@stage-labs/metro 0.1.0-beta.219 → 0.1.0-beta.220

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.219",
+  "version": "0.1.0-beta.220",
   "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.219",
+  "version": "0.1.0-beta.220",
   "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

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

@@ -23,6 +23,10 @@
     "./stations/station-runtime": "./src/stations/station-runtime.ts",
     "./stations/account-store": "./src/stations/account-store.ts",
     "./stations/attachments": "./src/stations/attachments.ts",
+    "./stations/mail": "./src/stations/mail.ts",
+    "./stations/mail-text": "./src/stations/mail-text.ts",
+    "./stations/mail-trust": "./src/stations/mail-trust.ts",
+    "./stations/oauth": "./src/stations/oauth.ts",
     "./stations/messaging-normalize": "./src/stations/messaging-normalize.ts",
     "./stations/profile": "./src/stations/profile.ts",
     "./stations/sender-profile": "./src/stations/sender-profile.ts",

package/runtime/node_modules/@metro-labs/core/src/lines.ts

@@ -21,7 +21,7 @@ function parseAccountScoped(
 const isSnowflake = (s: string): boolean => /^\d+$/.test(s);
 const isThreemaResource = (s: string): boolean =>
   /^(?:[A-Z0-9]{8}|\*[A-Z0-9]{7})(?:-[0-9a-f]{16})?$/i.test(s);
-const isOutlookResource = (s: string): boolean => /^[A-Za-z0-9=_%.@+-]+$/.test(s);
+const isMailResource = (s: string): boolean => /^[A-Za-z0-9=_%.@+-]+$/.test(s);
 const isSignedInt = (s: string): boolean => /^-?\d+$/.test(s);
 
 const topicPart = (topicId: string | undefined): { topicId?: number } | null => {
@@ -73,6 +73,6 @@ export const Line = {
   parseThreema: (line: Line | string) =>
     parseAccountScoped(line, 'threema', isThreemaResource),
 
-  parseOutlook: (line: Line | string) =>
-    parseAccountScoped(line, 'outlook', isOutlookResource),
+  parseMail: (line: Line | string, station: 'outlook' | 'gmail') =>
+    parseAccountScoped(line, station, isMailResource),
 };

package/runtime/node_modules/@metro-labs/core/src/station-names.ts

@@ -6,6 +6,7 @@ export const STATIONS = [
   'whatsapp',
   'threema',
   'outlook',
+  'gmail',
   'webhook',
 ] as const;
 

package/runtime/node_modules/@metro-labs/core/src/stations/mail-trust.ts

@@ -0,0 +1,29 @@
+export interface MailHeader {
+  name?: string;
+  value?: string;
+}
+
+export type Screened = { skip: string } | { verified: boolean };
+
+const AUTOMATED_LOCAL = /^(no-?reply|do-?not-?reply|donotreply|mailer-daemon|notifications?)([+._-].*)?$/i;
+const BULK = new Set(['bulk', 'list', 'junk']);
+
+export const headerValues = (headers: MailHeader[], name: string): string[] =>
+  headers.filter((h) => (h.name ?? '').toLowerCase() === name).map((h) => (h.value ?? '').trim());
+
+export const firstHeader = (headers: MailHeader[], name: string): string | undefined => headerValues(headers, name)[0];
+
+export function automatedBySender(address: string): string | null {
+  const local = address.split('@')[0] ?? '';
+  return AUTOMATED_LOCAL.test(local) ? `sender ${address}` : null;
+}
+
+export function automatedByHeaders(headers: MailHeader[]): string | null {
+  if (firstHeader(headers, 'list-unsubscribe') !== undefined) return 'List-Unsubscribe';
+  const auto = firstHeader(headers, 'auto-submitted');
+  if (auto !== undefined && auto.toLowerCase() !== 'no') return `Auto-Submitted: ${auto}`;
+  const precedence = (firstHeader(headers, 'precedence') ?? '').toLowerCase();
+  return BULK.has(precedence) ? `Precedence: ${precedence}` : null;
+}
+
+export const domainOf = (address: string): string => (address.split('@')[1] ?? '').toLowerCase();

package/runtime/node_modules/@metro-labs/core/src/stations/mail.ts

@@ -0,0 +1,212 @@
+import { mintId } from '../ids.js';
+import { Line } from '../lines.js';
+import { TrainError } from '../train-error.js';
+import { capText } from './mail-text.js';
+
+export type MailStation = 'outlook' | 'gmail';
+
+type Args = Record<string, unknown>;
+
+export interface MailItem {
+  id: string;
+  threadId: string;
+  subject: string;
+  from: string;
+  fromName: string;
+  to: string[];
+  cc: string[];
+  date: string | null;
+  preview: string;
+  text: string;
+  hasAttachments: boolean;
+  isRead: boolean;
+  internetMessageId: string | null;
+}
+
+export interface AttachmentMeta {
+  kind: string;
+  name: string;
+  mime: string;
+  size?: number;
+}
+
+export interface OutgoingFile {
+  path: string;
+  mime: string;
+  name: string;
+}
+
+export interface ReadQuery {
+  threadId: string | null;
+  query: string;
+  from: string;
+  since: string;
+  until: string;
+  before: string;
+  unreadOnly: boolean;
+  limit: number;
+}
+
+export const DEFAULT_LIMIT = 20;
+export const MAX_LIMIT = 50;
+const SEEN_MAX = 500;
+const SUBJECT_MAX = 255;
+const ADDRESS_RE = /^[^@\s/]+@[^@\s/]+\.[^@\s/]+$/;
+
+export interface MailService {
+  station: MailStation;
+  company: string;
+  product: string;
+  api: string;
+  apiCode: string;
+}
+
+export function refusalOf(s: MailService, status: number, detail: string): TrainError {
+  const refuse = (code: string, text: string, retryable = false): TrainError => new TrainError(`${s.station}_${code}`, text, { retryable });
+  if (status === 401) return refuse('signed_out', `${s.company} refused this mailbox's sign-in (${detail}); connect ${s.product} again from the page`);
+  if (status === 403) return refuse('forbidden', `${s.company} does not let Metro do that on this mailbox (${detail})`);
+  if (status === 404) return refuse('not_found', `${s.product} has no such message or conversation (${detail})`);
+  if (status === 413) return refuse('too_large', `${s.product} refused the size of that request (${detail})`);
+  if (status === 429) return refuse('throttled', `${s.company} asked Metro to slow down (${detail}); try again in a minute`, true);
+  return refuse(s.apiCode, `${s.api} answered ${String(status)} (${detail})`, status >= 500);
+}
+
+export const str = (v: unknown): string => (typeof v === 'string' ? v.trim() : '');
+
+const encodeResource = (id: string): string => id.replace(/%/g, '%25').replace(/\//g, '%2F').replace(/\+/g, '%2B');
+
+export const mailLine = (station: MailStation, accountId: string, threadId: string): string =>
+  `metro://${station}/${accountId}/${encodeResource(threadId)}`;
+
+const mailUser = (station: MailStation, accountId: string, address: string): string =>
+  `metro://${station}/${accountId}/user/${address.toLowerCase()}`;
+
+export function threadOfLine(station: MailStation, line: string): { accountId: string; threadId: string } | null {
+  const parsed = Line.parseMail(line, station);
+  if (parsed === null) return null;
+  try {
+    return { accountId: parsed.accountId, threadId: decodeURIComponent(parsed.resource) };
+  } catch {
+    return null;
+  }
+}
+
+const isPrivateTo = (m: MailItem, self: string): boolean => m.to.length === 1 && m.to[0] === self && m.cc.length === 0;
+
+export function mailEnvelope(station: MailStation, accountId: string, self: string, m: MailItem, attachments: AttachmentMeta[], verified: boolean): Record<string, unknown> {
+  const body = capText(m.text);
+  return {
+    id: mintId(),
+    ts: m.date ?? new Date().toISOString(),
+    station,
+    line: mailLine(station, accountId, m.threadId),
+    line_name: m.subject === '' ? '(no subject)' : m.subject,
+    from: mailUser(station, accountId, m.from === '' ? 'unknown' : m.from),
+    from_name: m.fromName || m.from,
+    from_display_name: m.fromName || undefined,
+    message_id: m.id,
+    text: m.subject === '' ? body : `Subject: ${m.subject}\n\n${body}`,
+    is_private: isPrivateTo(m, self),
+    sender_verified: verified,
+    payload: {
+      from: m.from,
+      to: m.to,
+      cc: m.cc,
+      subject: m.subject,
+      internetMessageId: m.internetMessageId,
+      ...(attachments.length === 0 ? {} : { attachments }),
+    },
+  };
+}
+
+const heading = (station: MailStation, accountId: string, m: MailItem): Record<string, unknown> => ({
+  message_id: m.id,
+  line: mailLine(station, accountId, m.threadId),
+  from: m.from,
+  from_name: m.fromName,
+  date: m.date,
+  title: m.subject,
+});
+
+export const mailSummary = (station: MailStation, accountId: string, m: MailItem): Record<string, unknown> => ({
+  ...heading(station, accountId, m),
+  text_preview: m.preview,
+  has_attachments: m.hasAttachments,
+  is_read: m.isRead,
+});
+
+export const mailFull = (station: MailStation, accountId: string, m: MailItem): Record<string, unknown> => ({
+  ...heading(station, accountId, m),
+  has_attachments: m.hasAttachments,
+  is_read: m.isRead,
+  to: m.to,
+  cc: m.cc,
+  text: capText(m.text),
+});
+
+export const isAddress = (target: string): boolean => target.includes('@');
+
+export const isEmailAddress = (value: string): boolean => ADDRESS_RE.test(value);
+
+export function checkAddress(station: MailStation, to: string): void {
+  if (!isEmailAddress(to)) throw new TrainError(`${station}_bad_address`, `not an email address: ${to}`, { retryable: false });
+}
+
+export function subjectOf(station: MailStation, subject: string, text: string): string {
+  const chosen = subject !== '' ? subject : (text.split('\n').find((l) => l.trim() !== '') ?? '').trim();
+  if (chosen === '') throw new TrainError(`${station}_subject_required`, 'a new email needs a subject or some text', { retryable: false });
+  return chosen.length > SUBJECT_MAX ? `${chosen.slice(0, SUBJECT_MAX - 3)}...` : chosen;
+}
+
+export const filesOf = (raw: unknown): OutgoingFile[] =>
+  (Array.isArray(raw) ? raw : [])
+    .map((a) => (a ?? {}) as Record<string, unknown>)
+    .filter((a) => typeof a.path === 'string' && a.path !== '')
+    .map((a) => ({
+      path: String(a.path),
+      mime: typeof a.mime === 'string' && a.mime !== '' ? a.mime : 'application/octet-stream',
+      name: typeof a.name === 'string' && a.name !== '' ? a.name : 'file',
+    }));
+
+function isoOf(station: MailStation, raw: string, field: string): string {
+  if (raw === '') return '';
+  const at = Date.parse(raw);
+  if (Number.isNaN(at)) throw new TrainError(`${station}_bad_date`, `${field} must be a date, for example 2026-09-24 or 2026-09-24T10:00:00Z`, { retryable: false });
+  return new Date(at).toISOString();
+}
+
+export function readQueryOf(station: MailStation, args: Args): ReadQuery {
+  const line = str(args.line);
+  const thread = line === '' ? null : threadOfLine(station, line);
+  if (line !== '' && thread === null) throw new TrainError(`${station}_bad_line`, `not a valid ${station} line: ${line}`, { retryable: false });
+  return {
+    threadId: thread?.threadId ?? null,
+    query: str(args.query),
+    from: str(args.from).toLowerCase(),
+    since: isoOf(station, str(args.since), 'since'),
+    until: isoOf(station, str(args.until), 'until'),
+    before: str(args.before),
+    unreadOnly: args.unreadOnly === true,
+    limit: typeof args.limit === 'number' && args.limit > 0 ? Math.min(Math.floor(args.limit), MAX_LIMIT) : DEFAULT_LIMIT,
+  };
+}
+
+export const seenOf = (raw: unknown): string[] => (Array.isArray(raw) ? raw.filter((s): s is string => typeof s === 'string') : []);
+
+export function noteSeen(seen: string[], messageId: string): void {
+  seen.push(messageId);
+  if (seen.length > SEEN_MAX) seen.splice(0, seen.length - SEEN_MAX);
+}
+
+export function pollForever(tag: string, once: () => Promise<unknown>, intervalMs: number): void {
+  const tick = (): void => {
+    once()
+      .catch((err: unknown) => {
+        process.stderr.write(`${tag} mail check failed: ${err instanceof Error ? err.message : String(err)}\n`);
+      })
+      .finally(() => {
+        setTimeout(tick, intervalMs);
+      });
+  };
+  tick();
+}

package/runtime/node_modules/@metro-labs/core/src/stations/oauth.ts

@@ -0,0 +1,126 @@
+import { createHash, randomBytes } from 'node:crypto';
+
+export class SignInError extends Error {}
+
+export type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+
+export type OAuthBody = Record<string, unknown>;
+
+export interface Tokens {
+  accessToken: string;
+  refreshToken: string;
+  expiresAt: number;
+}
+
+export interface Pkce {
+  verifier: string;
+  challenge: string;
+}
+
+const RENEW_BEFORE_MS = 5 * 60_000;
+const MAILBOX_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+const text = (v: unknown): string => (typeof v === 'string' ? v : '');
+
+export const seconds = (v: unknown, fallback: number): number =>
+  typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : fallback;
+
+export function envValue(name: string, fallback: string): string {
+  const value = (process.env[name] ?? '').trim();
+  return value === '' ? fallback : value;
+}
+
+export const envUrl = (name: string, fallback: string): string => envValue(name, fallback).replace(/\/+$/, '');
+
+export function pkcePair(verifier = randomBytes(32).toString('base64url')): Pkce {
+  return { verifier, challenge: createHash('sha256').update(verifier).digest('base64url') };
+}
+
+export const newState = (): string => randomBytes(24).toString('base64url');
+
+export function parseMailbox(value: unknown): string | null {
+  const mailbox = (typeof value === 'string' ? value.trim() : '').toLowerCase();
+  if (mailbox === '') return null;
+  if (!MAILBOX_RE.test(mailbox))
+    throw new SignInError('Type the whole address of the mailbox, like andy@company.com, or leave it blank.');
+  return mailbox;
+}
+
+export async function postForm(url: string, fields: Record<string, string>, fetchImpl: FetchLike, provider: string): Promise<{ status: number; body: OAuthBody }> {
+  let res: Response;
+  try {
+    res = await fetchImpl(url, {
+      method: 'POST',
+      headers: { 'content-type': 'application/x-www-form-urlencoded', accept: 'application/json' },
+      body: new URLSearchParams(fields).toString(),
+    });
+  } catch (err) {
+    throw new SignInError(`Metro could not reach ${provider}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const raw: unknown = await res.json().catch(() => ({}));
+  return { status: res.status, body: typeof raw === 'object' && raw !== null ? (raw as OAuthBody) : {} };
+}
+
+export function tokensOf(body: OAuthBody, now: number, provider: string, previous?: string): Tokens {
+  const accessToken = text(body.access_token);
+  const refreshToken = text(body.refresh_token) || (previous ?? '');
+  if (accessToken === '' || refreshToken === '') throw new SignInError(`${provider} answered without the tokens Metro needs.`);
+  return { accessToken, refreshToken, expiresAt: now + seconds(body.expires_in, 3600) * 1000 };
+}
+
+export function tokenStateOf(saved: OAuthBody, seed: Partial<Tokens>): Tokens {
+  const fromFile = text(saved.refreshToken) !== '';
+  return {
+    refreshToken: fromFile ? text(saved.refreshToken) : text(seed.refreshToken),
+    accessToken: fromFile ? text(saved.accessToken) : text(seed.accessToken),
+    expiresAt: fromFile ? Number(saved.expiresAt) || 0 : Number(seed.expiresAt) || 0,
+  };
+}
+
+export class TokenKeeper {
+  private refreshing: Promise<string> | null = null;
+
+  constructor(
+    private readonly state: Tokens,
+    private readonly renewWith: (refreshToken: string) => Promise<Tokens>,
+    private readonly renewed: () => void,
+  ) {}
+
+  token(force = false): Promise<string> {
+    const fresh = this.state.accessToken !== '' && this.state.expiresAt - RENEW_BEFORE_MS > Date.now();
+    if (fresh && !force) return Promise.resolve(this.state.accessToken);
+    this.refreshing ??= this.renew().finally(() => {
+      this.refreshing = null;
+    });
+    return this.refreshing;
+  }
+
+  private async renew(): Promise<string> {
+    Object.assign(this.state, await this.renewWith(this.state.refreshToken));
+    this.renewed();
+    return this.state.accessToken;
+  }
+}
+
+export interface BrowserFlow<R> {
+  authorize: (challenge: string, state: string) => string;
+  redeem: (code: string, verifier: string) => Promise<R>;
+}
+
+export class BrowserSignIn<R> {
+  readonly state = newState();
+  readonly authorizeUrl: string;
+  private readonly pkce = pkcePair();
+  private used = false;
+
+  constructor(private readonly flow: BrowserFlow<R>) {
+    this.authorizeUrl = flow.authorize(this.pkce.challenge, this.state);
+  }
+
+  async finish(code: string, state: string): Promise<R> {
+    if (state !== this.state) throw new SignInError('This sign-in link belongs to another attempt. Start again from the Channels page.');
+    if (this.used) throw new SignInError('This sign-in was already used. Start again from the Channels page.');
+    this.used = true;
+    return this.flow.redeem(code, this.pkce.verifier);
+  }
+}

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

@@ -30,6 +30,7 @@
     "@metro-labs/telegram-bot": "workspace:*",
     "@metro-labs/threema": "workspace:*",
     "@metro-labs/outlook": "workspace:*",
+    "@metro-labs/gmail": "workspace:*",
     "@metro-labs/webhook": "workspace:*",
     "@metro-labs/whatsapp": "workspace:*",
     "@metro-labs/xmtp": "workspace:*",

package/runtime/node_modules/@metro-labs/daemon/src/agents/accounts-api.ts

@@ -138,7 +138,7 @@ async function storeAccount(
 
 function asInput(body: unknown): Record<string, unknown> {
   const out: Record<string, unknown> = {};
-  for (const key of ['apiId', 'apiHash', 'phone', 'mailbox'])
+  for (const key of ['apiId', 'apiHash', 'phone', 'mailbox', 'clientId', 'clientSecret'])
     out[key] = bodyField(body, key);
   return out;
 }

package/runtime/node_modules/@metro-labs/daemon/src/mcp/tool-schemas.ts

@@ -34,8 +34,8 @@ export const COMMON_TOOLS: ToolDef[] = [
     group: 'write',
     description:
       'Send a message (and/or media) to a Metro conversation. Args: line, text?, reply_to?, ' +
-      'subject?, attachments?. The station is derived from the line. Outlook: send to ' +
-      'metro://outlook/<account>/<email address> to start a new email (subject defaults to the ' +
+      'subject?, attachments?. The station is derived from the line. Outlook and Gmail: send to ' +
+      'metro://<outlook|gmail>/<account>/<email address> to start a new email (subject defaults to the ' +
       'first line of text); the result names the new thread line. Each attachment names EXACTLY ONE ' +
       'source, and the choice matters: `upload` (an `upload_id` from `create_upload`, the ' +
       'route for any real file on your own machine, confidential or not, up to 64 MiB); ' +
@@ -59,7 +59,7 @@ export const COMMON_TOOLS: ToolDef[] = [
         },
         subject: {
           type: 'string',
-          description: 'Outlook only: the subject of a new email.',
+          description: 'Outlook and Gmail only: the subject of a new email.',
         },
         attachments: {
           type: 'array',
@@ -158,7 +158,9 @@ export const COMMON_TOOLS: ToolDef[] = [
       "(shapes differ per station), or the daemon's reason if the station does not support " +
       'reads. Outlook: `query` is a Microsoft search over all mail (with `from` folded into it; ' +
       'line, since, until and unread_only then narrow what the search found), and without ' +
-      '`query` every filter is applied by Outlook itself, newest first.',
+      '`query` every filter is applied by Outlook itself, newest first. Gmail: `query` uses ' +
+      'Gmail search syntax (from:, subject:, has:attachment, newer_than:7d...), and the other ' +
+      'filters are added to it.',
     inputSchema: {
       type: 'object',
       properties: {

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

@@ -0,0 +1,102 @@
+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 {
+  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 {
+      hooks.done(await login.finish(code, state));
+    } 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: () => 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 });
+  } 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-interactive.ts

@@ -1,8 +1,8 @@
 import { StationAttachError } from './attach.js';
 import type { DriverHooks, StartedAttach } from './attach-driver.js';
-import { startOutlook } from './attach-outlook.js';
+import { startGmail, startOutlook } from './attach-browser.js';
 
-export const INTERACTIVE_STATIONS = ['telegram', 'whatsapp', 'outlook'] as const;
+export const INTERACTIVE_STATIONS = ['telegram', 'whatsapp', 'outlook', 'gmail'] as const;
 
 export type InteractiveStation = (typeof INTERACTIVE_STATIONS)[number];
 
@@ -128,6 +128,7 @@ export async function startInteractiveAttach(
   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/daemon/src/stations/materialize.ts

@@ -91,6 +91,11 @@ const STATION_TARGETS: Record<StationName, StationTarget> = {
     fileEnv: 'OUTLOOK_ACCOUNTS_FILE',
     trainImport: '@metro-labs/outlook/train',
   },
+  gmail: {
+    file: 'gmail-accounts.json',
+    fileEnv: 'GMAIL_ACCOUNTS_FILE',
+    trainImport: '@metro-labs/gmail/train',
+  },
   webhook: {
     file: 'webhook-accounts.json',
     fileEnv: 'WEBHOOK_ACCOUNTS_FILE',

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

@@ -8,6 +8,7 @@ import { discordBotStation } from '@metro-labs/discord-bot';
 import { whatsappStation } from '@metro-labs/whatsapp';
 import { threemaStation } from '@metro-labs/threema';
 import { outlookStation } from '@metro-labs/outlook';
+import { gmailStation } from '@metro-labs/gmail';
 import { webhookStation } from '@metro-labs/webhook';
 
 export const STATIONS: readonly Station[] = [
@@ -18,6 +19,7 @@ export const STATIONS: readonly Station[] = [
   whatsappStation,
   threemaStation,
   outlookStation,
+  gmailStation,
   webhookStation,
 ];
 

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

@@ -0,0 +1,25 @@
+{
+  "name": "@metro-labs/gmail",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/station.ts",
+    "./train": "./src/index.ts",
+    "./login": "./src/login.ts"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc --noEmit && bun test test/"
+  },
+  "dependencies": {
+    "@metro-labs/core": "workspace:*"
+  },
+  "devDependencies": {
+    "@stage-labs/config": "0.1.0-beta.2",
+    "eslint": "^10.3.0",
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
+  }
+}