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

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

@@ -1,22 +1,25 @@
 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,
+  repair?: string,
 ) => Promise<StartedAttach>;
 
 export const ATTACH_ID_RE = /^as_[A-Za-z0-9_-]{22}$/;
@@ -28,8 +31,11 @@ const MAX_PER_AGENT = 2;
 const MAX_TOTAL = 40;
 
 export interface AttachOwner {
-  subject: string;
   agentId: string;
+  organization?: string;
+  userId?: string;
+  sessionId?: string;
+  authorization?: string;
 }
 
 export interface AttachView {
@@ -40,6 +46,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 +56,15 @@ export interface AttachView {
   expiresAt: number;
 }
 
-export type CompleteAttach = (
+type CompleteAttach = (
   owner: AttachOwner,
   station: StationName,
   config: Record<string, unknown>,
+  active: () => boolean,
+  repair?: string,
 ) => Promise<{ accountId: string; activated: boolean }>;
 
-export type AuthorizeAttach = (owner: AttachOwner) => Promise<void>;
+type AuthorizeAttach = (owner: AttachOwner) => Promise<void>;
 
 export interface AttachSessionDeps {
   authorize: AuthorizeAttach;
@@ -63,8 +74,11 @@ export interface AttachSessionDeps {
 
 interface Session {
   owner: AttachOwner;
+  repair?: string;
   driver: AttachDriver | null;
   view: AttachView;
+  finishing?: boolean;
+  committing?: boolean;
 }
 
 const missing = (): ApiError => new ApiError('no such attach session', 404);
@@ -82,6 +96,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 +125,8 @@ export class AttachSessions {
 
   private own(owner: AttachOwner, attachId: string): Session {
     const session = this.sessions.get(attachId);
-    if (
-      session?.owner.subject !== owner.subject ||
-      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 +150,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 +165,22 @@ 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;
+        },
+        session.repair,
       );
       this.settle(session, {
         status: 'done',
@@ -164,12 +191,12 @@ export class AttachSessions {
       });
       log.info(
         { agentId: session.owner.agentId, station, account: landed.accountId },
-        'attach-session: signed in and attached a station account',
+        session.repair === undefined ? 'attach-session: signed in and attached a station account' : 'attach-session: paired a station account again',
       );
     } catch (err) {
       const reason =
         err instanceof ApiError ? err.message : 'could not store the account';
-      log.warn({ station, err: errMsg(err) }, 'attach-session: store failed');
+      log.warn({ station, ...(err instanceof ApiError ? { status: err.status } : { err: errMsg(err).replace(/\d{6,}/g, '<number>') }) }, 'attach-session: store failed');
       this.settle(session, { status: 'failed', prompt: '', error: reason });
     }
   }
@@ -183,6 +210,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) => {
@@ -204,6 +234,7 @@ export class AttachSessions {
     owner: AttachOwner,
     station: InteractiveStation,
     input: Record<string, unknown>,
+    repair?: string,
   ): Promise<AttachView> {
     await this.deps.authorize(owner);
     this.admit(owner);
@@ -211,17 +242,26 @@ export class AttachSessions {
     const attachId = newAttachId();
     const session: Session = {
       owner,
+      ...(repair === undefined ? {} : { repair }),
       driver: null,
       view: blankView(attachId, station),
     };
     this.sessions.set(attachId, session);
     try {
+      ensureStationDeps(station);
       const started = await (this.deps.start ?? startInteractiveAttach)(
         station,
         input,
         this.hooksFor(attachId, station),
+        owner,
+        repair,
       );
+      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 +281,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 +303,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);

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

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