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

package/runtime/node_modules/@metro-labs/{mcp → 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/{mcp → daemon}/src/stations/attach-interactive.ts

@@ -1,39 +1,11 @@
 import { StationAttachError } from './attach.js';
+import type { DriverHooks, StartedAttach } from './attach-driver.js';
+import { startOutlook } from './attach-outlook.js';
 
-export const INTERACTIVE_STATIONS = ['telegram-user', 'whatsapp'] as const;
+export const INTERACTIVE_STATIONS = ['telegram', 'whatsapp', 'outlook'] as const;
 
 export type InteractiveStation = (typeof INTERACTIVE_STATIONS)[number];
 
-export type AttachStep = 'code' | 'password' | 'scan' | 'pair';
-
-export interface AttachPrompt {
-  step: AttachStep;
-  prompt: string;
-  qr?: string;
-  pairingCode?: string;
-}
-
-export interface AttachOutcome {
-  config: Record<string, unknown>;
-  identity: Record<string, string>;
-}
-
-export interface DriverHooks {
-  prompt: (p: AttachPrompt) => void;
-  done: (o: AttachOutcome) => void;
-  fail: (message: string) => void;
-}
-
-export interface AttachDriver {
-  submit: (input: { code?: unknown; password?: unknown }) => Promise<void>;
-  cancel: () => Promise<void>;
-}
-
-export interface StartedAttach {
-  driver: AttachDriver;
-  prompt: AttachPrompt;
-}
-
 const CODE_PROMPT =
   'Telegram sent a login code to that number. Enter it here.';
 const PASSWORD_PROMPT =
@@ -61,12 +33,12 @@ async function startTelegramUser(
   input: Record<string, unknown>,
   hooks: DriverHooks,
 ): Promise<StartedAttach> {
-  const { TelegramUserLogin, TelegramUserLoginError, validateCredentials } =
-    await import('@metro-labs/telegram-user/login');
-  const isOwn = (e: unknown): boolean => e instanceof TelegramUserLoginError;
+  const { TelegramLogin, TelegramLoginError, validateCredentials } =
+    await import('@metro-labs/telegram/login');
+  const isOwn = (e: unknown): boolean => e instanceof TelegramLoginError;
   let login;
   try {
-    login = new TelegramUserLogin(
+    login = new TelegramLogin(
       validateCredentials({
         apiId: input.apiId,
         apiHash: input.apiHash,
@@ -155,7 +127,8 @@ export async function startInteractiveAttach(
   input: Record<string, unknown>,
   hooks: DriverHooks,
 ): Promise<StartedAttach> {
-  return station === 'telegram-user'
+  if (station === 'outlook') return startOutlook(input, hooks);
+  return station === 'telegram'
     ? startTelegramUser(input, hooks)
     : startWhatsapp(input, hooks);
 }

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

@@ -0,0 +1,63 @@
+import type { OutlookLogin } from '@metro-labs/outlook/login';
+import { StationAttachError } from './attach.js';
+import type { DriverHooks, StartedAttach, StepInput } from './attach-driver.js';
+
+const BROWSER_PROMPT =
+  'Sign in with Microsoft in a new tab, with the mailbox this agent should read. This page updates on its own once you are done.';
+const DEVICE_PROMPT =
+  'Open the Microsoft sign-in page, type this code, and sign in with the mailbox this agent should read.';
+const OTHER_ATTEMPT = 'This sign-in link belongs to another attempt. Start again from the Channels page.';
+const BROWSER_TTL_MS = 15 * 60_000;
+
+const text = (v: unknown): string => (typeof v === 'string' ? v.trim() : '');
+
+export async function startOutlook(input: Record<string, unknown>, hooks: DriverHooks): Promise<StartedAttach> {
+  const { OutlookBrowserLogin, OutlookLogin: DeviceLogin, OutlookLoginError, failureOf, parseMailbox } = await import('@metro-labs/outlook/login');
+  const said = (err: unknown, fallback: string): string =>
+    err instanceof OutlookLoginError && err.message !== '' ? err.message : fallback;
+  const { browser, mailbox } = (() => {
+    try {
+      const wanted = parseMailbox(input.mailbox);
+      return { browser: new OutlookBrowserLogin({ mailbox: wanted }), mailbox: wanted };
+    } catch (err) {
+      throw new StationAttachError(said(err, 'Microsoft refused to start the sign-in'), 400);
+    }
+  })();
+  let device: OutlookLogin | null = null;
+
+  const toDevice = async (): Promise<void> => {
+    if (device !== null) return;
+    const login = new DeviceLogin({ onDone: hooks.done, onFailed: hooks.fail }, { mailbox });
+    const code = await login.start().catch((err: unknown) => {
+      throw new StationAttachError(said(err, 'Microsoft refused to start the sign-in'), 400);
+    });
+    device = login;
+    hooks.prompt({ step: 'device', prompt: DEVICE_PROMPT, userCode: code.userCode, verificationUri: code.verificationUri });
+  };
+
+  const finish = async (input: StepInput): Promise<void> => {
+    const state = text(input.state);
+    if (state !== browser.state) throw new StationAttachError(OTHER_ATTEMPT, 400);
+    const error = text(input.error);
+    if (error !== '') {
+      hooks.fail(failureOf({ error, error_description: text(input.errorDescription) }));
+      return;
+    }
+    const code = text(input.code);
+    if (code === '') throw new StationAttachError('Microsoft did not send a sign-in code back', 400);
+    try {
+      hooks.done(await browser.finish(code, state));
+    } catch (err) {
+      hooks.fail(said(err, 'Metro could not finish the Microsoft sign-in.'));
+    }
+  };
+
+  return {
+    prompt: { step: 'browser', prompt: BROWSER_PROMPT, authorizeUrl: browser.authorizeUrl },
+    expiresAt: Date.now() + BROWSER_TTL_MS,
+    driver: {
+      cancel: () => device?.cancel() ?? Promise.resolve(),
+      submit: (input) => (input.mode === 'device' ? toDevice() : finish(input)),
+    },
+  };
+}

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

@@ -2,18 +2,20 @@ import {
   assertAttachmentSize,
   assertContentLength,
   guessMime,
-  saveBufferToCache,
-} from './attachments.js';
+} from '@metro-labs/core/stations/attachments';
 import {
   assertInlineTotal,
   decodeInline,
   removeInlineTemp,
   splitInlineData,
+  streamToTemp,
   writeInlineTemp,
 } from './attach-inline.js';
 import { realpathSync } from 'node:fs';
-import { readUpload, UPLOAD_TTL_MS } from '../daemon/upload-store.js';
-import type { CanonicalAttachment } from './types.js';
+import { agentCommand, agentUser, type AgentUser } from '../agent-user/user.js';
+import { log } from '@metro-labs/core/log';
+import { readUpload, UPLOAD_TTL_MS } from '../files/upload-store.js';
+import type { CanonicalAttachment } from '@metro-labs/core/stations/types';
 
 export interface ResolvedAttachment {
   path: string;
@@ -38,8 +40,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 {
@@ -57,11 +57,38 @@ function assertReadablePath(path: string): void {
     );
 }
 
+async function fromPathAs(
+  user: AgentUser,
+  a: CanonicalAttachment,
+  path: string,
+): Promise<ResolvedAttachment> {
+  const proc = Bun.spawn(agentCommand(['cat', '--', path]), { stdout: 'pipe', stderr: 'pipe' });
+  const name = a.name ?? basenameOf(path) ?? 'attachment';
+  let saved: Awaited<ReturnType<typeof streamToTemp>>;
+  try {
+    saved = await streamToTemp(proc.stdout, name);
+  } catch (err) {
+    proc.kill();
+    throw err;
+  }
+  if ((await proc.exited) !== 0) {
+    await removeInlineTemp(saved.dir);
+    throw new Error(
+      `attachment path '${path}' cannot be read by the ${user.name} user Claude Code runs as. ` +
+        '`path` is read on the daemon machine with the agent\'s own rights; pass `upload` instead.',
+    );
+  }
+  assertAttachmentSize(saved.bytes);
+  return { path: saved.path, mime: a.mime ?? guessMime(path), name, bytes: saved.bytes, temp: saved.dir };
+}
+
 async function fromPath(
   a: CanonicalAttachment,
   path: string,
 ): Promise<ResolvedAttachment> {
   assertReadablePath(path);
+  const user = agentUser();
+  if (user !== null) return fromPathAs(user, a, path);
   const file = Bun.file(path);
   if (!(await file.exists()))
     throw new Error(
@@ -92,15 +119,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(
@@ -151,7 +175,7 @@ const sourcesOf = (a: CanonicalAttachment): string[] =>
     return typeof v === 'string' && v.length > 0;
   });
 
-export async function resolveAttachment(
+async function resolveAttachment(
   a: CanonicalAttachment,
   budget: InlineBudget = { used: 0 },
   opts: ResolveOptions = {},
@@ -167,6 +191,7 @@ export async function resolveAttachment(
         .map((s) => `\`${s}\``)
         .join(', ')}); pass exactly one of \`upload\`, \`data\`, \`url\` or \`path\``,
     );
+  log.info({ source: sources[0] }, 'send: attachment source');
   if (a.upload) return fromUpload(a, a.upload, opts.allowed);
   if (a.data) return fromData(a, a.data, budget);
   if (a.path) return fromPath(a, a.path);

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

@@ -1,17 +1,18 @@
 import { randomBytes } from 'node:crypto';
-import { ApiError } from './api-error.js';
-import { errMsg, log } from './log.js';
-import type { StationName } from '../db/schema.js';
-import {
-  startInteractiveAttach,
-  type AttachDriver,
-  type AttachOutcome,
-  type AttachPrompt,
-  type AttachStep,
-  type DriverHooks,
-  type InteractiveStation,
-  type StartedAttach,
-} from '../stations/attach-interactive.js';
+import { ApiError } from '@metro-labs/http/api-error';
+import { errMsg, log } from '@metro-labs/core/log';
+import type { StationName } from '@metro-labs/core/station-names';
+import { ensureStationDeps } from './runtime-deps.js';
+import { startInteractiveAttach, type InteractiveStation } from './attach-interactive.js';
+import type {
+  AttachDriver,
+  AttachOutcome,
+  AttachPrompt,
+  AttachStep,
+  DriverHooks,
+  StartedAttach,
+  StepInput,
+} from './attach-driver.js';
 
 export type StartAttach = (
   station: InteractiveStation,
@@ -28,7 +29,6 @@ const MAX_PER_AGENT = 2;
 const MAX_TOTAL = 40;
 
 export interface AttachOwner {
-  email: string;
   agentId: string;
 }
 
@@ -40,6 +40,9 @@ export interface AttachView {
   prompt: string;
   qr: string | null;
   pairingCode: string | null;
+  userCode: string | null;
+  verificationUri: string | null;
+  authorizeUrl: string | null;
   accountId: string | null;
   identity: Record<string, string>;
   activated: boolean;
@@ -82,6 +85,9 @@ function blankView(attachId: string, station: string): AttachView {
     prompt: '',
     qr: null,
     pairingCode: null,
+    userCode: null,
+    verificationUri: null,
+    authorizeUrl: null,
     accountId: null,
     identity: {},
     activated: false,
@@ -108,11 +114,7 @@ export class AttachSessions {
 
   private own(owner: AttachOwner, attachId: string): Session {
     const session = this.sessions.get(attachId);
-    if (
-      session?.owner.email !== owner.email ||
-      session.owner.agentId !== owner.agentId
-    )
-      throw missing();
+    if (session?.owner.agentId !== owner.agentId) throw missing();
     return session;
   }
 
@@ -136,6 +138,9 @@ export class AttachSessions {
     Object.assign(session.view, patch, {
       qr: null,
       pairingCode: null,
+      userCode: null,
+      verificationUri: null,
+      authorizeUrl: null,
       step: null,
       expiresAt: Date.now() + SETTLED_TTL_MS,
     });
@@ -183,6 +188,9 @@ export class AttachSessions {
         session.view.prompt = p.prompt;
         session.view.qr = p.qr ?? null;
         session.view.pairingCode = p.pairingCode ?? null;
+        session.view.userCode = p.userCode ?? null;
+        session.view.verificationUri = p.verificationUri ?? null;
+        session.view.authorizeUrl = p.authorizeUrl ?? null;
       },
       done: (o: AttachOutcome): void => {
         this.finish(attachId, station, o).catch((err: unknown) => {
@@ -216,12 +224,14 @@ export class AttachSessions {
     };
     this.sessions.set(attachId, session);
     try {
+      ensureStationDeps(station);
       const started = await (this.deps.start ?? startInteractiveAttach)(
         station,
         input,
         this.hooksFor(attachId, station),
       );
       session.driver = started.driver;
+      if (started.expiresAt !== undefined) session.view.expiresAt = started.expiresAt;
       this.hooksFor(attachId, station).prompt(started.prompt);
     } catch (err) {
       this.sessions.delete(attachId);
@@ -241,7 +251,7 @@ export class AttachSessions {
   async submit(
     owner: AttachOwner,
     attachId: string,
-    input: { code?: unknown; password?: unknown },
+    input: StepInput,
   ): Promise<AttachView> {
     const session = this.own(owner, attachId);
     const driver = session.driver;

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

@@ -1,7 +1,7 @@
 import { randomBytes } from 'node:crypto';
 import { rmSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
-import { errMsg, log } from '../daemon/log.js';
+import { errMsg, log } from '@metro-labs/core/log';
 
 export class XmtpAttachError extends Error {}
 
@@ -89,7 +89,7 @@ export async function verifyXmtpKeyOutOfProcess(
   dbPath: string,
 ): Promise<XmtpIdentity> {
   const raw = await runVerifier(
-    JSON.stringify({ privateKey, dbPath }),
+    JSON.stringify({ privateKey, dbPath, smart: true }),
   ).catch((err: unknown) => {
     log.warn({ err: errMsg(err) }, 'attach-xmtp: could not run the inbox check');
     throw new XmtpAttachError(UNREACHABLE);

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

@@ -2,13 +2,20 @@ import { randomBytes } from 'node:crypto';
 import {
   DiscordTokenError,
   verifyDiscordBotToken,
-} from '@metro-labs/discord/verify';
+} from '@metro-labs/discord-bot/verify';
 import {
   TelegramTokenError,
   verifyTelegramBotToken,
-} from '@metro-labs/telegram/verify';
-import { ApiError } from '../daemon/api-error.js';
-import { publicBaseOrDefault } from '../daemon/attach-serve.js';
+} from '@metro-labs/telegram-bot/verify';
+import {
+  parsePrivateKey,
+  ThreemaGatewayError,
+  verifyThreemaGateway,
+} from '@metro-labs/threema/verify';
+import { ApiError } from '@metro-labs/http/api-error';
+import { bodyField } from '@metro-labs/http/api-http';
+import { ensureStationDeps } from './runtime-deps.js';
+import { publicBaseOrDefault } from '../files/attach-serve.js';
 import {
   discardXmtpDb,
   newXmtpDbPath,
@@ -18,8 +25,9 @@ import {
 } from './attach-xmtp.js';
 
 export const ATTACHABLE_STATIONS = [
-  'discord',
-  'telegram',
+  'discord-bot',
+  'telegram-bot',
+  'threema',
   'xmtp',
   'webhook',
 ] as const;
@@ -31,6 +39,9 @@ export class StationAttachError extends ApiError {}
 export interface AttachInput {
   station: AttachStation;
   token?: unknown;
+  gatewayId?: unknown;
+  secret?: unknown;
+  privateKey?: unknown;
 }
 
 export interface OneTimeSecret {
@@ -52,6 +63,16 @@ const SECP256K1_ORDER = BigInt(
   '0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141',
 );
 
+export function attachInputOf(station: AttachStation, body: unknown): AttachInput {
+  return {
+    station,
+    token: bodyField(body, 'token'),
+    gatewayId: bodyField(body, 'gatewayId'),
+    secret: bodyField(body, 'secret'),
+    privateKey: bodyField(body, 'privateKey'),
+  };
+}
+
 export function isAttachStation(raw: unknown): raw is AttachStation {
   return (
     typeof raw === 'string' &&
@@ -137,7 +158,7 @@ async function prepareXmtp(verify: VerifyXmtpKey): Promise<PreparedAccount> {
     ),
   );
   return {
-    config: { privateKey, dbPath },
+    config: { privateKey, dbPath, smart: true },
     identity: { inboxId: identity.inboxId, address: identity.address },
     secret: {
       label: 'xmtp private key',
@@ -162,6 +183,49 @@ export function newWebhookId(): string {
   return String(WEBHOOK_ID_FLOOR + (raw % (9n * WEBHOOK_ID_FLOOR)));
 }
 
+export const threemaCallbackUrl = (callbackId: string, token: string): string =>
+  `${publicBaseOrDefault().replace(/\/+$/, '')}/api/threema/${callbackId}/${token}`;
+
+function requireText(raw: unknown, label: string): string {
+  const text = typeof raw === 'string' ? raw.trim() : '';
+  if (text === '')
+    throw new StationAttachError(`the Threema ${label} is required`, 400);
+  return text;
+}
+
+async function prepareThreema(input: AttachInput): Promise<PreparedAccount> {
+  const gatewayId = requireText(input.gatewayId, 'Gateway ID');
+  const secret = requireText(input.secret, 'API secret');
+  const privateKey = requireText(input.privateKey, 'private key');
+  try {
+    const identity = await verifyThreemaGateway({ gatewayId, secret, privateKey });
+    const callbackId = newWebhookId();
+    const callbackToken = randomBytes(48).toString('base64url');
+    return {
+      config: {
+        gatewayId: identity.gatewayId,
+        secret,
+        privateKey: parsePrivateKey(privateKey) ?? privateKey,
+        callbackId,
+        callbackToken,
+        createdAt: new Date().toISOString(),
+      },
+      identity: {
+        gatewayId: identity.gatewayId,
+        credits: String(identity.credits),
+        callback: threemaCallbackUrl(callbackId, callbackToken),
+      },
+    };
+  } catch (err) {
+    if (err instanceof StationAttachError) throw err;
+    return rejected(
+      err,
+      err instanceof ThreemaGatewayError,
+      'Threema rejected those Gateway credentials',
+    );
+  }
+}
+
 function prepareWebhook(): PreparedAccount {
   const secret = randomBytes(48).toString('base64url');
   const webhookId = newWebhookId();
@@ -175,8 +239,10 @@ export async function prepareAccount(
   input: AttachInput,
   verify: VerifyXmtpKey = verifyXmtpKeyOutOfProcess,
 ): Promise<PreparedAccount> {
-  if (input.station === 'discord') return prepareDiscord(input.token);
-  if (input.station === 'telegram') return prepareTelegram(input.token);
+  ensureStationDeps(input.station);
+  if (input.station === 'discord-bot') return prepareDiscord(input.token);
+  if (input.station === 'telegram-bot') return prepareTelegram(input.token);
   if (input.station === 'webhook') return prepareWebhook();
+  if (input.station === 'threema') return prepareThreema(input);
   return prepareXmtp(verify);
 }