@pellux/goodvibes-tui 0.24.1 → 0.26.0

package/src/daemon/handlers/inbox/index.ts

@@ -0,0 +1,210 @@
+// ---------------------------------------------------------------------------
+// Inbox surface: attaches the HOST handler to the SDK-registered
+// `channels.inbox.list` gateway descriptor.
+//
+// The SDK already declares the method id, input schema, output schema, scopes
+// (read:channels) and HTTP binding (GET /api/channels/inbox). This module does
+// NOT re-declare any of that — it looks the descriptor up via the catalog and
+// attaches an implementation with `registerCatalogHandler` ({ replace: true }).
+//
+// register(ctx, routing) =>
+//   1. registers built-in provider adapter factories (slack/discord/email)
+//   2. constructs adapters with the daemon credential store + a route resolver
+//      bridged from the routing surface (best-effort, never throws)
+//   3. opens the inbox cursor store and seeds an initial poll
+//   4. starts the per-provider polling loops
+//   5. attaches the read-only `channels.inbox.list` handler (no confirm)
+//   6. returns an Unregister that detaches the handler, stops the poller, and
+//      closes the store.
+//
+// The handler reads the persisted feed (filtered by provider/limit/since) and
+// maps the daemon-internal item shape onto the SDK CHANNEL_INBOX_ITEM_SCHEMA
+// wire shape. The redacted `fromDigest` is the only sender value emitted (as
+// `from`); raw sender ids and unredacted bodies never leave the daemon. The
+// monotonic cursor advances to max(receivedAt) in the returned window.
+// ---------------------------------------------------------------------------
+
+import type { HandlerContext } from '../context.ts';
+import type { Unregister } from '../register.ts';
+import { registerCatalogHandler } from '../register.ts';
+import type { RoutingRegistration } from '../index.ts';
+import {
+  buildAdapters,
+  registerAdapterFactory,
+  type AdapterContext,
+  type InboundChannelItem,
+  type RouteResolver,
+} from './provider-adapter.ts';
+import { InboxCursorStore } from './cursor-store.ts';
+import { InboundPoller } from './poller.ts';
+import { createSlackAdapter, SLACK_PROVIDER_ID } from './providers/slack.ts';
+import { createDiscordAdapter, DISCORD_PROVIDER_ID } from './providers/discord.ts';
+import { createEmailAdapter, EMAIL_PROVIDER_ID } from './providers/email.ts';
+
+export const INBOX_LIST_METHOD_ID = 'channels.inbox.list';
+const DEFAULT_LIMIT = 50;
+const MAX_LIMIT = 500;
+
+/** SDK `channels.inbox.list` input (single optional provider per the schema). */
+export interface InboxListInput {
+  provider?: string;
+  limit?: number;
+  since?: number;
+}
+
+/** One item in the SDK CHANNEL_INBOX_ITEM_SCHEMA wire shape. */
+export interface ChannelInboxItem {
+  id: string;
+  provider: string;
+  kind: string;
+  /** Redacted sender token (sha256First, 16 hex). Never the raw id. */
+  from: string;
+  subject?: string;
+  bodyPreview: string;
+  receivedAt: number;
+  unread: boolean;
+  routeId?: string;
+}
+
+/** SDK `channels.inbox.list` output (objectSchema: items/total/truncated/cursor?). */
+export interface InboxListOutput {
+  items: ChannelInboxItem[];
+  total: number;
+  truncated: boolean;
+  cursor?: string;
+}
+
+export interface RegisterInboxOptions {
+  /** Override the cursor-store filename (tests). */
+  storeFileName?: string;
+  /** Skip the initial seed poll (tests that drive polling manually). */
+  skipInitialPoll?: boolean;
+  /** Register the built-in slack/discord/email adapters (default true). */
+  registerBuiltins?: boolean;
+}
+
+function registerBuiltinAdapters(): void {
+  registerAdapterFactory(SLACK_PROVIDER_ID, (ctx) => createSlackAdapter(ctx));
+  registerAdapterFactory(DISCORD_PROVIDER_ID, (ctx) => createDiscordAdapter(ctx));
+  registerAdapterFactory(EMAIL_PROVIDER_ID, (ctx) => createEmailAdapter(ctx));
+}
+
+function normalizeInput(body: unknown): { providers?: string[]; limit: number; since?: number } {
+  const input = (body ?? {}) as InboxListInput;
+  const provider = typeof input.provider === 'string' && input.provider.length > 0
+    ? input.provider
+    : undefined;
+  let limit = typeof input.limit === 'number' && Number.isFinite(input.limit)
+    ? Math.floor(input.limit)
+    : DEFAULT_LIMIT;
+  limit = Math.min(Math.max(1, limit), MAX_LIMIT);
+  const since = typeof input.since === 'number' && Number.isFinite(input.since) && input.since >= 0
+    ? Math.floor(input.since)
+    : undefined;
+  return {
+    ...(provider ? { providers: [provider] } : {}),
+    limit,
+    ...(since !== undefined ? { since } : {}),
+  };
+}
+
+/** Map a daemon-internal item onto the SDK CHANNEL_INBOX_ITEM_SCHEMA wire shape. */
+function toWireItem(item: InboundChannelItem): ChannelInboxItem {
+  const wire: ChannelInboxItem = {
+    id: item.id,
+    provider: item.provider,
+    kind: item.kind,
+    from: item.fromDigest,
+    bodyPreview: item.bodyPreview,
+    receivedAt: item.receivedAt,
+    unread: item.unread,
+  };
+  if (item.subjectPreview.length > 0) wire.subject = item.subjectPreview;
+  if (item.routeId != null) wire.routeId = item.routeId;
+  return wire;
+}
+
+/**
+ * Bridge the routing surface's profile resolver into the adapter `RouteResolver`
+ * seam. Resolution is by provider surface (best-effort wildcard); a resolved
+ * profile id is surfaced as the item's routeId binding. Never throws.
+ */
+function routeResolverFromRouting(routing: RoutingRegistration): RouteResolver {
+  return ({ provider }) => {
+    try {
+      return routing.resolveProfileId(provider) ?? undefined;
+    } catch {
+      return undefined;
+    }
+  };
+}
+
+/**
+ * Register the inbox surface. Attaches the `channels.inbox.list` handler to the
+ * SDK catalog and returns an Unregister that detaches it, stops the poller, and
+ * closes the store.
+ */
+export function registerInboxMethods(
+  ctx: HandlerContext,
+  routing?: RoutingRegistration,
+  options: RegisterInboxOptions = {},
+): Unregister {
+  if (options.registerBuiltins !== false) {
+    registerBuiltinAdapters();
+  }
+
+  const adapterContext: AdapterContext = {
+    credentials: ctx.credentials,
+    logger: ctx.logger,
+    ...(routing ? { resolveRouteId: routeResolverFromRouting(routing) } : {}),
+  };
+  const adapters = buildAdapters(adapterContext);
+  const store = new InboxCursorStore(ctx.workingDirectory, options.storeFileName);
+  const poller = new InboundPoller({ adapters, store, logger: ctx.logger });
+
+  // Async bootstrap: init store, seed one poll, start loops. Failures are
+  // logged but never thrown out of register() — the handler still serves the
+  // (possibly empty) persisted feed.
+  const ready: Promise<void> = (async () => {
+    await store.init();
+    if (!options.skipInitialPoll) {
+      await poller.pollOnce();
+    }
+    poller.start();
+  })().catch((error: unknown) => {
+    ctx.logger.error('inbox surface bootstrap failed', {
+      error: error instanceof Error ? error.message : String(error),
+    });
+  });
+
+  const unregisterMethod = registerCatalogHandler<InboxListInput, InboxListOutput>(
+    ctx.catalog,
+    INBOX_LIST_METHOD_ID,
+    async (invocation) => {
+      await ready;
+      const { providers, limit, since } = normalizeInput(invocation.body);
+      const internalItems = store.listItems({
+        ...(providers ? { providers } : {}),
+        ...(since !== undefined ? { since } : {}),
+        limit,
+      });
+      const items = internalItems.map(toWireItem);
+      const total = store.countItems(providers);
+      const truncated = internalItems.length >= limit && total > internalItems.length;
+      const maxReceived = store.maxReceivedAt(providers);
+      const nextSince = Math.max(since ?? 0, maxReceived);
+      const output: InboxListOutput = { items, total, truncated };
+      if (nextSince > 0) output.cursor = String(nextSince);
+      return output;
+    },
+  );
+
+  return () => {
+    try {
+      unregisterMethod();
+    } finally {
+      poller.stop();
+      void store.close();
+    }
+  };
+}

package/src/daemon/handlers/inbox/mapping.ts

@@ -0,0 +1,192 @@
+// ---------------------------------------------------------------------------
+// Pure mapping + redaction helpers shared by every adapter.
+//
+// Rules (from the handoff contract):
+//   - fromDigest  = sha256First(senderExternalId, 16)   (never the raw id)
+//   - bodyPreview = plain-text, PII-stripped, truncated to 500 chars
+//   - subjectPreview <= 200 chars
+// These are pure and deterministic so they are unit-testable in isolation.
+// ---------------------------------------------------------------------------
+
+import { createHash } from 'node:crypto';
+
+export const SUBJECT_PREVIEW_MAX = 200;
+export const BODY_PREVIEW_MAX = 500;
+
+/** First `hexChars` hex chars of the SHA-256 digest of `input` (utf-8). */
+export function sha256First(input: string, hexChars: number): string {
+  const digest = createHash('sha256').update(input, 'utf-8').digest('hex');
+  return digest.slice(0, Math.max(0, hexChars));
+}
+
+/**
+ * Digest a sender's external id to a stable 16-hex-char token (the first 8
+ * bytes of the SHA-256 digest). The raw id is never emitted.
+ */
+export function digestSender(senderExternalId: string): string {
+  return sha256First(senderExternalId, 16);
+}
+
+// PII patterns stripped from body previews before they ever leave the daemon.
+const EMAIL_RE = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g;
+// E.164-ish and common separated phone numbers (>=7 digits with separators).
+const PHONE_RE = /(?:\+?\d[\d\s().-]{6,}\d)/g;
+// Long digit runs that look like card / account numbers (13-19 digits).
+const LONG_NUMBER_RE = /\b\d{13,19}\b/g;
+// IPv4 addresses.
+const IPV4_RE = /\b(?:\d{1,3}\.){3}\d{1,3}\b/g;
+
+// --- Secret / token patterns -----------------------------------------------
+// These must run BEFORE the generic numeric/email scrubbers and are ordered
+// most-specific first so a long opaque secret is never partially redacted.
+//
+// `Authorization: Bearer <token>` / bare `Bearer <token>`.
+const BEARER_RE = /\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/gi;
+// JSON Web Tokens: three base64url segments separated by dots (header.payload.sig).
+const JWT_RE = /\beyJ[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}/g;
+// Slack tokens: xoxb-/xoxp-/xoxa-/xoxr-/xoxs-... and legacy xox*-.
+const SLACK_TOKEN_RE = /\bxox[abeoprs]-[A-Za-z0-9-]{8,}/gi;
+// Common prefixed provider keys: OpenAI sk-/sk-proj-, GitHub gh[poursa]_,
+// Google AIza..., Stripe sk_live_/pk_live_/rk_live_, Slack-app xapp-, AWS AKIA...
+const PREFIXED_KEY_RE =
+  /\b(?:sk-(?:proj-)?[A-Za-z0-9_-]{16,}|gh[poursa]_[A-Za-z0-9]{16,}|AIza[A-Za-z0-9_-]{16,}|(?:sk|pk|rk)_(?:live|test)_[A-Za-z0-9]{16,}|xapp-[A-Za-z0-9-]{8,}|AKIA[A-Z0-9]{16})/g;
+// `token=`, `api_key=`, `access_token: ...`, `secret = ...` style key/value pairs.
+const KV_SECRET_RE =
+  /\b(?:api[_-]?key|access[_-]?token|refresh[_-]?token|client[_-]?secret|secret|token|password|passwd|pwd|authorization|auth)\b\s*[:=]\s*(?:"[^"]*"|'[^']*'|[A-Za-z0-9._~+/=-]{6,})/gi;
+// Generic high-entropy opaque blobs (>=24 chars of base64url/hex) not already
+// caught above — catches raw API keys pasted without a recognizable prefix.
+const OPAQUE_SECRET_RE = /\b[A-Za-z0-9_-]{24,}\b/g;
+
+/**
+ * Replace PII and credentials with stable redaction tokens (does not alter the
+ * length budget). Secrets/tokens are scrubbed before the email/phone/number
+ * passes so an OAuth/bearer/API token can never leak into a preview.
+ */
+export function stripPii(input: string): string {
+  return input
+    .replace(BEARER_RE, '[token]')
+    .replace(JWT_RE, '[token]')
+    .replace(SLACK_TOKEN_RE, '[token]')
+    .replace(PREFIXED_KEY_RE, '[token]')
+    .replace(KV_SECRET_RE, (match) => {
+      const sep = match.includes('=') ? '=' : ':';
+      const key = match.slice(0, match.indexOf(sep)).trimEnd();
+      return `${key}${sep}[token]`;
+    })
+    .replace(EMAIL_RE, '[email]')
+    .replace(IPV4_RE, '[ip]')
+    .replace(LONG_NUMBER_RE, '[number]')
+    .replace(PHONE_RE, (match) => {
+      // Avoid eating short numeric tokens that survived LONG_NUMBER_RE; only
+      // redact when there are at least 7 digits.
+      const digits = match.replace(/\D/g, '');
+      return digits.length >= 7 ? '[phone]' : match;
+    })
+    // Sweep any remaining long opaque blob (e.g. a bare API key) last so we do
+    // not clobber the redaction tokens we just inserted.
+    .replace(OPAQUE_SECRET_RE, (match) => (/^[A-Za-z]+$/.test(match) ? match : '[token]'));
+}
+
+// --- Markup / MIME de-structuring ------------------------------------------
+// Email BODY[TEXT] is frequently raw HTML and/or a multipart/MIME payload with
+// boundary lines and Content-* headers. Previews must be human-readable plain
+// text, so we de-MIME (prefer the text/plain part), strip tags, and decode the
+// handful of HTML entities that survive into previews. This is a no-op on text
+// that is already plain.
+const HTML_ENTITIES: Record<string, string> = {
+  '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"',
+  '&#39;': "'", '&apos;': "'", '&nbsp;': ' ',
+};
+
+/** True when the text looks like a MIME multipart payload (has boundary lines). */
+function isMultipart(text: string): boolean {
+  return /^--[^\r\n]+\r?\n/m.test(text) && /content-type:/i.test(text);
+}
+
+/**
+ * Given a multipart body, return the decoded text/plain part if present,
+ * otherwise the text/html part, otherwise the original input. Strips the
+ * per-part MIME headers so only the body bytes remain.
+ */
+function extractMimePart(text: string): string {
+  const boundaryMatch = /^--([^\r\n]+?)(?:--)?\r?$/m.exec(text);
+  if (!boundaryMatch) return text;
+  const boundary = boundaryMatch[1]!;
+  const parts = text.split(new RegExp(`--${boundary.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:--)?\r?\n?`));
+  let htmlPart: string | undefined;
+  for (const rawPart of parts) {
+    const split = /\r?\n\r?\n/.exec(rawPart);
+    if (!split) continue;
+    const headers = rawPart.slice(0, split.index);
+    const body = rawPart.slice(split.index + split[0].length);
+    const ctype = /content-type:\s*([^\r\n;]+)/i.exec(headers)?.[1]?.trim().toLowerCase();
+    if (!ctype) continue;
+    if (ctype === 'text/plain') return body.trim();
+    if (ctype === 'text/html' && htmlPart === undefined) htmlPart = body;
+  }
+  return (htmlPart ?? text).trim();
+}
+
+/** Strip stray top-level MIME/Content-* headers from a single-part body. */
+function stripMimeHeaders(text: string): string {
+  return text.replace(
+    /^(?:content-type|content-transfer-encoding|content-disposition|content-id|mime-version|--[^\r\n]+)\b[^\r\n]*\r?\n/gim,
+    '',
+  );
+}
+
+/** Decode the small set of HTML entities that matter for plain-text previews. */
+function decodeEntities(text: string): string {
+  return text
+    .replace(/&amp;|&lt;|&gt;|&quot;|&#39;|&apos;|&nbsp;/gi, (m) => HTML_ENTITIES[m.toLowerCase()] ?? m)
+    .replace(/&#(\d{1,7});/g, (_m, dec: string) => {
+      const code = Number.parseInt(dec, 10);
+      return Number.isFinite(code) ? String.fromCodePoint(code) : _m;
+    });
+}
+
+/**
+ * Convert HTML/MIME body text into readable plain text. Drops <script>/<style>
+ * blocks entirely, turns block-level tags into spaces, removes all remaining
+ * tags, decodes entities, and de-MIMEs multipart payloads. Plain text passes
+ * through unchanged (modulo entity decoding).
+ */
+export function stripMarkup(input: string): string {
+  let text = input;
+  if (isMultipart(text)) {
+    text = extractMimePart(text);
+  }
+  text = stripMimeHeaders(text);
+  // Drop script/style contents before tag removal so their bodies never leak.
+  text = text.replace(/<(script|style)\b[^>]*>[\s\S]*?<\/\1>/gi, ' ');
+  // Only treat as HTML if there is an actual tag; avoids mangling plain text
+  // that merely contains a stray '<'.
+  if (/<[a-z!/][^>]*>/i.test(text)) {
+    text = text
+      .replace(/<\/?(?:br|p|div|tr|li|h[1-6]|table|ul|ol|blockquote|hr)\b[^>]*>/gi, ' ')
+      .replace(/<[^>]+>/g, '');
+  }
+  return decodeEntities(text);
+}
+
+/** Collapse whitespace and trim — keeps previews single-line and tidy. */
+export function normalizeWhitespace(input: string): string {
+  return input.replace(/\s+/g, ' ').trim();
+}
+
+/** Build a display-safe subject preview (<=200 chars, no PII, single line). */
+export function toSubjectPreview(raw: string | undefined | null): string {
+  const normalized = normalizeWhitespace(stripPii(raw ?? ''));
+  return normalized.slice(0, SUBJECT_PREVIEW_MAX);
+}
+
+/**
+ * Build a display-safe body preview (<=500 chars, plain text, PII-stripped,
+ * single line). HTML/MIME is de-structured to readable text first so previews
+ * of real-world (HTML/multipart) emails never leak tags or MIME headers.
+ */
+export function toBodyPreview(raw: string | undefined | null): string {
+  const plain = stripMarkup(raw ?? '');
+  const normalized = normalizeWhitespace(stripPii(plain));
+  return normalized.slice(0, BODY_PREVIEW_MAX);
+}

package/src/daemon/handlers/inbox/poller.ts

@@ -0,0 +1,155 @@
+// ---------------------------------------------------------------------------
+// Inbound provider poller.
+//
+// Runs one setInterval per provider at the provider's own cadence (Slack/
+// Discord 30s, email 60s, others 120s). Each tick:
+//   1. resolves the provider's persisted cursor (nextSince)
+//   2. calls adapter.poll({ since, limit })
+//   3. dedups + persists items into the cursor store (upsert)
+//   4. advances the cursor monotonically to max(receivedAt)
+//   5. records the last per-provider state for channels.inbox.list to report
+//
+// One bad provider can never crash the loop: adapter.poll() resolves with
+// state:'unavailable' instead of rejecting, and any thrown error is caught and
+// downgraded to an 'unavailable' status here.
+// ---------------------------------------------------------------------------
+
+import type { InboundProviderAdapter, ProviderState } from './provider-adapter.ts';
+import type { InboxCursorStore } from './cursor-store.ts';
+import type { HandlerLogger } from '../context.ts';
+
+export interface ProviderStatus {
+  id: string;
+  state: ProviderState;
+  itemCount: number;
+  error?: string;
+  lastPolledAt?: number;
+}
+
+export interface PollerOptions {
+  adapters: Map<string, InboundProviderAdapter>;
+  store: InboxCursorStore;
+  logger: HandlerLogger;
+  /** Max items fetched per provider per tick. */
+  perProviderLimit?: number;
+  /** Inject a timer factory for tests (defaults to global setInterval). */
+  setIntervalImpl?: typeof setInterval;
+  clearIntervalImpl?: typeof clearInterval;
+}
+
+const DEFAULT_PER_PROVIDER_LIMIT = 50;
+
+export class InboundPoller {
+  private readonly adapters: Map<string, InboundProviderAdapter>;
+  private readonly store: InboxCursorStore;
+  private readonly logger: HandlerLogger;
+  private readonly perProviderLimit: number;
+  private readonly setIntervalImpl: typeof setInterval;
+  private readonly clearIntervalImpl: typeof clearInterval;
+  private readonly timers = new Map<string, ReturnType<typeof setInterval>>();
+  private readonly statuses = new Map<string, ProviderStatus>();
+  private readonly inFlight = new Set<string>();
+  private started = false;
+
+  constructor(options: PollerOptions) {
+    this.adapters = options.adapters;
+    this.store = options.store;
+    this.logger = options.logger;
+    this.perProviderLimit = options.perProviderLimit ?? DEFAULT_PER_PROVIDER_LIMIT;
+    this.setIntervalImpl = options.setIntervalImpl ?? setInterval;
+    this.clearIntervalImpl = options.clearIntervalImpl ?? clearInterval;
+    for (const id of this.adapters.keys()) {
+      this.statuses.set(id, { id, state: 'empty', itemCount: 0 });
+    }
+  }
+
+  /** Begin per-provider interval loops. Idempotent. Does NOT poll immediately. */
+  start(): void {
+    if (this.started) return;
+    this.started = true;
+    for (const [id, adapter] of this.adapters) {
+      const handle = this.setIntervalImpl(() => {
+        void this.pollProvider(id, adapter);
+      }, adapter.pollIntervalMs);
+      // Do not keep the event loop alive solely for polling (Bun/Node unref).
+      (handle as unknown as { unref?: () => void }).unref?.();
+      this.timers.set(id, handle);
+    }
+  }
+
+  /** Run a single poll across all providers now (used on register + tests). */
+  async pollOnce(): Promise<void> {
+    await Promise.all(
+      [...this.adapters.entries()].map(([id, adapter]) => this.pollProvider(id, adapter)),
+    );
+  }
+
+  /** Poll a single provider, dedup + persist, update status. Never throws. */
+  async pollProvider(id: string, adapter: InboundProviderAdapter): Promise<void> {
+    if (this.inFlight.has(id)) return; // skip overlapping ticks
+    this.inFlight.add(id);
+    const since = this.store.getCursor(id) || undefined;
+    try {
+      const result = await adapter.poll({ since, limit: this.perProviderLimit });
+      if (result.state === 'unavailable') {
+        this.setStatus(id, {
+          id,
+          state: 'unavailable',
+          itemCount: 0,
+          error: result.error ?? 'provider unavailable',
+          lastPolledAt: Date.now(),
+        });
+        return;
+      }
+      const newCount = this.store.upsertItems(result.items);
+      let maxReceived = since ?? 0;
+      for (const item of result.items) {
+        if (item.receivedAt > maxReceived) maxReceived = item.receivedAt;
+      }
+      if (maxReceived > 0) this.store.advanceCursor(id, maxReceived);
+      await this.store.flush();
+      this.setStatus(id, {
+        id,
+        state: result.items.length > 0 ? 'ready' : 'empty',
+        itemCount: newCount,
+        lastPolledAt: Date.now(),
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.warn('inbound poll failed', { provider: id, error: message });
+      this.setStatus(id, {
+        id,
+        state: 'unavailable',
+        itemCount: 0,
+        error: message,
+        lastPolledAt: Date.now(),
+      });
+    } finally {
+      this.inFlight.delete(id);
+    }
+  }
+
+  /** Snapshot of the last known status for each provider. */
+  snapshotStatuses(providerIds?: readonly string[]): ProviderStatus[] {
+    const ids = providerIds && providerIds.length > 0
+      ? providerIds.filter((id) => this.statuses.has(id))
+      : [...this.statuses.keys()];
+    return ids.map((id) => {
+      const status = this.statuses.get(id)!;
+      return { ...status };
+    });
+  }
+
+  /** Stop all interval loops. Idempotent. */
+  stop(): void {
+    for (const handle of this.timers.values()) {
+      this.clearIntervalImpl(handle);
+    }
+    this.timers.clear();
+    this.started = false;
+  }
+
+  private setStatus(id: string, status: ProviderStatus): void {
+    this.statuses.set(id, status);
+  }
+}