@stage-labs/metro 0.1.0-beta.30 → 0.1.0-beta.301

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

@@ -0,0 +1,78 @@
+import { parseMailbox, pkcePair, SignInError } from '@metro-labs/core/stations/oauth';
+import { managedRequest, managedTokens } from '@metro-labs/gmail/managed';
+import { ApiError } from '@metro-labs/http/api-error';
+import { stringOf } from '@metro-labs/http/api-http';
+import type { AttachOwner } from './attach-session.js';
+import type { AttachOutcome, DriverHooks, StartedAttach } from './attach-driver.js';
+
+interface ManagedStart {
+  host: string;
+  owner: AttachOwner;
+  mailbox: unknown;
+  sendEnabled: boolean;
+  check: () => void;
+}
+
+function authorizationOf(owner: AttachOwner): string {
+  if (!owner.userId || !owner.sessionId || !owner.organization || !owner.authorization) throw new ApiError('Sign in to Metro again before connecting Gmail.', 401);
+  return owner.authorization;
+}
+
+function signInLink(started: Record<string, unknown>): { state: string; authorizeUrl: string; expiresAt: number } {
+  const state = stringOf(started.state);
+  const authorizeUrl = stringOf(started.authorizeUrl);
+  const url = new URL(authorizeUrl);
+  const expiresAt = started.expiresAt;
+  if (!state || url.origin !== 'https://accounts.google.com' || url.pathname !== '/o/oauth2/v2/auth' || url.searchParams.get('state') !== state || url.searchParams.get('redirect_uri') !== 'https://metro.box/' || typeof expiresAt !== 'number' || !Number.isFinite(expiresAt) || expiresAt <= Date.now()) throw new SignInError('Metro returned an invalid Gmail sign-in link.');
+  return { state, authorizeUrl, expiresAt };
+}
+
+function outcomeOf(result: Record<string, unknown>, input: ManagedStart, mailbox: string | null): AttachOutcome {
+  const accountEmail = parseMailbox(result.accountEmail);
+  if (accountEmail === null || (mailbox !== null && accountEmail !== mailbox) || result.managed !== true || result.managedHost !== input.host || result.sendEnabled !== input.sendEnabled) throw new SignInError('Metro returned a Gmail connection for a different mailbox or access level.');
+  return { config: { ...managedTokens(result), accountEmail, managed: true, managedHost: input.host, managedOrganization: input.owner.organization, sendEnabled: input.sendEnabled }, identity: { email: accountEmail } };
+}
+
+export async function startManagedGmail(input: ManagedStart, hooks: DriverHooks): Promise<StartedAttach> {
+  const { host, owner, sendEnabled, check } = input;
+  const bearer = authorizationOf(owner);
+  const pair = pkcePair();
+  const mailbox = parseMailbox(input.mailbox);
+  check();
+  const started = await managedRequest('start', { host, agentId: owner.agentId, challenge: pair.challenge, ...(mailbox === null ? {} : { mailbox }), sendEnabled }, bearer);
+  check();
+  const { state, authorizeUrl, expiresAt } = signInLink(started);
+  let cancelled = false;
+  let used = false;
+  return {
+    expiresAt,
+    prompt: { step: 'browser', prompt: sendEnabled ? 'Approve sending for this mailbox on Google. Metro write permissions stay unchanged.' : 'Choose a Google account and approve read-only Gmail access. Metro cannot send mail with this connection.', authorizeUrl },
+    driver: {
+      cancel: async () => {
+        cancelled = true;
+        await managedRequest('cancel', { state, host, agentId: owner.agentId }, bearer);
+      },
+      submit: async (value, authorization) => {
+        if (cancelled || used || Date.now() >= expiresAt) throw new ApiError('This sign-in is finished or expired. Start again.', 409);
+        if (stringOf(value.state) !== state) throw new ApiError('This sign-in belongs to another attempt.', 400);
+        if (!authorization) throw new ApiError('Sign in to Metro again.', 401);
+        used = true;
+        try {
+          if (stringOf(value.error)) {
+            await managedRequest('cancel', { state, host, agentId: owner.agentId }, authorization);
+            hooks.fail('Google sign-in was declined or blocked. Nothing was connected.');
+            return;
+          }
+          const code = stringOf(value.code);
+          if (!code) throw new ApiError('Google did not return a sign-in code.', 400);
+          check();
+          const result = await managedRequest('exchange', { state, code, verifier: pair.verifier, host, agentId: owner.agentId }, authorization);
+          check();
+          if (!cancelled) hooks.done(outcomeOf(result, input, mailbox));
+        } catch {
+          hooks.fail('Metro could not finish this Gmail sign-in. Start again.');
+        }
+      },
+    },
+  };
+}

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 { startGmail, startOutlook } from './attach-browser.js';
 
-export const INTERACTIVE_STATIONS = ['telegram', 'whatsapp'] as const;
+export const INTERACTIVE_STATIONS = ['telegram', 'whatsapp', 'outlook', 'gmail'] 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 =
@@ -155,6 +127,8 @@ export async function startInteractiveAttach(
   input: Record<string, unknown>,
   hooks: DriverHooks,
 ): Promise<StartedAttach> {
+  if (station === 'outlook') return startOutlook(input, hooks);
+  if (station === 'gmail') return startGmail(input, hooks);
   return station === 'telegram'
     ? startTelegramUser(input, hooks)
     : startWhatsapp(input, hooks);

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

@@ -2,18 +2,21 @@ import {
   assertAttachmentSize,
   assertContentLength,
   guessMime,
-  saveBufferToCache,
-} from './attachments.js';
+  MAX_ATTACHMENT_BYTES,
+} 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 +41,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 +58,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(
@@ -78,6 +106,49 @@ async function fromPath(
   };
 }
 
+export const curlArgs = (url: string): string[] => [
+  'curl', '-sS', '-f', '-L', '--max-redirs', '5', '--proto', '=http,https', '--proto-redir', '=http,https',
+  '--max-time', String(FETCH_TIMEOUT_MS / 1000), '--max-filesize', String(MAX_ATTACHMENT_BYTES),
+  '-w', '%{stderr}\n%{content_type}', '--', url,
+];
+
+interface CurlSaid {
+  type: string;
+  why: string;
+}
+
+function curlSaid(text: string): CurlSaid {
+  const lines = text.trimEnd().split('\n');
+  const type = lines.pop()?.split(';')[0]?.trim() ?? '';
+  return { type, why: lines.join(' ').replace(/^curl: \(\d+\)\s*/, '').trim() };
+}
+
+async function fromUrlAs(
+  user: AgentUser,
+  a: CanonicalAttachment,
+  url: string,
+): Promise<ResolvedAttachment> {
+  const proc = Bun.spawn(agentCommand(curlArgs(url)), { stdout: 'pipe', stderr: 'pipe' });
+  const name = a.name ?? basenameOf(url) ?? 'attachment';
+  const said = new Response(proc.stderr).text().catch((err: unknown) => {
+    log.debug({ err: String(err) }, 'send: could not read what curl said');
+    return '';
+  });
+  let saved: Awaited<ReturnType<typeof streamToTemp>>;
+  try {
+    saved = await streamToTemp(proc.stdout, name);
+  } catch (err) {
+    proc.kill();
+    throw err;
+  }
+  const { type, why } = curlSaid(await said);
+  if ((await proc.exited) !== 0) {
+    await removeInlineTemp(saved.dir);
+    throw new Error(`attachment fetch failed for '${url}' (fetched as the ${user.name} user): ${why || 'no answer'}`);
+  }
+  return { path: saved.path, mime: a.mime ?? (type || guessMime(url)), name, bytes: saved.bytes, temp: saved.dir };
+}
+
 async function fromUrl(
   a: CanonicalAttachment,
   url: string,
@@ -86,21 +157,20 @@ async function fromUrl(
     throw new Error(
       `attachment url '${url}' is not an http(s) url; use \`path\` for a local file`,
     );
+  const user = agentUser();
+  if (user !== null) return fromUrlAs(user, a, url);
   const res = await fetch(url, {
     signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
   });
   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 +221,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 +237,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,22 +1,24 @@
 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,
   input: Record<string, unknown>,
   hooks: DriverHooks,
+  owner: AttachOwner,
 ) => Promise<StartedAttach>;
 
 export const ATTACH_ID_RE = /^as_[A-Za-z0-9_-]{22}$/;
@@ -28,8 +30,11 @@ const MAX_PER_AGENT = 2;
 const MAX_TOTAL = 40;
 
 export interface AttachOwner {
-  email: string;
   agentId: string;
+  organization?: string;
+  userId?: string;
+  sessionId?: string;
+  authorization?: string;
 }
 
 export interface AttachView {
@@ -40,6 +45,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;
@@ -47,13 +55,14 @@ export interface AttachView {
   expiresAt: number;
 }
 
-export type CompleteAttach = (
+type CompleteAttach = (
   owner: AttachOwner,
   station: StationName,
   config: Record<string, unknown>,
+  active: () => boolean,
 ) => Promise<{ accountId: string; activated: boolean }>;
 
-export type AuthorizeAttach = (owner: AttachOwner) => Promise<void>;
+type AuthorizeAttach = (owner: AttachOwner) => Promise<void>;
 
 export interface AttachSessionDeps {
   authorize: AuthorizeAttach;
@@ -65,6 +74,8 @@ interface Session {
   owner: AttachOwner;
   driver: AttachDriver | null;
   view: AttachView;
+  finishing?: boolean;
+  committing?: boolean;
 }
 
 const missing = (): ApiError => new ApiError('no such attach session', 404);
@@ -82,6 +93,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 +122,8 @@ 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 === undefined || session.owner.agentId !== owner.agentId || session.owner.organization !== owner.organization || session.owner.userId !== owner.userId || session.owner.sessionId !== owner.sessionId) throw missing();
+    if (session.view.expiresAt <= Date.now()) throw new ApiError('this sign-in expired; start again', 410);
     return session;
   }
 
@@ -136,6 +147,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,
     });
@@ -148,12 +162,21 @@ export class AttachSessions {
     outcome: AttachOutcome,
   ): Promise<void> {
     const session = this.sessions.get(attachId);
-    if (session?.view.status !== 'pending') return;
+    const active = (): boolean => session !== undefined && this.sessions.get(attachId) === session && session.view.status === 'pending' && session.view.expiresAt > Date.now();
+    if (!active() || session === undefined || session.finishing === true) return;
+    session.finishing = true;
     try {
+      await this.deps.authorize(session.owner);
+      if (!active()) return;
       const landed = await this.deps.complete(
         session.owner,
         station,
         outcome.config,
+        () => {
+          if (!active()) return false;
+          session.committing = true;
+          return true;
+        },
       );
       this.settle(session, {
         status: 'done',
@@ -183,6 +206,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 +242,19 @@ export class AttachSessions {
     };
     this.sessions.set(attachId, session);
     try {
+      ensureStationDeps(station);
       const started = await (this.deps.start ?? startInteractiveAttach)(
         station,
         input,
         this.hooksFor(attachId, station),
+        owner,
       );
+      if (this.sessions.get(attachId) !== session || session.view.expiresAt <= Date.now()) {
+        await started.driver.cancel();
+        throw new ApiError('this sign-in expired or stopped; start again', 410);
+      }
       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,18 +274,21 @@ 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;
     if (session.view.status !== 'pending' || !driver)
       throw new ApiError('this sign-in is already finished', 409);
-    await driver.submit(input);
+    await this.deps.authorize(owner);
+    this.own(owner, attachId);
+    await driver.submit(input, owner.authorization);
     return { ...session.view };
   }
 
   async cancel(owner: AttachOwner, attachId: string): Promise<void> {
     const session = this.own(owner, attachId);
+    if (session.committing === true) throw new ApiError('this sign-in has already been saved', 409);
     this.sessions.delete(attachId);
     await session.driver?.cancel().catch(() => undefined);
     log.info({ attachId }, 'attach-session: cancelled');
@@ -260,7 +296,7 @@ export class AttachSessions {
 
   async sweep(now = Date.now()): Promise<void> {
     for (const [attachId, session] of [...this.sessions]) {
-      if (session.view.expiresAt > now) continue;
+      if (session.view.expiresAt > now || (session.committing === true && session.view.status === 'pending')) continue;
       this.sessions.delete(attachId);
       const driver = session.driver;
       session.driver = null;

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

@@ -1,7 +1,8 @@
 import { randomBytes } from 'node:crypto';
+import { stringOf } from '@metro-labs/http/api-http';
 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 {}
 
@@ -43,8 +44,6 @@ interface VerifyReply {
   error?: unknown;
 }
 
-const str = (value: unknown): string => (typeof value === 'string' ? value : '');
-
 function readReply(raw: string): VerifyReply {
   const line = raw.trim().split('\n').at(-1) ?? '';
   try {
@@ -89,7 +88,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);
@@ -97,13 +96,13 @@ export async function verifyXmtpKeyOutOfProcess(
   const reply = readReply(raw);
   if (reply.ok !== true)
     throw new XmtpAttachError(
-      withoutKey(str(reply.error) || UNREACHABLE, privateKey),
+      withoutKey(stringOf(reply.error) || UNREACHABLE, privateKey),
     );
   const identity = {
-    inboxId: str(reply.inboxId),
-    address: str(reply.address),
-    installationId: str(reply.installationId),
-    dbPath: str(reply.dbPath),
+    inboxId: stringOf(reply.inboxId),
+    address: stringOf(reply.address),
+    installationId: stringOf(reply.installationId),
+    dbPath: stringOf(reply.dbPath),
   };
   if (identity.inboxId === '' || identity.address === '')
     throw new XmtpAttachError(UNREACHABLE);