@pellux/goodvibes-tui 1.27.0 → 2.0.1

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

@@ -1,261 +0,0 @@
-// ---------------------------------------------------------------------------
-// Channel routing surface — HANDLERS for the SDK-defined methods
-//   - channels.routing.list   (read-only)
-//   - channels.routing.assign (admin, confirmation-gated)
-//   - channels.routing.delete (admin, dangerous, confirmation-gated)
-//
-// The SDK's GatewayMethodCatalog already registered the canonical descriptors
-// (id, input/output schema, access, scopes, dangerous) for these three method
-// ids with `handler: undefined`. This module NEVER re-declares an id, schema,
-// or descriptor: it looks each one up by id and attaches a typed handler via
-// `registerCatalogHandlers`, flipping the builtin method from HTTP-fallback to
-// in-process execution. Handler outputs match the SDK output schemas exactly.
-//
-// Confirmation posture (per the daemon handoff, Responsibility 2): assign and
-// delete are control-plane mutations that require explicit user confirmation
-// (the SDK marks assign access:admin + 'Requires explicit confirmation', and
-// delete dangerous:true). Both pass `{ confirm: true }` so the register wrapper
-// enforces `body.confirm === true` AND `context.explicitUserRequest === true`.
-// list is read-only and ungated.
-// ---------------------------------------------------------------------------
-
-import type { HandlerContext } from '../context.ts';
-import type { RoutingRegistration as FoundationRoutingRegistration } from '../index.ts';
-import {
-  registerCatalogHandlers,
-  type CatalogHandlerEntry,
-  type TypedHandler,
-  type Unregister,
-} from '../register.ts';
-import {
-  buildChannelId,
-  parseChannelId,
-  RouteStore,
-  toRouteListItem,
-  type RoutingChannelRoute,
-  type RoutingRouteListItem,
-} from './route-store.ts';
-import { createRoutingResolver, type RoutingResolver } from './routing-resolver.ts';
-
-export { createInboxRouteResolver, type RouteResolver, type RouteResolverInput } from './inbox-bridge.ts';
-export {
-  buildChannelId,
-  parseChannelId,
-  RouteStore,
-  toRouteListItem,
-  type RoutingChannelRoute,
-  type RoutingRouteListItem,
-} from './route-store.ts';
-export {
-  createRoutingResolver,
-  resolveProfile,
-  WILDCARD_SURFACE,
-  type RoutingResolver,
-} from './routing-resolver.ts';
-
-// ---------------------------------------------------------------------------
-// Wire shapes (derived from the SDK contracts; NOT re-declared schemas).
-//
-// list   in : { profileId?, surfaceKind?, limit? }
-//         out: { routes: [{ id, createdAt, updatedAt, surfaceKind, routeId?,
-//                           profileId, label? }], total }   (SDK route-item shape)
-// assign in : { channelId?, surfaceKind, routeId?, profileId, label? }
-//             out: { assignmentId, channelId?, surfaceKind, routeId?, profileId, label?, createdAt, updatedAt }
-// delete in : { assignmentId }                        out: { deleted, assignmentId }
-// ---------------------------------------------------------------------------
-
-interface RoutingListBody {
-  profileId?: unknown;
-  surfaceKind?: unknown;
-  limit?: unknown;
-}
-interface RoutingListResult {
-  routes: RoutingRouteListItem[];
-  total: number;
-}
-
-interface RoutingAssignBody {
-  channelId?: unknown;
-  surfaceKind?: unknown;
-  routeId?: unknown;
-  profileId?: unknown;
-  label?: unknown;
-}
-interface RoutingAssignResult {
-  assignmentId: string;
-  channelId: string;
-  surfaceKind: string;
-  routeId?: string;
-  profileId: string;
-  label?: string;
-  createdAt: string;
-  updatedAt: string;
-}
-
-interface RoutingDeleteBody {
-  assignmentId?: unknown;
-}
-interface RoutingDeleteResult {
-  deleted: boolean;
-  assignmentId: string;
-}
-
-const LIST_METHOD = 'channels.routing.list';
-const ASSIGN_METHOD = 'channels.routing.assign';
-const DELETE_METHOD = 'channels.routing.delete';
-
-function optionalString(value: unknown): string | undefined {
-  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
-}
-
-function clampLimit(value: unknown): number | undefined {
-  if (value === undefined || value === null || value === '') return undefined;
-  const n = typeof value === 'number' ? value : Number(value);
-  if (!Number.isFinite(n)) return undefined;
-  return Math.max(1, Math.floor(n));
-}
-
-/**
- * Routing surface handle. Satisfies the foundation `RoutingRegistration`
- * (`{ unregister, resolveProfileId }`) and additionally exposes the live
- * {@link RoutingResolver} and {@link RouteStore} so the inbox surface and tests
- * can reuse routing resolution without going through the catalog.
- */
-export interface RoutingRegistration extends FoundationRoutingRegistration {
-  readonly resolver: RoutingResolver;
-  readonly store: RouteStore;
-}
-
-/**
- * Attach the channel-routing handlers to the SDK gateway catalog held by `ctx`.
- *
- * The {@link RouteStore} is lazily initialized on first invocation (the
- * register contract is synchronous) so registration never blocks on disk I/O.
- * Returns the teardown plus the resolver/store handles.
- */
-export function registerRoutingMethods(ctx: HandlerContext): RoutingRegistration {
-  const store = new RouteStore({ workingDirectory: ctx.workingDirectory });
-  const resolver = createRoutingResolver(store);
-
-  let initPromise: Promise<void> | null = null;
-  const ensureInit = async (): Promise<void> => {
-    if (!initPromise) {
-      initPromise = store.init().catch((error) => {
-        // Allow a later invocation to retry initialization.
-        initPromise = null;
-        throw error;
-      });
-    }
-    await initPromise;
-  };
-
-  const listHandler: TypedHandler<RoutingListBody, RoutingListResult> = async ({ body }) => {
-    await ensureInit();
-    const routes = store.list({
-      profileId: optionalString(body.profileId),
-      surfaceKind: optionalString(body.surfaceKind),
-    });
-    const limit = clampLimit(body.limit);
-    const limited = limit !== undefined ? routes.slice(0, limit) : routes;
-    // Project to the SDK `channels.routing.list` item shape: emit `id`
-    // (= assignmentId) and drop the daemon-internal `channelId`/`assignmentId`,
-    // which additionalProperties:false forbids.
-    const items = limited.map(toRouteListItem);
-    return { routes: items, total: items.length };
-  };
-
-  const assignHandler: TypedHandler<RoutingAssignBody, RoutingAssignResult> = async ({ body, context }) => {
-    await ensureInit();
-    const profileId = optionalString(body.profileId);
-    if (profileId === undefined) {
-      throw new Error('profileId is required');
-    }
-    // The SDK contract accepts either a composite `channelId` or the
-    // `surfaceKind` (+ optional `routeId`) parts. Prefer an explicit
-    // channelId; otherwise build one from the parts.
-    const explicitChannelId = optionalString(body.channelId);
-    const surfaceKind = optionalString(body.surfaceKind);
-    const routeId = optionalString(body.routeId);
-    const channelId = explicitChannelId ?? (
-      surfaceKind !== undefined ? buildChannelId(surfaceKind, routeId) : undefined
-    );
-    if (channelId === undefined) {
-      throw new Error('surfaceKind (or channelId) is required');
-    }
-    const { route, created } = await store.upsert({
-      channelId,
-      profileId,
-      label: optionalString(body.label),
-    });
-    ctx.logger.info('channels.routing.assign', {
-      assignmentId: route.assignmentId,
-      channelId: route.channelId,
-      surfaceKind: route.surfaceKind,
-      profileId: route.profileId,
-      created,
-      principalId: context.principalId,
-    });
-    const result: RoutingAssignResult = {
-      assignmentId: route.assignmentId,
-      channelId: route.channelId,
-      surfaceKind: route.surfaceKind,
-      profileId: route.profileId,
-      createdAt: route.createdAt,
-      updatedAt: route.updatedAt,
-    };
-    if (route.routeId !== undefined) result.routeId = route.routeId;
-    if (route.label !== undefined) result.label = route.label;
-    return result;
-  };
-
-  const deleteHandler: TypedHandler<RoutingDeleteBody, RoutingDeleteResult> = async ({ body, context }) => {
-    await ensureInit();
-    const assignmentId = optionalString(body.assignmentId);
-    if (assignmentId === undefined) {
-      throw new Error('assignmentId is required');
-    }
-    const deleted = await store.delete(assignmentId);
-    ctx.logger.info('channels.routing.delete', {
-      assignmentId,
-      deleted,
-      principalId: context.principalId,
-    });
-    return { deleted, assignmentId };
-  };
-
-  const entries: CatalogHandlerEntry[] = [
-    { id: LIST_METHOD, handler: listHandler as TypedHandler<unknown, unknown> },
-    {
-      id: ASSIGN_METHOD,
-      handler: assignHandler as TypedHandler<unknown, unknown>,
-      options: { confirm: true },
-    },
-    {
-      id: DELETE_METHOD,
-      handler: deleteHandler as TypedHandler<unknown, unknown>,
-      options: { confirm: true },
-    },
-  ];
-
-  const teardownHandlers = registerCatalogHandlers(ctx.catalog, entries);
-
-  const unregister: Unregister = () => {
-    teardownHandlers();
-    store.close();
-  };
-
-  return {
-    unregister,
-    resolveProfileId: (surfaceKind: string, routeId?: string) =>
-      resolver.getProfileForChannel(surfaceKind, routeId),
-    resolver,
-    store,
-  };
-}
-
-/**
- * Provider entry point consumed by `registerDaemonHandlers`
- * (`DaemonHandlerSurfaceProviders.registerRouting`).
- */
-export const registerRouting = (ctx: HandlerContext): RoutingRegistration =>
-  registerRoutingMethods(ctx);

package/src/daemon/handlers/routing/route-store.ts

@@ -1,319 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { HandlerSqliteStore } from '../sqlite-store.ts';
-import { HandlerError } from '../errors.ts';
-
-/**
- * A persisted channel-to-profile routing assignment, in the exact shape the
- * `channels.routing.*` methods serve. Keyed on a composite `channelId`
- * (`surfaceKind` or `surfaceKind:routeId`). The SDK output schemas require
- * `surfaceKind`, `profileId`, `createdAt`, and `updatedAt`; `channelId`,
- * `routeId`, and `label` are carried through as optional refinements.
- */
-export interface RoutingChannelRoute {
-  assignmentId: string;
-  /** Composite key: `surfaceKind` or `surfaceKind:routeId`. */
-  channelId: string;
-  surfaceKind: string;
-  routeId?: string;
-  profileId: string;
-  label?: string;
-  createdAt: string; // ISO-8601
-  updatedAt: string; // ISO-8601
-}
-
-/**
- * Per-route item shape emitted by `channels.routing.list`, matching the SDK
- * `CHANNEL_ROUTING_RULE_SCHEMA` exactly: properties
- * {id, createdAt, updatedAt, surfaceKind, routeId, profileId, label},
- * required [id, createdAt, updatedAt, surfaceKind, profileId], and
- * additionalProperties:false. The store's `assignmentId` is projected to `id`,
- * and the daemon-internal `channelId` is dropped (it is forbidden by the
- * schema's additionalProperties:false).
- */
-export interface RoutingRouteListItem {
-  id: string;
-  createdAt: string; // ISO-8601
-  updatedAt: string; // ISO-8601
-  surfaceKind: string;
-  routeId?: string;
-  profileId: string;
-  label?: string;
-}
-
-/**
- * Project a stored route to the SDK `channels.routing.list` item shape. Pure;
- * only includes optional `routeId`/`label` when present so the payload never
- * carries `undefined`-valued or schema-forbidden keys.
- */
-export function toRouteListItem(route: RoutingChannelRoute): RoutingRouteListItem {
-  const item: RoutingRouteListItem = {
-    id: route.assignmentId,
-    createdAt: route.createdAt,
-    updatedAt: route.updatedAt,
-    surfaceKind: route.surfaceKind,
-    profileId: route.profileId,
-  };
-  if (route.routeId !== undefined) {
-    item.routeId = route.routeId;
-  }
-  if (route.label !== undefined) {
-    item.label = route.label;
-  }
-  return item;
-}
-
-/** Parsed components of a composite channelId. */
-export interface ParsedChannelId {
-  surfaceKind: string;
-  routeId?: string;
-}
-
-export interface RouteUpsertInput {
-  channelId: string;
-  profileId: string;
-  label?: string;
-}
-
-export interface RouteUpsertResult {
-  route: RoutingChannelRoute;
-  created: boolean;
-}
-
-export interface RouteListFilter {
-  profileId?: string;
-  surfaceKind?: string;
-}
-
-const SCHEMA: string[] = [
-  `CREATE TABLE IF NOT EXISTS routes (
-    assignmentId TEXT PRIMARY KEY,
-    channelId TEXT NOT NULL,
-    surfaceKind TEXT NOT NULL,
-    routeId TEXT,
-    profileId TEXT NOT NULL,
-    label TEXT,
-    createdAt TEXT NOT NULL,
-    updatedAt TEXT NOT NULL
-  )`,
-  `CREATE INDEX IF NOT EXISTS idx_routes_surface_route ON routes (surfaceKind, routeId)`,
-  // Enforce one assignment per channel — the upsert path relies on this.
-  `CREATE UNIQUE INDEX IF NOT EXISTS idx_routes_channel ON routes (channelId)`,
-];
-
-interface RouteRow {
-  assignmentId: string;
-  channelId: string;
-  surfaceKind: string;
-  routeId: string | null;
-  profileId: string;
-  label: string | null;
-  createdAt: string;
-  updatedAt: string;
-}
-
-/**
- * Parse a composite channelId into its `surfaceKind` and optional `routeId`.
- *
- * The channelId format is `surfaceKind` (surface-only / wildcard) or
- * `surfaceKind:routeId`. Everything after the FIRST colon is the routeId, so
- * route IDs may themselves contain colons (e.g. `slack:C123:thread`).
- */
-export function parseChannelId(channelId: string): ParsedChannelId {
-  const raw = typeof channelId === 'string' ? channelId.trim() : '';
-  if (raw.length === 0) {
-    throw new HandlerError('channelId is required', 'ROUTING_INVALID_CHANNEL_ID', 400);
-  }
-  const separator = raw.indexOf(':');
-  if (separator === -1) {
-    return { surfaceKind: raw };
-  }
-  const surfaceKind = raw.slice(0, separator).trim();
-  const routeId = raw.slice(separator + 1).trim();
-  if (surfaceKind.length === 0) {
-    throw new HandlerError('channelId is missing a surfaceKind', 'ROUTING_INVALID_CHANNEL_ID', 400);
-  }
-  // A trailing colon with no routeId collapses to a surface-only assignment.
-  return routeId.length === 0 ? { surfaceKind } : { surfaceKind, routeId };
-}
-
-/** Build a canonical composite channelId from its parts. */
-export function buildChannelId(surfaceKind: string, routeId?: string): string {
-  return routeId === undefined || routeId === '' ? surfaceKind : `${surfaceKind}:${routeId}`;
-}
-
-function rowToRoute(row: RouteRow): RoutingChannelRoute {
-  const route: RoutingChannelRoute = {
-    assignmentId: row.assignmentId,
-    channelId: row.channelId,
-    surfaceKind: row.surfaceKind,
-    profileId: row.profileId,
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt,
-  };
-  if (row.routeId !== null && row.routeId !== '') route.routeId = row.routeId;
-  if (row.label !== null && row.label !== '') route.label = row.label;
-  return route;
-}
-
-/**
- * SQLite-backed store for channel-to-profile routing assignments.
- *
- * Wraps {@link HandlerSqliteStore} (file `channel-routes.sqlite`) and persists
- * after every mutation. The store owns the composite-key parsing so callers only
- * ever deal with `channelId` strings.
- */
-export class RouteStore {
-  private readonly store: HandlerSqliteStore;
-  private initialized = false;
-
-  constructor(options: { workingDirectory: string }) {
-    this.store = new HandlerSqliteStore({
-      workingDirectory: options.workingDirectory,
-      fileName: 'channel-routes.sqlite',
-      schema: SCHEMA,
-    });
-  }
-
-  get dbPath(): string {
-    return this.store.dbPath;
-  }
-
-  async init(): Promise<void> {
-    if (this.initialized) return;
-    await this.store.init();
-    this.initialized = true;
-  }
-
-  close(): void {
-    this.store.close();
-    this.initialized = false;
-  }
-
-  private requireInit(): void {
-    if (!this.initialized) {
-      throw new HandlerError('RouteStore not initialized', 'ROUTING_STORE_UNINITIALIZED', 500);
-    }
-  }
-
-  /** All assignments, ordered most-recently-updated first. */
-  listAll(): RoutingChannelRoute[] {
-    this.requireInit();
-    const rows = this.store.all<RouteRow>(
-      `SELECT assignmentId, channelId, surfaceKind, routeId, profileId, label, createdAt, updatedAt
-       FROM routes ORDER BY updatedAt DESC, assignmentId ASC`,
-    );
-    return rows.map(rowToRoute);
-  }
-
-  /** Assignments filtered by optional profileId and/or surfaceKind. */
-  list(filter: RouteListFilter = {}): RoutingChannelRoute[] {
-    this.requireInit();
-    const clauses: string[] = [];
-    const params: (string | number)[] = [];
-    if (filter.profileId !== undefined && filter.profileId !== '') {
-      clauses.push('profileId = ?');
-      params.push(filter.profileId);
-    }
-    if (filter.surfaceKind !== undefined && filter.surfaceKind !== '') {
-      clauses.push('surfaceKind = ?');
-      params.push(filter.surfaceKind);
-    }
-    const where = clauses.length > 0 ? `WHERE ${clauses.join(' AND ')}` : '';
-    const rows = this.store.all<RouteRow>(
-      `SELECT assignmentId, channelId, surfaceKind, routeId, profileId, label, createdAt, updatedAt
-       FROM routes ${where} ORDER BY updatedAt DESC, assignmentId ASC`,
-      params,
-    );
-    return rows.map(rowToRoute);
-  }
-
-  /** Lookup a single assignment by its composite channelId. */
-  findByChannelId(channelId: string): RoutingChannelRoute | null {
-    this.requireInit();
-    const row = this.store.get<RouteRow>(
-      `SELECT assignmentId, channelId, surfaceKind, routeId, profileId, label, createdAt, updatedAt
-       FROM routes WHERE channelId = ?`,
-      [channelId],
-    );
-    return row ? rowToRoute(row) : null;
-  }
-
-  /** Lookup a single assignment by its assignmentId. */
-  findById(assignmentId: string): RoutingChannelRoute | null {
-    this.requireInit();
-    const row = this.store.get<RouteRow>(
-      `SELECT assignmentId, channelId, surfaceKind, routeId, profileId, label, createdAt, updatedAt
-       FROM routes WHERE assignmentId = ?`,
-      [assignmentId],
-    );
-    return row ? rowToRoute(row) : null;
-  }
-
-  /**
-   * Create or update the assignment for a channel.
-   *
-   * `created` is true when no prior assignment existed for the channelId, false
-   * when an existing row was updated. The assignmentId is stable across updates
-   * (it is preserved from the existing row). Persists to disk after the write.
-   */
-  async upsert(input: RouteUpsertInput): Promise<RouteUpsertResult> {
-    this.requireInit();
-    const profileId = typeof input.profileId === 'string' ? input.profileId.trim() : '';
-    if (profileId.length === 0) {
-      throw new HandlerError('profileId is required', 'ROUTING_INVALID_PROFILE_ID', 400);
-    }
-    const { surfaceKind, routeId } = parseChannelId(input.channelId);
-    const channelId = buildChannelId(surfaceKind, routeId);
-    const label = typeof input.label === 'string' && input.label.trim().length > 0
-      ? input.label.trim()
-      : null;
-    const now = new Date().toISOString();
-
-    const existing = this.findByChannelId(channelId);
-    if (existing) {
-      this.store.run(
-        `UPDATE routes
-         SET profileId = ?, label = ?, surfaceKind = ?, routeId = ?, updatedAt = ?
-         WHERE assignmentId = ?`,
-        [profileId, label, surfaceKind, routeId ?? null, now, existing.assignmentId],
-      );
-      await this.store.save();
-      const route = this.findById(existing.assignmentId);
-      if (!route) {
-        throw new HandlerError('Failed to read back updated route', 'ROUTING_WRITE_FAILED', 500);
-      }
-      return { route, created: false };
-    }
-
-    const assignmentId = randomUUID();
-    this.store.run(
-      `INSERT INTO routes
-        (assignmentId, channelId, surfaceKind, routeId, profileId, label, createdAt, updatedAt)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-      [assignmentId, channelId, surfaceKind, routeId ?? null, profileId, label, now, now],
-    );
-    await this.store.save();
-    const route = this.findById(assignmentId);
-    if (!route) {
-      throw new HandlerError('Failed to read back inserted route', 'ROUTING_WRITE_FAILED', 500);
-    }
-    return { route, created: true };
-  }
-
-  /**
-   * Delete an assignment by assignmentId. Returns true when a row was removed,
-   * false when no matching assignment existed. Persists to disk after a delete.
-   */
-  async delete(assignmentId: string): Promise<boolean> {
-    this.requireInit();
-    const id = typeof assignmentId === 'string' ? assignmentId.trim() : '';
-    if (id.length === 0) {
-      throw new HandlerError('assignmentId is required', 'ROUTING_INVALID_ASSIGNMENT_ID', 400);
-    }
-    const existing = this.findById(id);
-    if (!existing) return false;
-    this.store.run('DELETE FROM routes WHERE assignmentId = ?', [id]);
-    await this.store.save();
-    return true;
-  }
-}

package/src/daemon/handlers/routing/routing-resolver.ts

@@ -1,75 +0,0 @@
-import type { RoutingChannelRoute } from './route-store.ts';
-import type { RouteStore } from './route-store.ts';
-
-/** Wildcard surfaceKind that matches any surface as a last resort. */
-export const WILDCARD_SURFACE = 'any';
-
-/**
- * Pure resolution of a profileId from a set of routes, applying the EXACT same
- * order as the agent-side `getProfileForChannel()` so offline and online
- * routing produce identical results:
- *
- *   1. exact match    — surfaceKind AND routeId both match
- *   2. surface-only   — surfaceKind matches, route has no routeId
- *   3. wildcard       — a route with surfaceKind === 'any' (no routeId)
- *
- * Returns the matching profileId, or `null` when nothing matches.
- */
-export function resolveProfile(
-  routes: readonly RoutingChannelRoute[],
-  surfaceKind: string,
-  routeId?: string,
-): string | null {
-  const surface = typeof surfaceKind === 'string' ? surfaceKind.trim() : '';
-  if (surface.length === 0) return null;
-  const route = typeof routeId === 'string' && routeId.trim().length > 0 ? routeId.trim() : undefined;
-
-  // 1. Exact match (surfaceKind + routeId). Only attempted when a routeId is
-  //    supplied by the caller.
-  if (route !== undefined) {
-    const exact = routes.find(
-      (entry) => entry.surfaceKind === surface && entry.routeId === route,
-    );
-    if (exact) return exact.profileId;
-  }
-
-  // 2. Surface-only match (surfaceKind, no routeId on the route).
-  const surfaceOnly = routes.find(
-    (entry) => entry.surfaceKind === surface && (entry.routeId === undefined || entry.routeId === ''),
-  );
-  if (surfaceOnly) return surfaceOnly.profileId;
-
-  // 3. Wildcard match (surfaceKind === 'any', no routeId).
-  const wildcard = routes.find(
-    (entry) => entry.surfaceKind === WILDCARD_SURFACE && (entry.routeId === undefined || entry.routeId === ''),
-  );
-  if (wildcard) return wildcard.profileId;
-
-  return null;
-}
-
-/** Resolver bound to a live {@link RouteStore}. */
-export interface RoutingResolver {
-  /**
-   * Resolve the profileId that should handle an inbound message on the given
-   * surface/route, applying the agent resolution order. Returns null when no
-   * assignment matches (caller falls back to the default session).
-   */
-  getProfileForChannel(surfaceKind: string, routeId?: string): string | null;
-  /** Alias of {@link getProfileForChannel}, exported for inbox surface reuse. */
-  resolveProfile(surfaceKind: string, routeId?: string): string | null;
-}
-
-/**
- * Create a resolver backed by a {@link RouteStore}. The store must already be
- * initialized; each call reads the current route set so assignments take effect
- * immediately after a mutation.
- */
-export function createRoutingResolver(store: RouteStore): RoutingResolver {
-  const resolve = (surfaceKind: string, routeId?: string): string | null =>
-    resolveProfile(store.listAll(), surfaceKind, routeId);
-  return {
-    getProfileForChannel: resolve,
-    resolveProfile: resolve,
-  };
-}