@pellux/goodvibes-tui 0.25.0 → 0.26.0

package/src/daemon/channels/inbox/register.ts

@@ -1,247 +0,0 @@
-// ---------------------------------------------------------------------------
-// Surface register: `channels.inbox.list`.
-//
-// register(ctx) =>
-//   1. registers built-in provider adapter factories (slack/discord/email)
-//   2. constructs adapters with a daemon credential store
-//   3. opens the inbox cursor store and seeds an initial poll
-//   4. starts the per-provider polling loops
-//   5. publishes the read-only `channels.inbox.list` operator method
-//   6. returns an Unregister that stops the poller, closes the store, and
-//      removes the method.
-//
-// `channels.inbox.list` is READ-ONLY (no confirm). It reads the persisted feed
-// (filtered by providers/limit/since) and reports per-provider state from the
-// live poller status. nextSince advances monotonically (max receivedAt in the
-// returned window, never below the requested `since`).
-// ---------------------------------------------------------------------------
-
-import {
-  createDaemonCredentialStore,
-  declareOperatorMethod,
-} from '../../operator/index.ts';
-import type {
-  OperatorContext,
-  OperatorInvocation,
-  SurfaceRegister,
-  Unregister,
-} from '../../operator/index.ts';
-import {
-  buildAdapters,
-  registerAdapterFactory,
-  type AdapterContext,
-  type InboundChannelItem,
-  type RouteResolver,
-} from './provider-adapter.ts';
-import { InboxCursorStore } from './cursor-store.ts';
-import { InboundPoller, type ProviderStatus } 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';
-export const INBOX_LIST_SCOPES = ['channels:inbox:read'];
-const DEFAULT_LIMIT = 50;
-const MAX_LIMIT = 500;
-
-export interface InboxListInput {
-  providers?: string[];
-  limit?: number;
-  since?: number;
-}
-
-export interface InboxProviderReport {
-  id: string;
-  state: ProviderStatus['state'];
-  itemCount: number;
-  error?: string;
-}
-
-export interface InboxListOutput {
-  items: InboundChannelItem[];
-  nextSince: number;
-  providers: InboxProviderReport[];
-}
-
-export interface RegisterInboxOptions {
-  /** Route resolver injected by the routing surface (optional, best-effort). */
-  resolveRouteId?: RouteResolver;
-  /** Override the cursor-store filename (tests). */
-  storeFileName?: string;
-  /** Skip the initial seed poll (tests that drive polling manually). */
-  skipInitialPoll?: boolean;
-  /** Replace the default built-in adapter set (tests). */
-  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));
-}
-
-const INBOX_LIST_OUTPUT_SCHEMA: Record<string, unknown> = {
-  type: 'object',
-  required: ['items', 'nextSince', 'providers'],
-  properties: {
-    items: {
-      type: 'array',
-      items: {
-        type: 'object',
-        required: [
-          'id', 'provider', 'kind', 'fromDigest',
-          'subjectPreview', 'bodyPreview', 'receivedAt', 'unread',
-        ],
-        properties: {
-          id: { type: 'string' },
-          provider: { type: 'string' },
-          kind: { type: 'string', enum: ['dm', 'thread', 'mention', 'reaction'] },
-          fromDigest: { type: 'string' },
-          subjectPreview: { type: 'string', maxLength: 200 },
-          bodyPreview: { type: 'string', maxLength: 500 },
-          routeId: { type: 'string' },
-          receivedAt: { type: 'number' },
-          unread: { type: 'boolean' },
-          triageScore: { type: 'number' },
-          triageTags: { type: 'array', items: { type: 'string' } },
-        },
-      },
-    },
-    nextSince: { type: 'number' },
-    providers: {
-      type: 'array',
-      items: {
-        type: 'object',
-        required: ['id', 'state', 'itemCount'],
-        properties: {
-          id: { type: 'string' },
-          state: { type: 'string', enum: ['ready', 'unavailable', 'empty'] },
-          itemCount: { type: 'number' },
-          error: { type: 'string' },
-        },
-      },
-    },
-  },
-};
-
-const INBOX_LIST_INPUT_SCHEMA: Record<string, unknown> = {
-  type: 'object',
-  properties: {
-    providers: { type: 'array', items: { type: 'string' } },
-    limit: { type: 'number', minimum: 1, maximum: MAX_LIMIT },
-    since: { type: 'number', minimum: 0 },
-  },
-};
-
-function normalizeInput(body: unknown): { providers?: string[]; limit: number; since?: number } {
-  const input = (body ?? {}) as InboxListInput;
-  const providers = Array.isArray(input.providers)
-    ? input.providers.filter((p): p is string => typeof p === 'string' && p.length > 0)
-    : 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 {
-    ...(providers && providers.length > 0 ? { providers } : {}),
-    limit,
-    ...(since !== undefined ? { since } : {}),
-  };
-}
-
-/**
- * Register the inbox surface. Returns an Unregister that tears down the poller,
- * closes the store, and removes the operator method.
- */
-export function registerInboxMethods(
-  ctx: OperatorContext,
-  options: RegisterInboxOptions = {},
-): Unregister {
-  if (options.registerBuiltins !== false) {
-    registerBuiltinAdapters();
-  }
-
-  const credentials = createDaemonCredentialStore(ctx.secrets);
-  const adapterContext: AdapterContext = {
-    credentials,
-    logger: ctx.logger,
-    ...(options.resolveRouteId ? { resolveRouteId: options.resolveRouteId } : {}),
-  };
-  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 method still serves the
-  // (possibly empty) persisted feed and reports provider states.
-  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 handler = async (
-    invocation: OperatorInvocation<InboxListInput>,
-  ): Promise<InboxListOutput> => {
-    await ready;
-    const { providers, limit, since } = normalizeInput(invocation.body);
-    const items = store.listItems({ ...(providers ? { providers } : {}), ...(since !== undefined ? { since } : {}), limit });
-    const maxReceived = store.maxReceivedAt(providers);
-    const nextSince = Math.max(since ?? 0, maxReceived);
-    const statuses = poller.snapshotStatuses(providers);
-    const reports: InboxProviderReport[] = statuses.map((status) => ({
-      id: status.id,
-      state: status.state,
-      itemCount: status.itemCount,
-      ...(status.error ? { error: status.error } : {}),
-    }));
-    return { items, nextSince, providers: reports };
-  };
-
-  const unregisterMethod = declareOperatorMethod<InboxListInput, InboxListOutput>(
-    ctx,
-    {
-      id: INBOX_LIST_METHOD_ID,
-      title: 'List inbound channel items',
-      description:
-        'Aggregated, deduplicated inbound feed (DMs/threads/mentions) across '
-        + 'configured providers. Read-only; advances a monotonic nextSince cursor.',
-      category: 'channels',
-      source: 'daemon',
-      access: 'operator',
-      transport: ['ws', 'internal'],
-      scopes: INBOX_LIST_SCOPES,
-      effect: 'read-only',
-      confirm: false,
-      inputSchema: INBOX_LIST_INPUT_SCHEMA,
-      outputSchema: INBOX_LIST_OUTPUT_SCHEMA,
-    },
-    handler,
-  );
-
-  return () => {
-    try {
-      unregisterMethod();
-    } finally {
-      poller.stop();
-      void store.close();
-    }
-  };
-}
-
-/**
- * SurfaceRegister contract entry point. Integration wires the inbox surface by
- * calling this from its surface bootstrap (the same mechanism every other
- * daemon surface uses, e.g. routing/triage), retaining the returned Unregister
- * for teardown. This is the production caller of `registerInboxMethods`.
- */
-export const register: SurfaceRegister = (ctx) => registerInboxMethods(ctx);

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

@@ -1,39 +0,0 @@
-// Channel-to-Profile Routing Control Plane — surface barrel.
-//
-// Integration wires this surface by calling `register(ctx)` (or
-// `registerRoutingMethods(ctx)` when it needs the returned store/resolver).
-// The inbox surface reuses `resolveProfile` / `createRoutingResolver` for
-// identical online/offline routing resolution.
-
-export { register, registerRoutingMethods } from './register.ts';
-export type {
-  RoutingRegistration,
-  RoutingListInput,
-  RoutingListOutput,
-  RoutingAssignInput,
-  RoutingAssignOutput,
-  RoutingDeleteInput,
-  RoutingDeleteOutput,
-} from './register.ts';
-
-export {
-  RouteStore,
-  parseChannelId,
-  buildChannelId,
-} from './route-store.ts';
-export type {
-  RoutingChannelRoute,
-  ParsedChannelId,
-  RouteUpsertInput,
-  RouteUpsertResult,
-  RouteListFilter,
-} from './route-store.ts';
-
-export {
-  resolveProfile,
-  createRoutingResolver,
-  WILDCARD_SURFACE,
-} from './routing-resolver.ts';
-export type { RoutingResolver } from './routing-resolver.ts';
-
-export { createInboxRouteResolver } from './inbox-bridge.ts';

package/src/daemon/channels/routing/register.ts

@@ -1,296 +0,0 @@
-import {
-  declareOperatorMethods,
-  OperatorError,
-  type OperatorContext,
-  type OperatorHandler,
-  type OperatorMethodDescriptor,
-  type SurfaceRegister,
-  type Unregister,
-} from '../../operator/index.ts';
-import { RouteStore, type RoutingChannelRoute } from './route-store.ts';
-import { createRoutingResolver, type RoutingResolver } from './routing-resolver.ts';
-
-// ---------------------------------------------------------------------------
-// Wire contracts (request/response bodies) for the channels.routing.* methods.
-//
-// These interfaces and the JSON Schemas below mirror the handoff's literal
-// Input/Output blocks exactly. Per the handoff's "Confirmation / Effect
-// Semantics" note, `channels.routing.assign` and `channels.routing.delete` are
-// control-plane mutations that additionally require confirmation. That
-// confirmation is NOT part of the documented Input body shape: it is a
-// framework confirm-guard envelope flag (`confirm: true` on the raw request
-// body, plus `explicitUserRequest` in the call metadata) enforced by
-// `assertConfirmed` inside `declareOperatorMethods` when `descriptor.confirm`
-// is set. We therefore keep `confirm` out of the advertised contract here and
-// rely on the framework guard, so the wire Input stays a faithful match for the
-// handoff rather than a strict superset.
-// ---------------------------------------------------------------------------
-
-export interface RoutingListInput {
-  profileId?: string;
-  surfaceKind?: string;
-}
-export interface RoutingListOutput {
-  routes: RoutingChannelRoute[];
-}
-
-export interface RoutingAssignInput {
-  channelId: string;
-  profileId: string;
-  label?: string;
-}
-export interface RoutingAssignOutput {
-  assignmentId: string;
-  channelId: string;
-  profileId: string;
-  created: boolean;
-}
-
-export interface RoutingDeleteInput {
-  assignmentId: string;
-}
-export interface RoutingDeleteOutput {
-  deleted: boolean;
-}
-
-function asObject(body: unknown): Record<string, unknown> {
-  return typeof body === 'object' && body !== null ? (body as Record<string, unknown>) : {};
-}
-
-function optionalString(value: unknown): string | undefined {
-  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
-}
-
-// ---------------------------------------------------------------------------
-// JSON Schemas (advertised on the catalog descriptors).
-// ---------------------------------------------------------------------------
-
-const CHANNEL_ROUTE_SCHEMA: Record<string, unknown> = {
-  type: 'object',
-  required: ['assignmentId', 'channelId', 'surfaceKind', 'profileId', 'createdAt', 'updatedAt'],
-  properties: {
-    assignmentId: { type: 'string' },
-    channelId: { type: 'string' },
-    surfaceKind: { type: 'string' },
-    routeId: { type: 'string' },
-    profileId: { type: 'string' },
-    label: { type: 'string' },
-    createdAt: { type: 'string' },
-    updatedAt: { type: 'string' },
-  },
-};
-
-const LIST_INPUT_SCHEMA: Record<string, unknown> = {
-  type: 'object',
-  properties: {
-    profileId: { type: 'string' },
-    surfaceKind: { type: 'string' },
-  },
-};
-
-const LIST_OUTPUT_SCHEMA: Record<string, unknown> = {
-  type: 'object',
-  required: ['routes'],
-  properties: {
-    routes: { type: 'array', items: CHANNEL_ROUTE_SCHEMA },
-  },
-};
-
-const ASSIGN_INPUT_SCHEMA: Record<string, unknown> = {
-  type: 'object',
-  required: ['channelId', 'profileId'],
-  properties: {
-    channelId: { type: 'string' },
-    profileId: { type: 'string' },
-    label: { type: 'string' },
-  },
-};
-
-const ASSIGN_OUTPUT_SCHEMA: Record<string, unknown> = {
-  type: 'object',
-  required: ['assignmentId', 'channelId', 'profileId', 'created'],
-  properties: {
-    assignmentId: { type: 'string' },
-    channelId: { type: 'string' },
-    profileId: { type: 'string' },
-    created: { type: 'boolean' },
-  },
-};
-
-const DELETE_INPUT_SCHEMA: Record<string, unknown> = {
-  type: 'object',
-  required: ['assignmentId'],
-  properties: {
-    assignmentId: { type: 'string' },
-  },
-};
-
-const DELETE_OUTPUT_SCHEMA: Record<string, unknown> = {
-  type: 'object',
-  required: ['deleted'],
-  properties: {
-    deleted: { type: 'boolean' },
-  },
-};
-
-// ---------------------------------------------------------------------------
-// Registration
-// ---------------------------------------------------------------------------
-
-/**
- * Handle returned by {@link registerRoutingMethods}: tears down the catalog
- * methods and closes the underlying SQLite store. Also exposes the resolver so
- * integration / the inbox surface can reuse routing resolution without going
- * through the catalog.
- */
-export interface RoutingRegistration extends Unregister {
-  (): void;
-  readonly store: RouteStore;
-  readonly resolver: RoutingResolver;
-}
-
-/**
- * Register the channel-to-profile routing control-plane methods against the
- * operator catalog:
- *   - channels.routing.list   (read-only)
- *   - channels.routing.assign (confirmed local-state mutation)
- *   - channels.routing.delete (confirmed local-state mutation)
- *
- * The store is lazily initialized on first method invocation (the SurfaceRegister
- * contract is synchronous), so registration never blocks on disk I/O.
- */
-export function registerRoutingMethods(ctx: OperatorContext): 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: OperatorHandler<RoutingListInput, RoutingListOutput> = async (input) => {
-    await ensureInit();
-    const body = asObject(input.body);
-    const routes = store.list({
-      profileId: optionalString(body.profileId),
-      surfaceKind: optionalString(body.surfaceKind),
-    });
-    return { routes };
-  };
-
-  const assignHandler: OperatorHandler<RoutingAssignInput, RoutingAssignOutput> = async (input) => {
-    await ensureInit();
-    const body = asObject(input.body);
-    const channelId = optionalString(body.channelId);
-    const profileId = optionalString(body.profileId);
-    if (channelId === undefined) {
-      throw new OperatorError('channelId is required', 'ROUTING_INVALID_CHANNEL_ID', 400);
-    }
-    if (profileId === undefined) {
-      throw new OperatorError('profileId is required', 'ROUTING_INVALID_PROFILE_ID', 400);
-    }
-    const { route, created } = await store.upsert({
-      channelId,
-      profileId,
-      label: optionalString(body.label),
-    });
-    ctx.logger.info('channels.routing.assign', {
-      assignmentId: route.assignmentId,
-      channelId: route.channelId,
-      profileId: route.profileId,
-      created,
-      principalId: input.context.principalId,
-    });
-    return {
-      assignmentId: route.assignmentId,
-      channelId: route.channelId,
-      profileId: route.profileId,
-      created,
-    };
-  };
-
-  const deleteHandler: OperatorHandler<RoutingDeleteInput, RoutingDeleteOutput> = async (input) => {
-    await ensureInit();
-    const body = asObject(input.body);
-    const assignmentId = optionalString(body.assignmentId);
-    if (assignmentId === undefined) {
-      throw new OperatorError('assignmentId is required', 'ROUTING_INVALID_ASSIGNMENT_ID', 400);
-    }
-    const deleted = await store.delete(assignmentId);
-    ctx.logger.info('channels.routing.delete', {
-      assignmentId,
-      deleted,
-      principalId: input.context.principalId,
-    });
-    return { deleted };
-  };
-
-  const listDescriptor: OperatorMethodDescriptor = {
-    id: 'channels.routing.list',
-    title: 'List channel routes',
-    description: 'List channel-to-profile routing assignments, optionally filtered by profile or surface.',
-    category: 'channels',
-    source: 'daemon',
-    access: 'authenticated',
-    transport: ['ws', 'internal'],
-    scopes: ['channels:routing:read'],
-    effect: 'read-only',
-    inputSchema: LIST_INPUT_SCHEMA,
-    outputSchema: LIST_OUTPUT_SCHEMA,
-  };
-
-  const assignDescriptor: OperatorMethodDescriptor = {
-    id: 'channels.routing.assign',
-    title: 'Assign channel to profile',
-    description: 'Create or update the profile that handles inbound messages on a channel.',
-    category: 'channels',
-    source: 'daemon',
-    access: 'authenticated',
-    transport: ['ws', 'internal'],
-    scopes: ['channels:routing:write'],
-    effect: 'local-state-mutation',
-    confirm: true,
-    inputSchema: ASSIGN_INPUT_SCHEMA,
-    outputSchema: ASSIGN_OUTPUT_SCHEMA,
-  };
-
-  const deleteDescriptor: OperatorMethodDescriptor = {
-    id: 'channels.routing.delete',
-    title: 'Delete channel route',
-    description: 'Remove a channel-to-profile routing assignment by assignmentId.',
-    category: 'channels',
-    source: 'daemon',
-    access: 'authenticated',
-    transport: ['ws', 'internal'],
-    scopes: ['channels:routing:write'],
-    effect: 'local-state-mutation',
-    confirm: true,
-    inputSchema: DELETE_INPUT_SCHEMA,
-    outputSchema: DELETE_OUTPUT_SCHEMA,
-  };
-
-  const unregister = declareOperatorMethods(ctx, [
-    { descriptor: listDescriptor, handler: listHandler as OperatorHandler<unknown, unknown> },
-    { descriptor: assignDescriptor, handler: assignHandler as OperatorHandler<unknown, unknown> },
-    { descriptor: deleteDescriptor, handler: deleteHandler as OperatorHandler<unknown, unknown> },
-  ]);
-
-  // Build the callable teardown handle, then attach the store/resolver as
-  // read-only properties so callers (integration, the inbox surface) can reuse
-  // routing resolution without going through the catalog.
-  const teardown = (): void => {
-    unregister();
-    store.close();
-  };
-  return Object.assign(teardown, { store, resolver }) as RoutingRegistration;
-}
-
-/** SurfaceRegister contract entry point (integration calls this). */
-export const register: SurfaceRegister = (ctx) => registerRoutingMethods(ctx);

package/src/daemon/email/index.ts

@@ -1,68 +0,0 @@
-// ---------------------------------------------------------------------------
-// Email operator-method surface barrel.
-//
-// Integration wires this surface by calling registerEmailMethods(ctx) once and
-// retaining the returned Unregister. Connectors and pure helpers are re-exported
-// for daemon-internal reuse and unit testing.
-// ---------------------------------------------------------------------------
-
-export { registerEmailMethods, resolveEmailSettings } from './register.ts';
-export type {
-  ResolvedEmailSettings,
-  EmailMethodsOptions,
-  ImapClient,
-  SmtpClient,
-} from './register.ts';
-
-export {
-  ImapConnector,
-  ImapError,
-  toImapSearchDate,
-  quoteImapString,
-  parseSearchUids,
-  parseAppendUid,
-  parseEnvelope,
-  parseFetchSummaries,
-  parseFullMessage,
-  parseAddressList,
-  parseMimeMessage,
-  splitHeadersBody,
-  tokenizeParen,
-  extractParenValue,
-  extractLiteralFor,
-  unescapeImapString,
-  decodeTransferEncoding,
-  decodeQuotedPrintable,
-  decodeMimeWords,
-  stripHtml,
-  collapseWhitespace,
-} from './imap-connector.ts';
-export type {
-  ImapConnectionSettings,
-  ImapEnvelopeSummary,
-  ImapFullMessage,
-  ImapAttachmentSummary,
-  ImapListOptions,
-  ImapAppendResult,
-  ParsedMime,
-} from './imap-connector.ts';
-
-export {
-  SmtpConnector,
-  SmtpError,
-  extractCompleteReply,
-  extractAddress,
-  parseRecipients,
-  dotStuff,
-  generateMessageId,
-  buildRfc5322Message,
-  encodeHeaderValue,
-  formatRfc2822Date,
-  encodeQuotedPrintable,
-} from './smtp-connector.ts';
-export type {
-  SmtpConnectionSettings,
-  SmtpMessage,
-  SmtpSendResult,
-  Rfc5322Parts,
-} from './smtp-connector.ts';