@stage-labs/metro 0.1.0-beta.32 → 0.1.0-beta.321

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

@@ -0,0 +1,107 @@
+import { SignInError, parseMailbox } from '@metro-labs/core/stations/oauth';
+import { StationAttachError } from './attach.js';
+import type { AttachOutcome, DriverHooks, StartedAttach, StepInput } from './attach-driver.js';
+
+const OUTLOOK_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 GMAIL_PROMPT =
+  'Sign in with Google 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;
+
+interface BrowserLogin {
+  state: string;
+  authorizeUrl: string;
+  finish: (code: string, state: string) => Promise<AttachOutcome>;
+}
+
+interface BrowserAttach {
+  provider: string;
+  prompt: string;
+  failure: (body: Record<string, unknown>) => string;
+  device?: () => Promise<void>;
+  cancel?: () => Promise<void>;
+}
+
+const text = (v: unknown): string => (typeof v === 'string' ? v.trim() : '');
+
+const said = (err: unknown, fallback: string): string => (err instanceof SignInError && err.message !== '' ? err.message : fallback);
+
+function refused(err: unknown, provider: string): StationAttachError {
+  return new StationAttachError(said(err, `${provider} refused to start the sign-in`), 400);
+}
+
+function browserAttach(login: BrowserLogin, hooks: DriverHooks, how: BrowserAttach): StartedAttach {
+  let cancelled = false;
+  const finish = async (input: StepInput): Promise<void> => {
+    const state = text(input.state);
+    if (state !== login.state) throw new StationAttachError(OTHER_ATTEMPT, 400);
+    const error = text(input.error);
+    if (error !== '') {
+      hooks.fail(how.failure({ error, error_description: text(input.errorDescription) }));
+      return;
+    }
+    const code = text(input.code);
+    if (code === '') throw new StationAttachError(`${how.provider} did not send a sign-in code back`, 400);
+    try {
+      const outcome = await login.finish(code, state);
+      if (!cancelled) hooks.done(outcome);
+    } catch (err) {
+      hooks.fail(said(err, `Metro could not finish the ${how.provider} sign-in.`));
+    }
+  };
+  const device = how.device;
+  return {
+    prompt: { step: 'browser', prompt: how.prompt, authorizeUrl: login.authorizeUrl },
+    expiresAt: Date.now() + BROWSER_TTL_MS,
+    driver: {
+      cancel: () => {
+        cancelled = true;
+        return how.cancel?.() ?? Promise.resolve();
+      },
+      submit: (input) => (input.mode === 'device' && device !== undefined ? device() : finish(input)),
+    },
+  };
+}
+
+export async function startOutlook(input: Record<string, unknown>, hooks: DriverHooks): Promise<StartedAttach> {
+  const { OutlookBrowserLogin, OutlookLogin: DeviceLogin, failureOf } = await import('@metro-labs/outlook/login');
+  const { browser, mailbox } = (() => {
+    try {
+      const wanted = parseMailbox(input.mailbox);
+      return { browser: new OutlookBrowserLogin({ mailbox: wanted }), mailbox: wanted };
+    } catch (err) {
+      throw refused(err, 'Microsoft');
+    }
+  })();
+  let device: InstanceType<typeof DeviceLogin> | 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 refused(err, 'Microsoft');
+    });
+    device = login;
+    hooks.prompt({ step: 'device', prompt: DEVICE_PROMPT, userCode: code.userCode, verificationUri: code.verificationUri });
+  };
+  return browserAttach(browser, hooks, {
+    provider: 'Microsoft',
+    prompt: OUTLOOK_PROMPT,
+    failure: (body) => failureOf(body),
+    device: toDevice,
+    cancel: () => device?.cancel() ?? Promise.resolve(),
+  });
+}
+
+export async function startGmail(input: Record<string, unknown>, hooks: DriverHooks): Promise<StartedAttach> {
+  const { GmailBrowserLogin, failureOf } = await import('@metro-labs/gmail/login');
+  let login;
+  try {
+    login = new GmailBrowserLogin({ clientId: input.clientId, clientSecret: input.clientSecret, mailbox: input.mailbox, sendEnabled: input.sendEnabled === true });
+  } catch (err) {
+    throw refused(err, 'Google');
+  }
+  return browserAttach(login, hooks, { provider: 'Google', prompt: GMAIL_PROMPT, failure: failureOf });
+}

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

@@ -0,0 +1,42 @@
+export type AttachStep = 'code' | 'password' | 'scan' | 'pair' | 'device' | 'browser';
+
+export interface AttachPrompt {
+  step: AttachStep;
+  prompt: string;
+  qr?: string;
+  pairingCode?: string;
+  userCode?: string;
+  verificationUri?: string;
+  authorizeUrl?: 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 StepInput {
+  code?: unknown;
+  password?: unknown;
+  state?: unknown;
+  mode?: unknown;
+  error?: unknown;
+  errorDescription?: unknown;
+}
+
+export interface AttachDriver {
+  submit: (input: StepInput, authorization?: string) => Promise<void>;
+  cancel: () => Promise<void>;
+}
+
+export interface StartedAttach {
+  driver: AttachDriver;
+  prompt: AttachPrompt;
+  expiresAt?: number;
+}

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 =
@@ -125,7 +97,7 @@ async function startWhatsapp(
       },
       onPaired: hooks.done,
       onFailed: hooks.fail,
-    });
+    }, normalizePhone(input.expect));
     await login.start();
   } catch (err) {
     await login?.cancel();
@@ -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);