@stage-labs/metro 0.1.0-beta.270 → 0.1.0-beta.272

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.270",
+  "version": "0.1.0-beta.272",
   "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.270",
+  "version": "0.1.0-beta.272",
   "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/src/tickets.ts

@@ -2,6 +2,7 @@ import { randomBytes } from 'node:crypto';
 
 export interface TicketStore<T> {
   mint: (value: T, now?: number) => { ticket: string; expiresAt: number };
+  peek: (ticket: string, now?: number) => T | undefined;
   take: (ticket: string, now?: number) => T | undefined;
   size: (now?: number) => number;
 }
@@ -24,6 +25,12 @@ export function ticketStore<T>(ttlMs: number, max: number): TicketStore<T> {
       open.set(ticket, { value, expiresAt });
       return { ticket, expiresAt };
     },
+    peek(ticket, now = Date.now()) {
+      const entry = open.get(ticket);
+      if (entry !== undefined && entry.expiresAt > now) return entry.value;
+      open.delete(ticket);
+      return undefined;
+    },
     take(ticket, now = Date.now()) {
       const entry = open.get(ticket);
       open.delete(ticket);

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

@@ -5,7 +5,7 @@ import { approversForAccount } from './map.js';
 import { isRecord } from '@metro-labs/core/is-record';
 import type { RecentSender } from './senders.js';
 import { ApiError } from '@metro-labs/http/api-error';
-import { apiFailure, bodyField, readJsonBody, sendJson } from '@metro-labs/http/api-http';
+import { apiFailure, bodyField, readJsonBody, sendJson, type ApiSession } from '@metro-labs/http/api-http';
 import { type AccountRef } from './account-attach.js';
 import { type AccountRoute } from './account-routes.js';
 import { handlePolicy, type SetPolicy } from './policy-route.js';
@@ -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', 'clientId', 'clientSecret'])
+  for (const key of ['apiId', 'apiHash', 'phone', 'mailbox', 'clientId', 'clientSecret', 'mode', 'sendEnabled', 'accountId'])
     out[key] = bodyField(body, key);
   return out;
 }
@@ -148,12 +148,13 @@ async function handleStart(
   res: ServerResponse,
   deps: AccountApiDeps,
   agentId: string,
+  owner: AttachOwner,
 ): Promise<void> {
   const body = await readJsonBody(req);
   const station = bodyField(body, 'station');
   if (isInteractiveStation(station)) {
     const view = await deps.attachSessions.start(
-      { agentId },
+      owner,
       station,
       asInput(body),
     );
@@ -320,10 +321,12 @@ async function dispatchAttach(
   deps: AccountApiDeps,
   agentId: string,
   route: Extract<AccountRoute, { kind: 'start' | 'session' | 'step' }>,
+  session?: ApiSession,
 ): Promise<void> {
-  if (route.kind === 'start') return handleStart(req, res, deps, agentId);
-  if (route.kind === 'session') return handleSession(req, res, deps, { agentId }, route.attachId);
-  return handleStep(req, res, deps, { agentId }, route.attachId);
+  const owner: AttachOwner = { agentId, organization: session?.subject, userId: session?.userId, sessionId: session?.sessionId, authorization: req.headers.authorization };
+  if (route.kind === 'start') return handleStart(req, res, deps, agentId, owner);
+  if (route.kind === 'session') return handleSession(req, res, deps, owner, route.attachId);
+  return handleStep(req, res, deps, owner, route.attachId);
 }
 
 async function dispatchRoute(
@@ -332,8 +335,9 @@ async function dispatchRoute(
   deps: AccountApiDeps,
   agentId: string,
   route: AccountRoute,
+  session?: ApiSession,
 ): Promise<void> {
-  if (route.kind === 'start' || route.kind === 'session' || route.kind === 'step') return dispatchAttach(req, res, deps, agentId, route);
+  if (route.kind === 'start' || route.kind === 'session' || route.kind === 'step') return dispatchAttach(req, res, deps, agentId, route, session);
   if (route.kind === 'allowlist') return handleAllowlist(req, res, deps, agentId, route);
   if (route.kind === 'enabled') return handleEnabled(req, res, deps, agentId, route);
   if (route.kind === 'policy') return handlePolicy(req, res, deps, agentId, route);
@@ -348,9 +352,10 @@ export async function handleAccountRoute(
   deps: AccountApiDeps,
   agentId: string,
   route: AccountRoute,
+  session?: ApiSession,
 ): Promise<void> {
   try {
-    await dispatchRoute(req, res, deps, agentId, route);
+    await dispatchRoute(req, res, deps, agentId, route, session);
   } catch (err) {
     apiFailure(req, res, err);
   }

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

@@ -25,6 +25,7 @@ export interface AgentApiDeps extends AccountApiDeps {
   capabilities: () => Record<string, string[]>;
   toolGroups?: () => Record<string, { name: string; group: string }[]>;
   attachable?: string[];
+  features?: string[];
   connectorIds: (agentIds: string[]) => Promise<Map<string, string[]>>;
 }
 
@@ -69,6 +70,7 @@ async function handleList(
   const base = {
     agents: list.map((a) => agentPayload(a, connectors)),
     capabilities: deps.capabilities(),
+    features: deps.features ?? [],
     attachable: deps.attachable ?? ATTACHABLE,
     ...(deps.toolGroups === undefined ? {} : { tools: deps.toolGroups() }),
   };
@@ -100,7 +102,7 @@ async function dispatch(
     sendJson(req, res, 401, { error: 'unauthorized' });
     return;
   }
-  if (tgt.kind === 'accounts') await handleAccountRoute(req, res, deps, tgt.id, tgt.route);
+  if (tgt.kind === 'accounts') await handleAccountRoute(req, res, deps, tgt.id, tgt.route, session);
   else await handleList(req, res, deps);
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/agents/file-admin.ts

@@ -116,6 +116,7 @@ function assertUnclaimed(existing: Stored[], agent: LoadedAgent): void {
 }
 
 function assertImportable(agent: LoadedAgent): void {
+  if (agent.accounts.some((a) => a.station === 'gmail' && a.config.managed === true)) throw new AgentAdminError('Managed Gmail cannot be imported. Connect the mailbox again on this box.', 400);
   const immovable = agent.accounts.find((a) => !MOVABLE_STATIONS.has(a.station));
   if (immovable !== undefined)
     throw new AgentAdminError(
@@ -170,6 +171,7 @@ function mergedStations(
   const fromMetro = agent.accounts
     .map((a) => ({ ...a, allowlist: a.allowlist ?? ['*'] }))
     .filter((m) => mode === 'overwrite' || !here(m.station, m.id));
+  if (fromMetro.some((m) => m.station === 'gmail' && before.some((s) => s.station === 'gmail' && s.id === m.id && s.config.managed === true))) throw new AgentAdminError('Managed Gmail cannot be overwritten by an import. Delete the connection first.', 400);
   const kept = before.filter((s) => !fromMetro.some((m) => m.station === s.station && m.id === s.id));
   return [...fromMetro, ...kept];
 }
@@ -198,6 +200,16 @@ function fileFor(
   }
 }
 
+export function localRenewGmail(agentId: string, accountId: string, previous: string, config: Record<string, unknown>, dir = agentsDir()): AccountRef {
+  const stored = agentOrThrow(agentId, dir);
+  const account = stored.file.stations.find((s) => s.station === 'gmail' && s.id === accountId);
+  if (account === undefined || (account.config.authorizationId ?? account.config.refreshToken) !== previous) throw new AgentAdminError('This Gmail connection changed. Start again.', 409);
+  if (account.config.accountEmail !== config.accountEmail) throw new AgentAdminError('The Gmail mailbox did not match. Nothing was changed.', 400);
+  account.config = { ...account.config, ...config };
+  save(stored);
+  return { agentId, station: 'gmail', accountId };
+}
+
 export function readLocalAgentFile(agentId: string, dir = agentsDir()): AgentFile {
   const found = storedAgents(dir).find((s) => s.file.id === agentId);
   if (found === undefined) throw missing();
@@ -233,7 +245,7 @@ export async function localAttachAccount(
   assertCredentialFree(storedAgents(dir), station, config);
   const taken = new Set(stored.file.stations.map((a) => a.id));
   const accountId = freshId(taken);
-  stored.file.stations.push({ station, id: accountId, allowlist: ['*'], enabled: true, config });
+  stored.file.stations.push({ station, id: accountId, allowlist: ['*'], enabled: true, ...(station === 'gmail' && config.sendEnabled === false ? { policy: { write: 'deny' as const } } : {}), config });
   save(stored);
   return Promise.resolve({ agentId, station, accountId });
 }

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

@@ -7,7 +7,8 @@ import { acquireLock, STATE_DIR, trainsDir } from './paths.js';
 import { installCrashGuard, markDaemonReady } from './crash-guard.js';
 import { METRO_VERSION } from '@metro-labs/core/version';
 import { funnelDriver, Tunnel, tunnelWanted } from '../net/tunnel.js';
-import { webhookPort } from '../files/attach-serve.js';
+import { publicBaseUrl, webhookPort } from '../files/attach-serve.js';
+import { setManagedHost } from '@metro-labs/gmail/managed-binding';
 import {
   localConnectHint,
   publicConnectHint,
@@ -80,7 +81,8 @@ supervisor.onTrainEvent((env, train) => {
 });
 
 let webhookServer: Server | null = null;
-const tunnel = tunnelWanted() ? new Tunnel(funnelDriver(webhookPort()), announcePublic) : null;
+const syncGmailHost = (): void => { setManagedHost(publicBaseUrl()); };
+const tunnel = tunnelWanted() ? new Tunnel(funnelDriver(webhookPort()), announcePublic, undefined, syncGmailHost) : null;
 
 function announcePublic(url: string): void {
   process.stderr.write(`\n${publicConnectHint(url, localOwner())}`);
@@ -140,6 +142,7 @@ installBearerSessions(agentsDir(), localOwner);
   log.info({ agent: await ensureLocalAgent() }, 'local daemon: agent');
   await materializeFrom(fileSource);
   forgetOrphans(knownAccounts());
+  syncGmailHost();
   supervisor.start();
   sweepLeftoverCalls();
   const metroMcp = await createMetroMcp({ liveEvents: liveEvents() });

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

@@ -26,6 +26,7 @@ import { setupAnswer, type SetupApiDeps } from './setup-api.js';
 import {
   autostartEnabled,
   ensureSession,
+  sessionSnapshot,
   sessionStatus,
   setAutostart,
   startSession,
@@ -270,6 +271,11 @@ export function handleClaudeRequest(
   apiSession(req)
     .then(async (session) => {
       if (!session) throw new ApiError('unauthorized', 401);
+      if (path === `${PREFIX}/session/snapshot`) {
+        if (req.method !== 'GET') throw new ApiError('method not allowed', 405);
+        sendJson(req, res, 200, sessionSnapshot(deps.session));
+        return;
+      }
       if (req.method !== 'GET' && ADMIN_ONLY.test(path)) requireAdmin(session);
       if (await streamed(req, res, path, search, (deps.dir ?? claudeDir)())) return;
       sendJson(req, res, 200, await routed(req, path, search, deps, session));

package/runtime/node_modules/@metro-labs/daemon/src/claude/session.ts

@@ -61,6 +61,13 @@ export interface SessionStatus {
   lastError: string | null;
 }
 
+export interface SessionSnapshot {
+  running: boolean;
+  runner: HarnessRunner | null;
+  activity: RunnerActivity | null;
+  lastStartedAt: string | null;
+}
+
 interface Memory {
   lastStartedAt: number | null;
   lastError: string | null;
@@ -267,17 +274,27 @@ export function stopSession(deps: SessionDeps = {}): SessionStatus {
 export const sessionLive = (deps: SessionDeps = {}): boolean =>
   sessionRunning(deps.tmux ?? 'tmux') || sdkAlive(readAgentActivity(sessionHome(deps)));
 
-export function sessionStatus(deps: SessionDeps = {}): SessionStatus {
+export function sessionSnapshot(deps: SessionDeps = {}): SessionSnapshot {
   const activity = readAgentActivity(sessionHome(deps));
   const sdk = sdkAlive(activity);
+  const tmux = sessionRunning(deps.tmux ?? 'tmux');
+  const runner = sdk ? 'sdk' : tmux ? readState(deps.agents ?? agentsDir()).runner : null;
   return {
-    name: SESSION_NAME,
-    running: sessionRunning(deps.tmux ?? 'tmux') || sdk,
-    runner: sdk ? 'sdk' : sessionRunner(deps),
+    running: tmux || sdk,
+    runner: isHarnessRunner(runner) ? runner : null,
     activity,
+    lastStartedAt: memory.lastStartedAt === null ? null : new Date(memory.lastStartedAt).toISOString(),
+  };
+}
+
+export function sessionStatus(deps: SessionDeps = {}): SessionStatus {
+  const snapshot = sessionSnapshot(deps);
+  return {
+    name: SESSION_NAME,
+    ...snapshot,
+    runner: snapshot.runner ?? sessionRunner(deps),
     autostart: autostartEnabled(deps.agents ?? agentsDir()),
     blocked: sessionBlocked(deps),
-    lastStartedAt: memory.lastStartedAt === null ? null : new Date(memory.lastStartedAt).toISOString(),
     lastError: memory.lastError,
   };
 }

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

@@ -14,6 +14,7 @@ import {
   connectionOf,
   parseModelConfig,
   readModelConfig,
+  readModelSnapshot,
   removeConnection,
   setFallbacks,
   setRoute,
@@ -28,6 +29,7 @@ import { refreshUsage } from './usage-refresh.js';
 import { handleOpenRouterSignIn } from './openrouter-signin.js';
 
 const PATH = '/api/model';
+const SNAPSHOT = '/api/model/snapshot';
 const CONNECTIONS = '/api/model/connections';
 const FALLBACKS = '/api/model/fallbacks';
 const CODEX = '/api/model/codex/';
@@ -201,12 +203,13 @@ const TABLES: [string, Record<string, Route>][] = [
   [BEDROCK, BEDROCK_ROUTES],
   [GEMINI, GEMINI_ROUTES],
 ];
-const EXACT = new Set([PATH, FALLBACKS, BUNDLE, RESTORE, CONNECTIONS]);
+const EXACT = new Set([PATH, SNAPSHOT, FALLBACKS, BUNDLE, RESTORE, CONNECTIONS]);
 const PREFIXES = [`${CONNECTIONS}/`, CODEX, ...TABLES.map(([prefix]) => prefix)];
 
 const mine = (path: string): boolean => EXACT.has(path) || PREFIXES.some((prefix) => path.startsWith(prefix));
 
 function routeFor(path: string, method: string | undefined): Route | number {
+  if (path === SNAPSHOT) return method === 'GET' ? { method: 'GET', run: (_req, _deps, store) => Promise.resolve().then(() => settingsBody(store.read())).catch(asApiError) } : 405;
   if (path === PATH || path === FALLBACKS) return settingsRoute(path, method);
   if (path === BUNDLE || path === RESTORE) return bundleRoute(path, method);
   if (path === CONNECTIONS || path.startsWith(`${CONNECTIONS}/`)) return connectionsRoute(path, method);
@@ -232,7 +235,7 @@ export function handleModelRequest(req: IncomingMessage, res: ServerResponse, de
     return true;
   }
   const store: Store = {
-    read: deps.read ?? readModelConfig,
+    read: deps.read ?? (path === SNAPSHOT ? readModelSnapshot : readModelConfig),
     write: (cfg) => {
       checkRunnerRoute(store.read(), cfg, deps);
       (deps.write ?? writeModelConfig)(cfg);

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

@@ -158,13 +158,22 @@ export function parseModelConfig(raw: unknown): ModelConfig {
 const needsIds = (raw: unknown): boolean =>
   isRecord(raw) && Array.isArray(raw.connections) && raw.connections.some((c: unknown) => isRecord(c) && text(c.id) === '');
 
+const readStoredModel = (dir: string): unknown =>
+  readJson<unknown>(join(dir, MODEL_FILE), null, { warn: 'model-config: model.json is unreadable, so every request goes to Anthropic until it is fixed' });
+
 export function readModelConfig(dir = agentsDir()): ModelConfig {
-  const raw = readJson<unknown>(join(dir, MODEL_FILE), null, { warn: 'model-config: model.json is unreadable, so every request goes to Anthropic until it is fixed' });
+  const raw = readStoredModel(dir);
   const cfg = parseModelConfig(raw);
   if (needsIds(raw)) writeModelConfig(cfg, dir);
   return cfg;
 }
 
+export function readModelSnapshot(dir = agentsDir()): ModelConfig {
+  const raw = readStoredModel(dir);
+  if (needsIds(raw)) throw new ModelConfigError('model snapshot is unavailable until every connection has a saved id');
+  return parseModelConfig(raw);
+}
+
 export function writeModelConfig(cfg: ModelConfig, dir = agentsDir()): void {
   writeSecure(join(dir, MODEL_FILE), JSON.stringify(cfg, null, 2));
 }

package/runtime/node_modules/@metro-labs/daemon/src/net/tunnel.ts

@@ -187,12 +187,18 @@ export class Tunnel {
     private driver: TunnelDriver,
     private onUrl: (url: string) => void = () => undefined,
     private resolves: Resolves = resolvesPublicly,
+    private onChange: () => void = () => undefined,
   ) {}
 
+  private setUrl(url: string | null): void {
+    liveUrl = url;
+    this.onChange();
+  }
+
   private noticeUrl(text: string): void {
     const url = this.driver.urlIn(text);
     if (url === null || url === liveUrl) return;
-    liveUrl = url;
+    this.setUrl(url);
     this.restartDelay = RESTART_DELAY_MS;
     log.info({ url }, `${this.driver.name} up; waiting for its name to resolve`);
     this.announceWhenResolvable(url).catch((err: unknown) => {
@@ -240,7 +246,7 @@ export class Tunnel {
     }, SILENT_MS).unref();
     child.on('exit', (code) => {
       this.child = null;
-      liveUrl = null;
+      this.setUrl(null);
       if (this.closed) return;
       this.afterExit(code).catch((err: unknown) => {
         log.warn({ err: errMsg(err) }, `${this.driver.name}: exit handling failed`);
@@ -289,7 +295,7 @@ export class Tunnel {
       if (misses < ADOPTED_MISSES) return;
       this.unwatch();
       log.warn({ url }, `${this.driver.name}: the Funnel this daemon adopted no longer answers; publishing our own`);
-      liveUrl = null;
+      this.setUrl(null);
       this.restartDelay = RESTART_DELAY_MS;
       this.start();
     };
@@ -312,5 +318,6 @@ export class Tunnel {
     this.unwatch();
     this.child?.kill('SIGINT');
     this.child = null;
+    this.setUrl(null);
   }
 }

package/runtime/node_modules/@metro-labs/daemon/src/routes/bearer.ts

@@ -28,7 +28,7 @@ export function bearerSessionsFor(owner: () => string | null, keys: SigningKeys)
     const held = owner();
     if (held === null || session.organization === null || session.organization !== held)
       throw new ApiError('this machine belongs to another organization', 403);
-    return { subject: held, role: session.role === 'admin' ? 'admin' : 'member', ...(isOperatorUser(session.userId) ? { operator: true as const } : {}) };
+    return { subject: held, userId: session.userId, sessionId: session.sessionId, role: session.role === 'admin' ? 'admin' : 'member', ...(isOperatorUser(session.userId) ? { operator: true as const } : {}) };
   };
 }
 

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

@@ -0,0 +1,67 @@
+import { randomUUID } from 'node:crypto';
+import { ApiError } from '@metro-labs/http/api-error';
+import { stringOf } from '@metro-labs/http/api-http';
+import { publicBaseUrl } from '../files/attach-serve.js';
+import { localOwner, readLocalAgentFile, localRenewGmail } from '../agents/file-admin.js';
+import { startManagedGmail } from '../stations/attach-gmail.js';
+import { startGmail } from '../stations/attach-browser.js';
+import type { AttachOwner, StartAttach } from '../stations/attach-session.js';
+import type { AttachOutcome, DriverHooks } from '../stations/attach-driver.js';
+import { assertGmailNotDeleting } from './gmail-detach.js';
+
+export function assertAttachOwner(owner: AttachOwner): void {
+  readLocalAgentFile(owner.agentId);
+  if (owner.organization !== undefined && owner.organization !== localOwner()) throw new ApiError('This box changed organization. Start again.', 403);
+}
+
+function gmailHost(): string {
+  const raw = publicBaseUrl();
+  const url = raw === null ? null : new URL(raw);
+  if (url === null || url.protocol !== 'https:' || url.username || url.password || url.pathname !== '/' || url.search || url.hash) throw new ApiError('Managed Gmail needs this box registered in Metro with its HTTPS address.', 400);
+  return url.host;
+}
+
+interface Upgrade {
+  accountId: string;
+  previous: string;
+}
+
+function gmailInput(owner: AttachOwner, input: Record<string, unknown>): { fields: Record<string, unknown>; upgrade?: Upgrade } {
+  if (input.mode !== 'upgrade') return { fields: { ...input, sendEnabled: false } };
+  const accountId = stringOf(input.accountId);
+  assertGmailNotDeleting(owner.agentId, accountId);
+  const account = readLocalAgentFile(owner.agentId).stations.find((s) => s.station === 'gmail' && s.id === accountId);
+  if (account === undefined) throw new ApiError('No such Gmail connection.', 404);
+  if (account.config.sendEnabled !== false) throw new ApiError('Sending is already authorized for this Gmail connection.', 409);
+  return {
+    fields: { clientId: account.config.clientId, clientSecret: account.config.clientSecret, mailbox: account.config.accountEmail, sendEnabled: true, mode: account.config.managed === true ? 'managed' : 'byo' },
+    upgrade: { accountId, previous: stringOf(account.config.authorizationId ?? account.config.refreshToken) },
+  };
+}
+
+export const startGmailAttach: StartAttach = async (_station, input, hooks, owner) => {
+  assertAttachOwner(owner);
+  const { fields, upgrade } = gmailInput(owner, input);
+  const bound: DriverHooks = {
+    ...hooks,
+    done: (outcome: AttachOutcome) => {
+      hooks.done({ ...outcome, config: { ...outcome.config, authorizationId: randomUUID(), ...(upgrade === undefined ? {} : { gmailUpgrade: upgrade }) } });
+    },
+  };
+  if (fields.mode !== 'managed') return startGmail(fields, bound);
+  const host = gmailHost();
+  return startManagedGmail({ host, owner, mailbox: fields.mailbox, sendEnabled: fields.sendEnabled === true, check: () => {
+    assertAttachOwner(owner);
+    if (gmailHost() !== host) throw new ApiError('This box changed address. Start again.', 409);
+  } }, bound);
+};
+
+export function finishGmailUpgrade(owner: AttachOwner, config: Record<string, unknown>): ReturnType<typeof localRenewGmail> | null {
+  const value = config.gmailUpgrade;
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return null;
+  const upgrade = value as Record<string, unknown>;
+  assertGmailNotDeleting(owner.agentId, stringOf(upgrade.accountId));
+  const saved = { ...config };
+  delete saved.gmailUpgrade;
+  return localRenewGmail(owner.agentId, stringOf(upgrade.accountId), stringOf(upgrade.previous), saved);
+}

package/runtime/node_modules/@metro-labs/daemon/src/routes/gmail-detach.ts

@@ -0,0 +1,37 @@
+import { ApiError } from '@metro-labs/http/api-error';
+import { localDetachAccount, localOwner, readLocalAgentFile } from '../agents/file-admin.js';
+import { forwardTrainCall } from '../stations/train-call.js';
+
+const deleting = new Set<string>();
+const keyOf = (agentId: string, accountId: string): string => `${agentId}/${accountId}`;
+
+export function assertGmailNotDeleting(agentId: string, accountId: string): void {
+  if (deleting.has(keyOf(agentId, accountId))) throw new ApiError('This Gmail connection is being deleted. Try again after it finishes.', 409);
+}
+
+async function revokeConnection(accountId: string, authorizationId: unknown): Promise<void> {
+  try {
+    const response = await forwardTrainCall('gmail', 'disconnect', { account: accountId, authorizationId });
+    const result = response.result as { revoked?: unknown } | undefined;
+    if (response.error !== undefined || result?.revoked !== true) throw new Error('revocation not confirmed');
+  } catch {
+    throw new ApiError('Google access could not be revoked. The Gmail channel was kept. Keep the Gmail service running and try deleting again.', 503);
+  }
+}
+
+export const detachWithGmailRevocation: typeof localDetachAccount = async (agentId, station, accountId, dir) => {
+  const config = station === 'gmail' ? readLocalAgentFile(agentId, dir).stations.find((a) => a.station === station && a.id === accountId)?.config : undefined;
+  if (config?.managed !== true) return localDetachAccount(agentId, station, accountId, dir);
+  assertGmailNotDeleting(agentId, accountId);
+  const key = keyOf(agentId, accountId);
+  const owner = localOwner(dir);
+  deleting.add(key);
+  try {
+    await revokeConnection(accountId, config.authorizationId);
+    const current = readLocalAgentFile(agentId, dir).stations.find((a) => a.station === station && a.id === accountId)?.config;
+    if (localOwner(dir) !== owner || current?.authorizationId !== config.authorizationId) throw new ApiError('This box or Gmail connection changed during deletion. Google access was revoked; review the connection before trying again.', 409);
+    return await localDetachAccount(agentId, station, accountId, dir);
+  } finally {
+    deleting.delete(key);
+  }
+};

package/runtime/node_modules/@metro-labs/daemon/src/routes/local-mode.ts

@@ -1,6 +1,9 @@
 import { ApiError } from '@metro-labs/http/api-error';
 import { errMsg, log } from '@metro-labs/core/log';
 import { AttachSessions } from '../stations/attach-session.js';
+import { startInteractiveAttach } from '../stations/attach-interactive.js';
+import { assertAttachOwner, finishGmailUpgrade, startGmailAttach } from './gmail-attach.js';
+import { detachWithGmailRevocation } from './gmail-detach.js';
 import { recentSenders } from '../agents/senders.js';
 import { forwardTrainCall } from '../stations/train-call.js';
 import { syncPluginServers } from '../connectors/plugin-sync.js';
@@ -36,7 +39,6 @@ import { blockedReason } from '../connectors/gates.js';
 import {
   setLocalOwner,
   localAttachAccount,
-  localDetachAccount,
   localSetAllowlist,
   localSetPolicy,
   localSetAccountEnabled,
@@ -64,11 +66,14 @@ export interface LocalModeDeps {
 function attachSessions(deps: LocalModeDeps): AttachSessions {
   return new AttachSessions({
     authorize: (owner) => {
-      readLocalAgentFile(owner.agentId);
+      assertAttachOwner(owner);
       return Promise.resolve();
     },
-    complete: async (owner, station, config) => {
-      const ref = await localAttachAccount(owner.agentId, station, config);
+    start: (station, input, hooks, owner) => station === 'gmail' ? startGmailAttach(station, input, hooks, owner) : startInteractiveAttach(station, input, hooks),
+    complete: async (owner, station, config, active) => {
+      assertAttachOwner(owner);
+      if (!active()) throw new ApiError('This sign-in was cancelled or expired.', 409);
+      const ref = (station === 'gmail' ? finishGmailUpgrade(owner, config) : null) ?? await localAttachAccount(owner.agentId, station, config);
       const activated = await deps.syncStations(station).then(
         () => true,
         (err: unknown) => {
@@ -92,10 +97,11 @@ function agentApi(deps: LocalModeDeps): AgentApiDeps {
     capabilities: deps.capabilities,
     ...(deps.toolGroups === undefined ? {} : { toolGroups: deps.toolGroups }),
     attachable: ATTACHABLE.filter((s) => s !== 'webhook'),
+    features: ['gmail-managed'],
     connectorIds: connectorIdsOfLocalAgents,
     prepareAccount: deps.prepareAccount,
     attachAccount: localAttachAccount,
-    detachAccount: localDetachAccount,
+    detachAccount: detachWithGmailRevocation,
     syncStations: deps.syncStations,
     setAllowlist: localSetAllowlist,
     setPolicy: localSetPolicy,
@@ -151,7 +157,7 @@ function bundleApi(deps: LocalModeDeps): BundleApiDeps {
       const file = readLocalAgentFile(agentId);
       const bundle: AgentBundle = {
         version: 1,
-        agent: { id: file.id, name: file.name ?? '', stations: file.stations },
+        agent: { id: file.id, name: file.name ?? '', stations: file.stations.filter((a) => a.station !== 'gmail' || a.config.managed !== true) },
         connectors: readLocalConnectors().map((c) => ({ id: c.id, name: c.name, url: c.url, config: { ...c.config } })),
       };
       return Promise.resolve(bundle);

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

@@ -34,6 +34,7 @@ function refused(err: unknown, provider: string): StationAttachError {
 }
 
 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);
@@ -45,7 +46,8 @@ function browserAttach(login: BrowserLogin, hooks: DriverHooks, how: BrowserAtta
     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));
+      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.`));
     }
@@ -55,7 +57,10 @@ function browserAttach(login: BrowserLogin, hooks: DriverHooks, how: BrowserAtta
     prompt: { step: 'browser', prompt: how.prompt, authorizeUrl: login.authorizeUrl },
     expiresAt: Date.now() + BROWSER_TTL_MS,
     driver: {
-      cancel: () => how.cancel?.() ?? Promise.resolve(),
+      cancel: () => {
+        cancelled = true;
+        return how.cancel?.() ?? Promise.resolve();
+      },
       submit: (input) => (input.mode === 'device' && device !== undefined ? device() : finish(input)),
     },
   };
@@ -94,7 +99,7 @@ export async function startGmail(input: Record<string, unknown>, hooks: DriverHo
   const { GmailBrowserLogin, failureOf } = await import('@metro-labs/gmail/login');
   let login;
   try {
-    login = new GmailBrowserLogin({ clientId: input.clientId, clientSecret: input.clientSecret, mailbox: input.mailbox });
+    login = new GmailBrowserLogin({ clientId: input.clientId, clientSecret: input.clientSecret, mailbox: input.mailbox, sendEnabled: input.sendEnabled === true });
   } catch (err) {
     throw refused(err, 'Google');
   }

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

@@ -31,7 +31,7 @@ export interface StepInput {
 }
 
 export interface AttachDriver {
-  submit: (input: StepInput) => Promise<void>;
+  submit: (input: StepInput, authorization?: string) => Promise<void>;
   cancel: () => Promise<void>;
 }