@stage-labs/metro 0.1.0-beta.170 → 0.1.0-beta.172

package/runtime/node_modules/@metro-labs/daemon/src/gateway/model-signin.ts

@@ -5,10 +5,10 @@ import { isRecord } from '@metro-labs/core/is-record';
 import { errMsg, log } from '@metro-labs/core/log';
 import { beginLogin, finishLogin, readCodexCliAuth, type CodexTokens } from './codex-auth.js';
 import { beginDeviceLogin, pollDeviceLogin } from './codex-device.js';
-import { codexModels, currentTokens, freshCodexState } from './codex.js';
+import { codexModels, currentTokens, sharedCodexState } from './codex.js';
 import { beginLogin as beginGeminiLogin, exchangeCode as exchangeGeminiCode, userEmail, type GeminiTokens } from './gemini-auth.js';
 import { onboard, parseGeminiProject } from './gemini-setup.js';
-import { currentGeminiTokens, freshGeminiState, listGeminiModels, type GeminiDeps } from './gemini.js';
+import { currentGeminiTokens, listGeminiModels, sharedGeminiState, type GeminiDeps } from './gemini.js';
 import { openrouterCredits } from './openrouter.js';
 import { lastServed } from './served.js';
 import { geminiUsage, noteUsage, openrouterUsage, usageOf } from './usage.js';
@@ -23,8 +23,6 @@ import {
 } from './model-config.js';
 import { asApiError, askedConnection, BODY_MAX, connectionFor, CREDITS_TTL_MS, settingsBody, type ModelApiDeps, type Route, type Store } from './model-store.js';
 
-const codexState = freshCodexState();
-const geminiState = freshGeminiState();
 
 function connectionToFill(store: Store, req: IncomingMessage, provider: Provider): { cfg: ModelConfig; id: string } {
   const asked = askedConnection(req);
@@ -100,7 +98,7 @@ export const CODEX_ROUTES: Record<string, Route> = {
       const conn = connectionFor(store.read(), req, 'codex');
       if (conn.codex === null) throw new ApiError('this connection is not signed in yet', 400);
       const codexDeps = codexDepsFor(deps, store, conn.id);
-      const auth = await currentTokens(conn, codexDeps, codexState).catch(asApiError);
+      const auth = await currentTokens(conn, codexDeps, sharedCodexState).catch(asApiError);
       return { models: await codexModels(auth, codexDeps).catch(asApiError) };
     },
   },
@@ -117,7 +115,7 @@ export const geminiDeps = (deps: ModelApiDeps, store: Store): GeminiDeps => ({
 
 async function geminiModelsOf(conn: Connection, deps: ModelApiDeps, store: Store): Promise<Awaited<ReturnType<typeof listGeminiModels>>> {
   if (conn.gemini === null) throw new ApiError('this connection is not signed in yet', 400);
-  const tokens = await currentGeminiTokens(conn, geminiDeps(deps, store), geminiState);
+  const tokens = await currentGeminiTokens(conn, geminiDeps(deps, store), sharedGeminiState);
   return listGeminiModels(tokens, geminiDeps(deps, store));
 }
 

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

@@ -55,7 +55,7 @@ export function registerPermissionRelay(deps: PermissionRelayDeps): void {
         );
         return;
       }
-      relay.registerPermission(params.request_id);
+      relay.registerPermission(params.request_id, line);
       try {
         await metroSend(line, promptBody(params));
       } catch (e) {

package/runtime/node_modules/@metro-labs/daemon/src/stations/attach-inline.ts

@@ -1,4 +1,5 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { mkdtemp, open, rm, writeFile } from 'node:fs/promises';
+import { assertAttachmentSize } from '@metro-labs/core/stations/attachments';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
@@ -98,3 +99,30 @@ export async function writeInlineTemp(
 
 export const removeInlineTemp = (dir: string): Promise<void> =>
   rm(dir, { recursive: true, force: true });
+
+export async function streamToTemp(
+  body: ReadableStream<Uint8Array>,
+  name: string | undefined,
+): Promise<InlineTemp & { bytes: number }> {
+  const dir = await mkdtemp(join(tmpdir(), INLINE_TEMP_PREFIX));
+  const path = join(dir, safeFileName(name));
+  const handle = await open(path, 'wx', 0o600);
+  const reader = body.getReader();
+  let bytes = 0;
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      bytes += value.length;
+      assertAttachmentSize(bytes);
+      await handle.write(value);
+    }
+  } catch (err) {
+    await reader.cancel().catch(() => undefined);
+    await handle.close();
+    await removeInlineTemp(dir);
+    throw err;
+  }
+  await handle.close();
+  return { dir, path, bytes };
+}

package/runtime/node_modules/@metro-labs/daemon/src/stations/attach-resolve.ts

@@ -2,13 +2,13 @@ import {
   assertAttachmentSize,
   assertContentLength,
   guessMime,
-  saveBufferToCache,
 } from '@metro-labs/core/stations/attachments';
 import {
   assertInlineTotal,
   decodeInline,
   removeInlineTemp,
   splitInlineData,
+  streamToTemp,
   writeInlineTemp,
 } from './attach-inline.js';
 import { realpathSync } from 'node:fs';
@@ -39,8 +39,6 @@ const basenameOf = (src: string): string =>
 
 const isHttpUrl = (src: string): boolean => /^https?:\/\//i.test(src);
 
-const mintId = (): string => Math.random().toString(36).slice(2, 12);
-
 const HIDDEN_SEGMENT = /(^|\/)\.[^/]/;
 
 function assertReadablePath(path: string): void {
@@ -93,15 +91,12 @@ async function fromUrl(
   if (!res.ok)
     throw new Error(`attachment fetch failed ${res.status} for '${url}'`);
   assertContentLength(res.headers.get('content-length'));
-  const data = new Uint8Array(await res.arrayBuffer());
   const mime =
     a.mime ?? res.headers.get('content-type')?.split(';')[0] ?? guessMime(url);
   const name = a.name ?? basenameOf(url) ?? 'attachment';
-  const saved = await saveBufferToCache(data, `out${mintId()}`, 0, {
-    mime,
-    name,
-  });
-  return { path: saved.path, mime, name, bytes: data.length };
+  if (res.body === null) throw new Error(`attachment fetch returned no body for '${url}'`);
+  const { dir, path, bytes } = await streamToTemp(res.body, name);
+  return { path, mime, name, bytes, temp: dir };
 }
 
 async function fromData(

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

@@ -1,20 +1,13 @@
+import type { Message } from 'discord.js';
 import {
-  ActivityType,
-  type Message,
-  type PresenceStatusData,
-} from 'discord.js';
-import {
-  accountFor,
   accounts,
   encodeEmoji,
-  lineOf,
   rest,
   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 { assertContentLength } from '@metro-labs/core/stations/attachments';
 import {
   appendFiles,
   outgoingFiles,
@@ -111,38 +104,6 @@ async function send(id: string, args: Record<string, unknown>): Promise<void> {
   });
 }
 
-function presence(id: string, args: Record<string, unknown>): void {
-  const {
-    text,
-    status = 'online',
-    account,
-  } = args as {
-    text?: string;
-    status?: PresenceStatusData;
-    account?: string;
-  };
-  const accountId = accountFor({ account });
-  const acct = accounts.get(accountId);
-  if (!acct) {
-    respond(id, { error: `unknown account '${accountId}'` });
-    return;
-  }
-  const client = acct.client;
-  if (!client.user) {
-    respond(id, { error: `gateway not ready for account '${accountId}'` });
-    return;
-  }
-  client.user.setPresence({
-    status,
-    activities: text
-      ? [{ name: 'Custom Status', type: ActivityType.Custom, state: text }]
-      : [],
-  });
-  respond(id, {
-    result: { ok: true, text: text ?? null, status, account: accountId },
-  });
-}
-
 const profileUrl = (userId?: string): string | null =>
   userId === undefined ? null : `https://discord.com/users/${userId}`;
 
@@ -245,104 +206,6 @@ async function fetchMessages(
   respond(id, { result: { messages: msgs, account: accountId } });
 }
 
-async function download(
-  id: string,
-  args: Record<string, unknown>,
-): Promise<void> {
-  const {
-    line,
-    messageId,
-    outDir = '/tmp',
-    account,
-  } = args as {
-    line: string;
-    messageId: string;
-    outDir?: string;
-    account?: string;
-  };
-  const { accountId, channelId } = routeOf(line, account);
-  const msg = await rest<{
-    attachments: { url: string; content_type?: string; filename: string }[];
-  }>(accountId, 'GET', `/channels/${channelId}/messages/${messageId}`);
-  const files: { path: string; mediaType: string }[] = [];
-  for (const att of msg.attachments) {
-    const res = await fetch(att.url, { signal: AbortSignal.timeout(60_000) });
-    if (!res.ok)
-      throw new Error(`discord-bot download ${res.status} for ${att.url}`);
-    assertContentLength(res.headers.get('content-length'));
-    const buf = await res.arrayBuffer();
-    const path = `${outDir}/${messageId}-${att.filename}`;
-    await Bun.write(path, buf);
-    files.push({
-      path,
-      mediaType: att.content_type ?? 'application/octet-stream',
-    });
-  }
-  respond(id, { result: { files, account: accountId } });
-}
-
-async function threadCreate(
-  id: string,
-  args: Record<string, unknown>,
-): Promise<void> {
-  const {
-    line,
-    messageId,
-    name,
-    autoArchiveDuration = 1440,
-    account,
-  } = args as {
-    line: string;
-    messageId?: string;
-    name: string;
-    autoArchiveDuration?: number;
-    account?: string;
-  };
-  const { accountId, channelId } = routeOf(line, account);
-  const path = messageId
-    ? `/channels/${channelId}/messages/${messageId}/threads`
-    : `/channels/${channelId}/threads`;
-  const res = await rest<{ id: string }>(accountId, 'POST', path, {
-    name,
-    auto_archive_duration: autoArchiveDuration,
-  });
-  respond(id, {
-    result: {
-      threadId: res.id,
-      line: lineOf(accountId, res.id),
-      account: accountId,
-    },
-  });
-}
-
-async function pin(id: string, args: Record<string, unknown>): Promise<void> {
-  const { line, messageId, account } = args as {
-    line: string;
-    messageId: string;
-    account?: string;
-  };
-  const { accountId, channelId } = routeOf(line, account);
-  await rest(accountId, 'PUT', `/channels/${channelId}/pins/${messageId}`);
-  respond(id, { result: { ok: true, account: accountId } });
-}
-
-async function typing(id: string, args: Record<string, unknown>): Promise<void> {
-  const { line, account } = args as { line: string; account?: string };
-  const { accountId, channelId } = routeOf(line, account);
-  await rest(accountId, 'POST', `/channels/${channelId}/typing`);
-  respond(id, { result: { ok: true, account: accountId } });
-}
-
-async function channel(
-  id: string,
-  args: Record<string, unknown>,
-): Promise<void> {
-  const { line, account } = args as { line: string; account?: string };
-  const { accountId, channelId } = routeOf(line, account);
-  const res = await rest(accountId, 'GET', `/channels/${channelId}`);
-  respond(id, { result: res });
-}
-
 async function listMembers(
   id: string,
   args: Record<string, unknown>,
@@ -369,13 +232,7 @@ const HANDLERS: Record<string, StationHandler> = {
   edit,
   delete: remove,
   fetch: fetchMessages,
-  download,
-  thread_create: threadCreate,
-  pin,
-  typing,
-  channel,
   listMembers,
-  set_presence: presence,
   set_profile: setProfile,
   profile: readProfile,
   joinVoice,

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

@@ -44,11 +44,20 @@ function emitAttachmentSaved(
         },
       });
     })
-    .catch((err: unknown) =>
-      process.stderr.write(
-        `discord-bot attachment save failed: ${err instanceof Error ? err.message : String(err)}\n`,
-      ),
-    );
+    .catch((err: unknown) => {
+      const reason = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`discord-bot attachment save failed: ${reason}\n`);
+      emitInbound(accountId, {
+        kind: 'inbound',
+        id: mintId(),
+        ts: new Date().toISOString(),
+        station: 'discord-bot',
+        line,
+        from: SELF_URI,
+        text: `📎 not fetched: ${reason}`,
+        payload: { contentType: 'attachmentFailed', attachmentFor: sourceMsgId, index, name: ref.name ?? undefined, mime: ref.contentType ?? undefined, reason },
+      });
+    });
 }
 
 const AV_TAG: Record<string, string> = { audio: 'audio', video: 'video' };

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

@@ -123,6 +123,25 @@ export function attachmentSavedEnvelope(
   };
 }
 
+export function attachmentFailedEnvelope(
+  accountId: string,
+  line: string,
+  sourceEnvId: string,
+  reason: string,
+  index = 0,
+): Record<string, unknown> {
+  return {
+    kind: 'inbound',
+    id: mintId(),
+    ts: new Date().toISOString(),
+    station: 'telegram',
+    line,
+    from: `metro://telegram/${accountId}/self`,
+    text: `📎 not fetched: ${reason}`,
+    payload: { account: accountId, contentType: 'attachmentFailed', attachmentFor: sourceEnvId, index, reason },
+  };
+}
+
 export interface ReactionInput {
   accountId: string;
   chatId: number;

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

@@ -1,7 +1,7 @@
 import type { Message } from '@mtcute/bun';
 import { errMsg, log } from '@metro-labs/core/log';
 import { emit } from './wire.js';
-import { envelope, isOwnEcho, attachmentSavedEnvelope } from './format.js';
+import { envelope, isOwnEcho, attachmentFailedEnvelope, attachmentSavedEnvelope } from './format.js';
 import { downloadMedia, isDownloadable } from './attachments.js';
 import { subscribeReactions } from './reactions.js';
 import type { UserClient } from './client.js';
@@ -28,6 +28,7 @@ async function saveMediaAndEmit(
     process.stderr.write(
       `telegram[${accountId}] media save failed: ${errMsg(e)}\n`,
     );
+    emit(attachmentFailedEnvelope(accountId, env.line as string, env.id as string, errMsg(e)));
   }
 }
 

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

@@ -1,4 +1,4 @@
-import { accountFor, accounts, tg, targetOf } from './accounts.js';
+import { accounts, tg, targetOf } from './accounts.js';
 import { respond } from './wire.js';
 import { errMsg } from '@metro-labs/core/log';
 import { normalizeTelegram } from '@metro-labs/core/stations/messaging-normalize';
@@ -13,21 +13,14 @@ import {
   type StationHandler,
 } from '@metro-labs/core/stations/station-runtime';
 import { mediaKindOf } from './attachments.js';
-import { assertContentLength } from '@metro-labs/core/stations/attachments';
 import {
   emitOutbound,
   finishSend,
-  media,
   MEDIA_METHOD_FIELD,
-  sendDice,
-  sendLocation,
   sendMedia,
 } from './media-actions.js';
 import { readProfile, setProfile } from './profile.js';
 
-
-
-
 export type { CallMsg };
 
 const meCache = new Map<string, { id: number; username: string | null }>();
@@ -211,34 +204,6 @@ async function remove(id: string, args: Record<string, unknown>): Promise<void>
   respond(id, { result: { ok: true, account: accountId } });
 }
 
-
-
-async function download(id: string, args: Record<string, unknown>): Promise<void> {
-  const {
-    fileId,
-    outDir = '/tmp',
-    account,
-  } = args as { fileId: string; outDir?: string; account?: string };
-  const accountId = accountFor({ account });
-  const acct = accounts.get(accountId);
-  if (!acct) throw new Error(`unknown account '${accountId}'`);
-  const meta = await tg<{ file_path: string }>(accountId, 'getFile', {
-    file_id: fileId,
-  });
-  const res = await fetch(`${acct.fileApi}/${meta.file_path}`, {
-    signal: AbortSignal.timeout(60_000),
-  });
-  if (!res.ok) throw new Error(`telegram-bot download ${res.status}`);
-  assertContentLength(res.headers.get('content-length'));
-  const data = await res.arrayBuffer();
-  const filename = meta.file_path.split('/').pop() ?? `${fileId}.bin`;
-  const path = `${outDir}/${Date.now()}-${filename}`;
-  await Bun.write(path, data);
-  respond(id, {
-    result: { path, fileSize: data.byteLength, account: accountId },
-  });
-}
-
 async function listMembers(
   id: string,
   args: Record<string, unknown>,
@@ -274,15 +239,6 @@ const HANDLERS: Record<string, StationHandler> = {
   listMembers,
   set_profile: setProfile,
   profile: readProfile,
-  send_photo: (id, args) =>
-    media(id, 'sendPhoto', 'photo', ((args.caption as string) ?? '') + ' [image]', args),
-  send_document: (id, args) =>
-    media(id, 'sendDocument', 'document', ((args.caption as string) ?? '') + ' [file]', args),
-  send_voice: (id, args) => media(id, 'sendVoice', 'voice', '[voice]', args),
-  send_sticker: (id, args) => media(id, 'sendSticker', 'sticker', '[sticker]', args),
-  send_dice: sendDice,
-  send_location: sendLocation,
-  download,
 };
 
 export const handleCall = makeStation({

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

@@ -198,9 +198,17 @@ export function saveMediaAndEmit(
         },
       });
     })
-    .catch((err: unknown) =>
-      process.stderr.write(
-        `telegram-bot media save failed: ${errMsg(err)}\n`,
-      ),
-    );
+    .catch((err: unknown) => {
+      process.stderr.write(`telegram-bot media save failed: ${errMsg(err)}\n`);
+      emitInbound(emit, accountId, {
+        kind: 'inbound',
+        id: mintId(),
+        ts: new Date().toISOString(),
+        station: 'telegram-bot',
+        line,
+        from: SELF_URI || `metro://telegram-bot/${accountId}/self`,
+        text: `📎 not fetched: ${errMsg(err)}`,
+        payload: { contentType: 'attachmentFailed', attachmentFor: sourceEnvId, index: 0, reason: errMsg(err) },
+      });
+    });
 }

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

@@ -1,4 +1,4 @@
-import { tg, tgForm, targetOf } from './accounts.js';
+import { tgForm, targetOf } from './accounts.js';
 import { emit, mintId, respond, SELF_URI } from './wire.js';
 import { appendFile } from '@metro-labs/core/stations/attachments';
 
@@ -82,25 +82,6 @@ export async function sendMedia(
   return { accountId, message_id: r.message_id };
 }
 
-export async function media(
-  id: string,
-  method: string,
-  field: string,
-  label: string,
-  args: Record<string, unknown>,
-): Promise<void> {
-  const { accountId, message_id } = await sendMedia(method, field, args);
-  const line = (args as { line: string }).line;
-  finishSend(
-    id,
-    accountId,
-    line,
-    String(message_id),
-    label,
-    args.replyTo as string | undefined,
-  );
-}
-
 export const MEDIA_METHOD_FIELD: Record<
   string,
   { method: string; field: string }
@@ -111,56 +92,3 @@ export const MEDIA_METHOD_FIELD: Record<
   video: { method: 'sendVideo', field: 'video' },
   document: { method: 'sendDocument', field: 'document' },
 };
-
-export async function sendDice(
-  id: string,
-  args: Record<string, unknown>,
-): Promise<void> {
-  const {
-    line,
-    emoji = '\U0001F3B2',
-    account,
-  } = args as { line: string; emoji?: string; account?: string };
-  const { accountId, chatId, topicId } = targetOf(line, account);
-  const body: Record<string, unknown> = { chat_id: chatId, emoji };
-  if (topicId !== undefined) body.message_thread_id = topicId;
-  const r = await tg<{ message_id: number; dice?: { value: number } }>(
-    accountId,
-    'sendDice',
-    body,
-  );
-  finishSend(
-    id,
-    accountId,
-    line,
-    String(r.message_id),
-    `[dice ${emoji} = ${r.dice?.value ?? '?'}]`,
-    undefined,
-    { value: r.dice?.value },
-  );
-}
-
-export async function sendLocation(
-  id: string,
-  args: Record<string, unknown>,
-): Promise<void> {
-  const { line, latitude, longitude, account } = args as {
-    line: string;
-    latitude: number;
-    longitude: number;
-    account?: string;
-  };
-  const { accountId, chatId } = targetOf(line, account);
-  const r = await tg<{ message_id: number }>(accountId, 'sendLocation', {
-    chat_id: chatId,
-    latitude,
-    longitude,
-  });
-  finishSend(
-    id,
-    accountId,
-    line,
-    String(r.message_id),
-    `[location: ${latitude}, ${longitude}]`,
-  );
-}

package/runtime/node_modules/@metro-labs/xmtp/package.json

@@ -18,7 +18,6 @@
     "@xmtp/content-type-reaction": "^2.0.2",
     "@xmtp/content-type-remote-attachment": "^2.0.4",
     "@xmtp/content-type-reply": "^2.0.3",
-    "@xmtp/content-type-wallet-send-calls": "^2.0.0",
     "@xmtp/node-bindings": "1.9.1",
     "@xmtp/node-sdk": "^6.0.0",
     "@zerodev/ecdsa-validator": "5.4.9",