@stage-labs/metro 0.1.0-beta.26 → 0.1.0-beta.261

package/runtime/node_modules/@metro-labs/xmtp/src/actions-push.ts

@@ -1,87 +0,0 @@
-import { accounts } from './accounts.js';
-import { respond } from './wire.js';
-import {
-  fcmPushToAll,
-  loadPushTokens,
-  removePushToken,
-  savePushTokens,
-  storePushToken,
-} from './push.js';
-
-type Args = Record<string, unknown>;
-type Handler = (id: string, args: Args) => Promise<void>;
-
-function registerPush(id: string, args: Args): Promise<void> {
-  const { token, account, platform, inboxId } = args as {
-    token?: string;
-    account?: string;
-    platform?: string;
-    inboxId?: string;
-  };
-  if (!token || typeof token !== 'string' || token.length < 20) {
-    throw new Error('register-push requires a non-empty FCM device token');
-  }
-  const total = storePushToken({ token, account, platform, inboxId });
-  respond(id, { result: { stored: true, total, account: account ?? null } });
-  return Promise.resolve();
-}
-
-function listPush(id: string): Promise<void> {
-  const tokens = loadPushTokens();
-  respond(id, {
-    result: {
-      count: tokens.length,
-      tokens: tokens.map((t) => ({
-        token: `${t.token.slice(0, 12)}…${t.token.slice(-6)}`,
-        registeredAt: t.registeredAt,
-        lastSeenAt: t.lastSeenAt ?? null,
-        account: t.account ?? null,
-        platform: t.platform ?? null,
-        inboxId: t.inboxId ?? null,
-      })),
-    },
-  });
-  return Promise.resolve();
-}
-
-async function testPush(id: string, args: Args): Promise<void> {
-  const { account } = args as { account?: string };
-  const acctId =
-    account ??
-    (accounts.size === 1 ? [...accounts.keys()][0] : 'default') ??
-    'default';
-  await fcmPushToAll(acctId, { channelId: 'xmtp', source: 'test-push' });
-  const sent = loadPushTokens().filter(
-    (t) => !t.account || t.account === acctId,
-  ).length;
-  respond(id, { result: { sent, account: acctId } });
-}
-
-function unregisterPush(id: string, args: Args): Promise<void> {
-  const { token } = args as { token: string };
-  savePushTokens(loadPushTokens().filter((t) => t.token !== token));
-  respond(id, { result: { removed: true } });
-  return Promise.resolve();
-}
-
-function disablePush(id: string, args: Args): Promise<void> {
-  const { token } = args as { token?: string };
-  if (!token || typeof token !== 'string')
-    throw new Error('disable-push requires a token');
-  const remaining = removePushToken(token);
-  respond(id, {
-    result: {
-      removed: remaining !== -1,
-      remaining: remaining === -1 ? null : remaining,
-    },
-  });
-  return Promise.resolve();
-}
-
-export const pushHandlers: Record<string, Handler> = {
-  'register-push': registerPush,
-  'list-push': (id) => listPush(id),
-  'test-push': testPush,
-  'unregister-push': unregisterPush,
-  'disable-push': disablePush,
-};

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

@@ -1,55 +0,0 @@
-import { accounts } from './accounts.js';
-import { emit, mintId, SELF_URI } from './wire.js';
-
-export function emitInbound(
-  accountId: string,
-  e: Record<string, unknown>,
-): void {
-  const acct = accounts.get(accountId);
-  const owner = acct?.cfg.owner;
-  const payload = {
-    ...(e.payload as Record<string, unknown> | undefined),
-    account: accountId,
-  };
-  emit({
-    kind: 'inbound',
-    ...e,
-    ...(owner ? { to: owner } : {}),
-    account: accountId,
-    payload,
-  });
-}
-
-export function emitAttachmentSaved(
-  accountId: string,
-  line: string,
-  sourceMsgId: string,
-  index: number,
-  save: Promise<{ path: string; mime?: string; name?: string }>,
-): void {
-  void save
-    .then((saved) => {
-      emitInbound(accountId, {
-        id: mintId(),
-        ts: new Date().toISOString(),
-        station: 'xmtp',
-        line,
-        from: SELF_URI,
-        text: `📎 saved: ${saved.path}`,
-        payload: {
-          contentType: 'attachmentSaved',
-          attachmentFor: sourceMsgId,
-          index,
-          attachmentPath: saved.path,
-          localPath: saved.path,
-          mime: saved.mime,
-          name: saved.name,
-        },
-      });
-    })
-    .catch((err: unknown) =>
-      process.stderr.write(
-        `xmtp attachment save failed: ${err instanceof Error ? err.message : String(err)}\n`,
-      ),
-    );
-}

package/runtime/node_modules/@metro-labs/xmtp/src/push.ts

@@ -1,349 +0,0 @@
-import { errMsg } from '@metro-labs/mcp/log';
-import { type DecodedMessage } from '@xmtp/node-sdk';
-import { existsSync, readFileSync, mkdirSync } from 'node:fs';
-import { dirname } from 'node:path';
-import { readJson, writeJson } from '@metro-labs/mcp/secure-fs';
-import { parseLine } from './accounts.js';
-
-const FCM_SVC_PATH = `${process.env.HOME}/.config/metro/firebase-service-account.json`;
-const FCM_TOKENS_PATH = `${process.env.HOME}/.cache/metro/xmtp-push-tokens.json`;
-interface FcmServiceAccount {
-  client_email: string;
-  private_key: string;
-  project_id: string;
-  token_uri: string;
-}
-
-interface StoredPushToken {
-  token: string;
-  registeredAt: string;
-  account?: string;
-  inboxId?: string;
-  inboxIds?: string[];
-  platform?: string;
-  lastSeenAt?: string;
-}
-
-function loadFcmSvc(): FcmServiceAccount | null {
-  if (!existsSync(FCM_SVC_PATH)) return null;
-  try {
-    return JSON.parse(readFileSync(FCM_SVC_PATH, 'utf8')) as FcmServiceAccount;
-  } catch (err) {
-    process.stderr.write(
-      `fcm: bad service account: ${errMsg(err)}\n`,
-    );
-    return null;
-  }
-}
-export function loadPushTokens(): StoredPushToken[] {
-  return readJson<StoredPushToken[]>(FCM_TOKENS_PATH, []);
-}
-export function savePushTokens(tokens: StoredPushToken[]): void {
-  mkdirSync(dirname(FCM_TOKENS_PATH), { recursive: true });
-  writeJson(FCM_TOKENS_PATH, tokens);
-}
-
-function collectInboxIds(
-  existing: StoredPushToken | undefined,
-  entryInboxId: string | undefined,
-): Set<string> {
-  const inboxIds = new Set<string>(existing?.inboxIds ?? []);
-  if (existing?.inboxId) inboxIds.add(existing.inboxId);
-  if (entryInboxId) inboxIds.add(entryInboxId);
-  return inboxIds;
-}
-
-export function storePushToken(entry: {
-  token: string;
-  account?: string;
-  inboxId?: string;
-  platform?: string;
-}): number {
-  const now = new Date().toISOString();
-  const all = loadPushTokens();
-  const existing = all.find((t) => t.token === entry.token);
-  const remaining = all.filter((t) => t.token !== entry.token);
-  const inboxIds = collectInboxIds(existing, entry.inboxId);
-  const row: StoredPushToken = {
-    token: entry.token,
-    registeredAt: existing?.registeredAt ?? now,
-    lastSeenAt: now,
-  };
-  if (entry.account) row.account = entry.account;
-  if (entry.inboxId) row.inboxId = entry.inboxId;
-  if (inboxIds.size) row.inboxIds = [...inboxIds];
-  if (entry.platform) row.platform = entry.platform;
-  remaining.push(row);
-  savePushTokens(remaining);
-  return remaining.length;
-}
-
-let cachedAccessToken: { token: string; expiresAt: number } | null = null;
-async function fcmAccessToken(): Promise<string | null> {
-  const svc = loadFcmSvc();
-  if (!svc) return null;
-  if (cachedAccessToken && cachedAccessToken.expiresAt > Date.now() + 60_000)
-    return cachedAccessToken.token;
-  const { createSign } = await import('node:crypto');
-  const enc = (o: unknown): string =>
-    Buffer.from(JSON.stringify(o)).toString('base64url');
-  const now = Math.floor(Date.now() / 1000);
-  const header = { alg: 'RS256', typ: 'JWT' };
-  const payload = {
-    iss: svc.client_email,
-    scope: 'https://www.googleapis.com/auth/firebase.messaging',
-    aud: svc.token_uri,
-    iat: now,
-    exp: now + 3600,
-  };
-  const sigInput = `${enc(header)}.${enc(payload)}`;
-  const signer = createSign('RSA-SHA256');
-  signer.update(sigInput);
-  signer.end();
-  const sig = signer.sign(svc.private_key).toString('base64url');
-  const jwt = `${sigInput}.${sig}`;
-  const grant = encodeURIComponent(
-    'urn:ietf:params:oauth:grant-type:jwt-bearer',
-  );
-  const res = await fetch(svc.token_uri, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-    body: `grant_type=${grant}&assertion=${jwt}`,
-    signal: AbortSignal.timeout(15_000),
-  });
-  if (!res.ok) {
-    process.stderr.write(
-      `fcm token exchange ${res.status}: ${await res.text()}\n`,
-    );
-    return null;
-  }
-  const json = (await res.json()) as {
-    access_token: string;
-    expires_in: number;
-  };
-  cachedAccessToken = {
-    token: json.access_token,
-    expiresAt: Date.now() + json.expires_in * 1000,
-  };
-  return cachedAccessToken.token;
-}
-
-async function fcmPushTo(
-  deviceToken: string,
-  data: Record<string, string> = {},
-): Promise<void> {
-  const svc = loadFcmSvc();
-  if (!svc) return;
-  const at = await fcmAccessToken();
-  if (!at) return;
-  const url = `https://fcm.googleapis.com/v1/projects/${svc.project_id}/messages:send`;
-  const payloadData: Record<string, string> = { channelId: 'xmtp', ...data };
-  const res = await fetch(url, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${at}`,
-    },
-    body: JSON.stringify({
-      message: {
-        token: deviceToken,
-        android: { priority: 'HIGH' },
-        data: payloadData,
-      },
-    }),
-    signal: AbortSignal.timeout(15_000),
-  });
-  if (!res.ok) {
-    const txt = await res.text().catch(() => '');
-    const dead =
-      res.status === 404 ||
-      txt.includes('UNREGISTERED') ||
-      txt.includes('NOT_FOUND') ||
-      txt.includes('registration-token-not-registered') ||
-      txt.includes('NotRegistered');
-    if (dead) {
-      removePushToken(deviceToken);
-      process.stderr.write(
-        `fcm: pruned stale token ${deviceToken.slice(0, 12)}…\n`,
-      );
-      return;
-    }
-    process.stderr.write(`fcm push ${res.status}: ${txt}\n`);
-  }
-}
-
-function freshestPerAccount(tokens: StoredPushToken[]): StoredPushToken[] {
-  const freshness = (t: StoredPushToken): number =>
-    new Date(t.lastSeenAt ?? t.registeredAt ?? 0).getTime();
-  const byAccount = new Map<string, StoredPushToken>();
-  const unscoped: StoredPushToken[] = [];
-  for (const t of tokens) {
-    if (!t.account) {
-      unscoped.push(t);
-      continue;
-    }
-    const cur = byAccount.get(t.account);
-    if (!cur || freshness(t) >= freshness(cur)) byAccount.set(t.account, t);
-  }
-  return [...byAccount.values(), ...unscoped];
-}
-
-export async function fcmPushToAll(
-  accountId: string,
-  data: Record<string, string> = {},
-  excludeInboxId?: string,
-): Promise<void> {
-  const tokens = loadPushTokens().filter((t) => {
-    if (t.account && t.account !== accountId) return false;
-    if (
-      excludeInboxId &&
-      (t.inboxId === excludeInboxId || t.inboxIds?.includes(excludeInboxId))
-    )
-      return false;
-    return true;
-  });
-  const deduped = freshestPerAccount(tokens);
-  if (deduped.length === 0) return;
-  await Promise.all(
-    deduped.map((t) =>
-      fcmPushTo(t.token, { ...data, account: accountId }).catch(
-        () => undefined,
-      ),
-    ),
-  );
-}
-
-const METRO_CTRL_PREFIX = 'METRO_CTRL:';
-const CTRL_REGISTER_PUSH = 'register-push';
-const CTRL_DISABLE_PUSH = 'disable-push';
-
-export function removePushToken(token: string): number {
-  const all = loadPushTokens();
-  const remaining = all.filter((t) => t.token !== token);
-  if (remaining.length === all.length) return -1;
-  savePushTokens(remaining);
-  return remaining.length;
-}
-
-function isMetroControlBody(text: unknown): text is string {
-  return typeof text === 'string' && text.startsWith(METRO_CTRL_PREFIX);
-}
-
-interface RegisterPushPayload {
-  v?: number;
-  token: string;
-  platform?: string;
-  address?: string;
-  inboxId?: string;
-}
-interface DisablePushPayload {
-  v?: number;
-  token: string;
-  address?: string;
-  inboxId?: string;
-}
-
-function isValidPushToken(token: unknown): token is string {
-  return typeof token === 'string' && token.length >= 20;
-}
-
-function handleRegisterPushCtrl(
-  accountId: string,
-  msg: DecodedMessage,
-  arg: string,
-): void {
-  const obj = JSON.parse(arg) as Partial<RegisterPushPayload>;
-  if (!obj || !isValidPushToken(obj.token)) {
-    process.stderr.write(
-      `xmtp[${accountId}]: register-push (ctrl-dm) ignored — bad/short token\n`,
-    );
-    return;
-  }
-  const total = storePushToken({
-    token: obj.token,
-    account: accountId,
-    inboxId: msg.senderInboxId,
-    platform: typeof obj.platform === 'string' ? obj.platform : undefined,
-  });
-  process.stderr.write(
-    `xmtp[${accountId}]: register-push (ctrl-dm) stored token ${obj.token.slice(0, 12)}… ` +
-      `from inbox ${msg.senderInboxId.slice(0, 10)}… (v=${obj.v ?? '?'}, ${total} total)\n`,
-  );
-}
-
-function handleDisablePushCtrl(accountId: string, arg: string): void {
-  const obj = JSON.parse(arg) as Partial<DisablePushPayload>;
-  if (!obj || !isValidPushToken(obj.token)) {
-    process.stderr.write(
-      `xmtp[${accountId}]: disable-push (ctrl-dm) ignored — bad/short token\n`,
-    );
-    return;
-  }
-  const remaining = removePushToken(obj.token);
-  process.stderr.write(
-    `xmtp[${accountId}]: disable-push (ctrl-dm) token ${obj.token.slice(0, 12)}… ` +
-      (remaining === -1
-        ? 'not found (already gone)\n'
-        : `removed (v=${obj.v ?? '?'}, ${remaining} remain)\n`),
-  );
-}
-
-export function handleControlDm(
-  accountId: string,
-  msg: DecodedMessage,
-): boolean {
-  const body = msg.content;
-  if (!isMetroControlBody(body)) return false;
-  const rest = body.slice(METRO_CTRL_PREFIX.length);
-  const sep = rest.indexOf(':');
-  const verb = sep === -1 ? rest : rest.slice(0, sep);
-  const arg = sep === -1 ? '' : rest.slice(sep + 1);
-  try {
-    if (verb === CTRL_REGISTER_PUSH) {
-      handleRegisterPushCtrl(accountId, msg, arg);
-    } else if (verb === CTRL_DISABLE_PUSH) {
-      handleDisablePushCtrl(accountId, arg);
-    } else {
-      process.stderr.write(
-        `xmtp[${accountId}]: unknown control verb '${verb}' — swallowed\n`,
-      );
-    }
-  } catch (err) {
-    process.stderr.write(
-      `xmtp[${accountId}]: control DM '${verb}' FAILED: ${errMsg(err)}\n`,
-    );
-  }
-  return true;
-}
-
-export function pushInbound(
-  accountId: string,
-  env: Record<string, unknown>,
-  msg: DecodedMessage,
-  conv?: unknown,
-): void {
-  const line = typeof env.line === 'string' ? env.line : '';
-  const messageId =
-    typeof env.message_id === 'string'
-      ? env.message_id
-      : typeof env.id === 'string'
-        ? env.id
-        : '';
-  void (async (): Promise<void> => {
-    const data: Record<string, string> = {
-      line,
-      messageId,
-      account: accountId,
-    };
-    {
-      const p = parseLine(line);
-      if (p) data.convId = p.convId.toLowerCase();
-    }
-    if (conv) {
-      const isDm =
-        typeof (conv as { peerInboxId?: unknown }).peerInboxId === 'function';
-      if (!isDm) data.isGroup = 'true';
-    }
-    await fcmPushToAll(accountId, data, msg.senderInboxId);
-  })().catch(() => undefined);
-}