@pellux/goodvibes-tui 0.25.0 → 0.26.0

package/src/daemon/handlers/triage/tagger/index.ts

@@ -0,0 +1,184 @@
+// ---------------------------------------------------------------------------
+// Daemon-internal triage TAGGER (composition).
+//
+// Applies user-defined triage labels back on the provider side:
+//   - IMAP : STORE a keyword flag on the message (IMAP4rev1 over TLS).
+//   - Slack: reactions.add emoji on the source message.
+//   - Discord: real forum thread tags (PATCH applied_tags, merge) when a
+//     forum-tag mapping is configured, else a unicode reaction analog.
+//
+// Hard rules honored here:
+//   - All provider credentials come ONLY from the daemon credential store.
+//     They are never returned in results and never logged.
+//   - The whole tagger is gated behind a config flag (surfaces.triage.autoTag);
+//     when disabled, applyTags() is a no-op that reports skipped:true.
+//   - Provider-side writes are EFFECTFUL; callers must pass an explicitly
+//     confirmed request (confirm === true && explicitUserRequest === true).
+//     Unconfirmed calls throw HandlerError(REQUIRE_CONFIRM).
+//
+// Contract-fidelity note: the triage surface (`inbox.triage.*`) is daemon-
+// internal and NOT a published operator method, so there is no external
+// request/response schema to certify these tag shapes against. What is
+// guaranteed is the provider-side behavior: no silent data loss (Discord thread
+// tags are merged, never blindly overwritten) and no command injection (IMAP
+// quoting rejects control characters).
+// ---------------------------------------------------------------------------
+
+import type { HandlerContext } from '../../context.ts';
+import type { DaemonCredentialStore } from '../../credentials.ts';
+import { HandlerError, REQUIRE_CONFIRM } from '../../errors.ts';
+import { labelToTag } from '../scorer.ts';
+import { applyImap, imapStoreFlagOverTls, makeRetryingImapStoreFlag } from './imap.ts';
+import type { ImapRetryOptions, ImapStoreFlag } from './imap.ts';
+import { applySlack } from './slack.ts';
+import { applyDiscord } from './discord.ts';
+import type { ApplyTagsRequest, ApplyTagsResult, TaggerProviderConfig } from './shared.ts';
+
+export type {
+  ApplyTagsRequest,
+  ApplyTagsResult,
+  TaggerProviderConfig,
+} from './shared.ts';
+export type { ImapRetryOptions, ImapStoreArgs, ImapStoreFlag } from './imap.ts';
+
+export const TRIAGE_AUTOTAG_FLAG = 'surfaces.triage.autoTag';
+
+export interface TriageTaggerOptions {
+  credentials?: DaemonCredentialStore;
+  /** Override the autotag flag lookup (used in tests). */
+  autoTagEnabled?: boolean;
+  /** Per-surface provider config; usually derived from configManager. */
+  providers?: TaggerProviderConfig;
+  /** Injectable fetch (Slack/Discord HTTP). Defaults to global fetch. */
+  fetchImpl?: typeof fetch;
+  /** Injectable IMAP flag-setter (used in tests to avoid a live socket). */
+  imapStoreFlag?: ImapStoreFlag;
+  /**
+   * Transient-failure retry policy for the default IMAP store implementation.
+   * Ignored when imapStoreFlag is injected and succeeds first-try.
+   */
+  imapRetry?: ImapRetryOptions;
+}
+
+export interface TriageTagger {
+  /** Whether provider-side tagging is currently enabled. */
+  enabled(): boolean;
+  applyTags(request: ApplyTagsRequest): Promise<ApplyTagsResult>;
+}
+
+function readBoolFlag(
+  configManager: HandlerContext['configManager'],
+  key: string,
+): boolean {
+  try {
+    const value = configManager.get(key as never) as unknown;
+    return value === true || value === 'true' || value === 1;
+  } catch {
+    return false;
+  }
+}
+
+function safeGet(configManager: HandlerContext['configManager'], key: string): unknown {
+  try {
+    return configManager.get(key as never) as unknown;
+  } catch {
+    return undefined;
+  }
+}
+
+function resolveProvidersFromConfig(
+  configManager: HandlerContext['configManager'],
+): TaggerProviderConfig {
+  const out: TaggerProviderConfig = {};
+  const slackToken = safeGet(configManager, 'surfaces.slack.botToken');
+  if (typeof slackToken === 'string' && slackToken.length > 0) {
+    out.slack = { tokenConfigKey: 'surfaces.slack.botToken' };
+  }
+  const discordToken = safeGet(configManager, 'surfaces.discord.botToken');
+  if (typeof discordToken === 'string' && discordToken.length > 0) {
+    out.discord = { tokenConfigKey: 'surfaces.discord.botToken' };
+  }
+  const imapHost = safeGet(configManager, 'surfaces.email.imap.host');
+  const imapUser = safeGet(configManager, 'surfaces.email.imap.user');
+  if (typeof imapHost === 'string' && imapHost.length > 0 && typeof imapUser === 'string') {
+    const portRaw = safeGet(configManager, 'surfaces.email.imap.port');
+    const mailbox = safeGet(configManager, 'surfaces.email.imap.mailbox');
+    out.imap = {
+      host: imapHost,
+      port: typeof portRaw === 'number' ? portRaw : 993,
+      user: imapUser,
+      passwordConfigKey: 'surfaces.email.imap.password',
+      mailbox: typeof mailbox === 'string' && mailbox.length > 0 ? mailbox : 'INBOX',
+    };
+  }
+  return out;
+}
+
+function resolveTags(request: ApplyTagsRequest): string[] {
+  if (request.tags && request.tags.length > 0) {
+    return [...new Set(request.tags.map((t) => t.trim()).filter((t) => t.length > 0))];
+  }
+  if (request.label) return [labelToTag(request.label)];
+  return [];
+}
+
+/**
+ * Create the triage tagger. Reads the autotag flag and provider config from the
+ * handler context; credentials are resolved lazily, per apply, from the daemon
+ * credential store.
+ */
+export function createTriageTagger(
+  ctx: HandlerContext,
+  options: TriageTaggerOptions = {},
+): TriageTagger {
+  const credentials = options.credentials ?? ctx.credentials;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const providers = options.providers ?? resolveProvidersFromConfig(ctx.configManager);
+  // Retry wraps whichever store impl is in use (default TLS client OR an
+  // injected one), so transient failures are retried uniformly.
+  const imapStoreFlag = makeRetryingImapStoreFlag(
+    options.imapStoreFlag ?? imapStoreFlagOverTls,
+    options.imapRetry,
+  );
+  const enabled = (): boolean =>
+    options.autoTagEnabled ?? readBoolFlag(ctx.configManager, TRIAGE_AUTOTAG_FLAG);
+
+  return {
+    enabled,
+    async applyTags(request: ApplyTagsRequest): Promise<ApplyTagsResult> {
+      const { item } = request;
+      const tags = resolveTags(request);
+      const base: ApplyTagsResult = {
+        surface: item.surface,
+        itemId: item.id,
+        appliedTags: [],
+        skipped: true,
+      };
+
+      if (!enabled()) {
+        return { ...base, reason: 'autotag-disabled' };
+      }
+
+      // Provider-side mutation is effectful — require explicit confirmation.
+      if (request.confirm !== true || request.explicitUserRequest !== true) {
+        throw new HandlerError(
+          'Provider-side triage tagging requires explicit user confirmation.',
+          REQUIRE_CONFIRM,
+          403,
+        );
+      }
+
+      switch (item.surface) {
+        case 'email':
+        case 'imap':
+          return applyImap(item, tags, providers, credentials, imapStoreFlag, base);
+        case 'slack':
+          return applySlack(item, tags, providers, credentials, fetchImpl, ctx, base);
+        case 'discord':
+          return applyDiscord(item, tags, providers, credentials, fetchImpl, ctx, base);
+        default:
+          return { ...base, reason: `unsupported-surface:${item.surface}` };
+      }
+    },
+  };
+}

package/src/daemon/handlers/triage/tagger/shared.ts

@@ -0,0 +1,70 @@
+// ---------------------------------------------------------------------------
+// Triage tagger — shared types and provider-agnostic helpers.
+//
+// Provider config shapes, the apply request/result contract, and the tag
+// normalization helpers used by the IMAP/Slack/Discord modules. No I/O here.
+// ---------------------------------------------------------------------------
+
+import type { InboundChannelItem, TriageLabel } from '../types.ts';
+
+export interface TaggerProviderConfig {
+  /** IMAP host:port (default port 993, TLS). Credentials resolved separately. */
+  imap?: { host: string; port?: number; user: string; passwordConfigKey: string; mailbox?: string };
+  /** Slack bot token config key (resolved from credential store). */
+  slack?: { tokenConfigKey: string };
+  /**
+   * Discord bot token config key (resolved from credential store), plus an
+   * optional forum-tag mapping. When `forumTagIds` maps a GoodVibes triage tag
+   * (e.g. 'GoodVibes/Spam') to a forum tag SNOWFLAKE id, items that target a
+   * forum/media-channel thread get that REAL thread tag applied (PATCH
+   * applied_tags) — exact fidelity to the contract's "Discord thread tags".
+   * Without a mapping (or for non-thread messages) tagging degrades to a
+   * unicode reaction analog.
+   */
+  discord?: { tokenConfigKey: string; forumTagIds?: Record<string, string> };
+}
+
+export interface ApplyTagsRequest {
+  item: InboundChannelItem;
+  /** Provider-side tags to apply. Defaults to [labelToTag(label)] when omitted. */
+  tags?: readonly string[];
+  label?: TriageLabel;
+  /** Must be true — provider-side mutation requires explicit confirmation. */
+  confirm?: boolean;
+  /** Mirror of the operator invocation context flag. */
+  explicitUserRequest?: boolean;
+}
+
+export interface ApplyTagsResult {
+  surface: string;
+  itemId: string;
+  appliedTags: string[];
+  /** True when the autotag flag is disabled or no provider matched. */
+  skipped: boolean;
+  reason?: string;
+}
+
+/** IMAP keywords cannot contain spaces or '/'; normalize the canonical tag. */
+export function imapKeywordForTag(tag: string): string {
+  return tag.replace(/[^A-Za-z0-9_]+/g, '_');
+}
+
+export function slackEmojiForTag(tag: string): string {
+  const lower = tag.toLowerCase();
+  if (lower.includes('spam')) return 'no_entry_sign';
+  if (lower.includes('priority')) return 'rotating_light';
+  return 'inbox_tray';
+}
+
+export function discordEmojiForTag(tag: string): string {
+  const lower = tag.toLowerCase();
+  if (lower.includes('spam')) return '\u{1F6AB}';
+  if (lower.includes('priority')) return '\u{1F6A8}';
+  return '\u{1F4E5}';
+}
+
+/** Read a non-empty string from the item's opaque metadata bag. */
+export function stringMeta(item: InboundChannelItem, key: string): string | undefined {
+  const value = item.metadata?.[key];
+  return typeof value === 'string' && value.length > 0 ? value : undefined;
+}

package/src/daemon/handlers/triage/tagger/slack.ts

@@ -0,0 +1,69 @@
+// ---------------------------------------------------------------------------
+// Triage tagger — Slack provider.
+//
+// Applies a triage label as a Slack message reaction (reactions.add). The bot
+// token is resolved per-apply from the daemon credential store and is never
+// logged or returned. `already_reacted` is treated as idempotent success.
+// ---------------------------------------------------------------------------
+
+import type { HandlerContext } from '../../context.ts';
+import type { DaemonCredentialStore } from '../../credentials.ts';
+import { HandlerError } from '../../errors.ts';
+import type { InboundChannelItem } from '../types.ts';
+import type { ApplyTagsResult, TaggerProviderConfig } from './shared.ts';
+import { slackEmojiForTag, stringMeta } from './shared.ts';
+
+export async function applySlack(
+  item: InboundChannelItem,
+  tags: string[],
+  providers: TaggerProviderConfig,
+  credentials: DaemonCredentialStore,
+  fetchImpl: typeof fetch,
+  ctx: HandlerContext,
+  base: ApplyTagsResult,
+): Promise<ApplyTagsResult> {
+  const cfg = providers.slack;
+  if (!cfg) return { ...base, reason: 'slack-not-configured' };
+  const channel = stringMeta(item, 'channelId') ?? item.conversationId;
+  const ts = stringMeta(item, 'ts') ?? stringMeta(item, 'messageTs');
+  if (!channel || !ts) return { ...base, reason: 'slack-missing-target' };
+  if (tags.length === 0) return { ...base, reason: 'no-tags' };
+
+  const token = await credentials.resolveConfigSecret(cfg.tokenConfigKey);
+  if (!token) return { ...base, reason: 'slack-no-credentials' };
+
+  const applied: string[] = [];
+  for (const tag of tags) {
+    const emoji = slackEmojiForTag(tag);
+    const response = await fetchImpl('https://slack.com/api/reactions.add', {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json; charset=utf-8',
+      },
+      body: JSON.stringify({ channel, timestamp: ts, name: emoji }),
+    });
+    const payload = (await response.json().catch(() => ({}))) as {
+      ok?: boolean;
+      error?: string;
+    };
+    if (!response.ok) {
+      throw new HandlerError(
+        `Slack reactions.add HTTP ${response.status}`,
+        'TRIAGE_SLACK_TAG_FAILED',
+        502,
+      );
+    }
+    // 'already_reacted' is an idempotent success for our purposes.
+    if (payload.ok !== true && payload.error !== 'already_reacted') {
+      ctx.logger.warn('triage: slack reaction rejected', { error: payload.error });
+      throw new HandlerError(
+        `Slack reactions.add rejected: ${payload.error ?? 'unknown'}`,
+        'TRIAGE_SLACK_TAG_FAILED',
+        502,
+      );
+    }
+    applied.push(tag);
+  }
+  return { surface: item.surface, itemId: item.id, appliedTags: applied, skipped: false };
+}

package/src/daemon/handlers/triage/types.ts

@@ -0,0 +1,50 @@
+// ---------------------------------------------------------------------------
+// Daemon-internal triage domain types.
+//
+// `InboundChannelItem` is the daemon-internal shape the inbox poller produces
+// and the triage pipeline scores. It is NOT an SDK catalog contract: the
+// published `channels.inbox.list` output schema (CHANNEL_INBOX_ITEM_SCHEMA) is
+// owned by the SDK and never re-declared here. This is the internal poller
+// item per the handoff doc — it carries `fromDigest` (never a raw sender id),
+// `subjectPreview`/`bodyPreview` (PII-stripped, length-bounded) and an opaque
+// `metadata` bag the tagger reads provider targeting from (imapUid, channelId,
+// Slack ts, Discord messageId/threadId).
+// ---------------------------------------------------------------------------
+
+/** Triage label assigned by the scorer. */
+export type TriageLabel = 'spam' | 'priority' | 'normal';
+
+/** 1:1 vs group/channel/thread conversation hint (priority signal). */
+export type ConversationKind = 'direct' | 'group' | 'channel' | 'thread' | 'service';
+
+/**
+ * Internal inbound feed item. Mirrors the handoff `InboundChannelItem` shape
+ * plus the optional fields the scorer/tagger consult. `surface` is the provider
+ * family ('email' | 'imap' | 'slack' | 'discord' | ...) the tagger dispatches
+ * on; `provider` is the handoff-facing provider id. They are usually equal.
+ */
+export interface InboundChannelItem {
+  /** Stable, provider-scoped dedup key. */
+  readonly id: string;
+  /** Provider family the tagger dispatches on (email/imap/slack/discord/...). */
+  readonly surface: string;
+  /** Handoff-facing provider id ("slack" | "discord" | "email" | ...). */
+  readonly provider?: string;
+  readonly kind?: 'dm' | 'thread' | 'mention' | 'reaction';
+  /** SHA-256 first-N of sender external id — NEVER a raw identifier. */
+  readonly fromDigest?: string;
+  /** Conversation id (Slack/Discord channel, IMAP mailbox-scoped). */
+  readonly conversationId?: string;
+  readonly conversationKind?: ConversationKind;
+  /** Display subject (<= 200 chars). */
+  readonly subject?: string;
+  /** Display body preview (<= 500 chars, PII-stripped). Alias: bodyPreview. */
+  readonly snippet?: string;
+  /** Optional daemon route binding id. */
+  readonly routeId?: string;
+  /** Unix ms. */
+  readonly receivedAt?: number;
+  readonly unread?: boolean;
+  /** Opaque provider targeting bag (imapUid/uid, channelId, ts, messageId, threadId). */
+  readonly metadata?: Record<string, unknown>;
+}

package/src/runtime/services.ts

@@ -7,15 +7,6 @@ import { AutomationDeliveryManager, AutomationManager, AutomationRouteStore } fr
 import { ChannelPluginRegistry, ChannelPolicyManager, RouteBindingManager, SurfaceRegistry } from '@pellux/goodvibes-sdk/platform/channels';
 import { ChannelDeliveryRouter } from '@pellux/goodvibes-sdk/platform/channels';
 import { ApprovalBroker, GatewayMethodCatalog, SharedSessionBroker } from '@pellux/goodvibes-sdk/platform/control-plane';
-import {
-  registerDaemonOperatorSurfaces,
-  type DaemonOperatorSurfaces,
-} from '../daemon/operator/surfaces.ts';
-import type {
-  OperatorContext,
-  OperatorLogger,
-} from '../daemon/operator/index.ts';
-import { attachRemoteInvokeRoute } from '../daemon/remote/index.ts';
 import { WatcherRegistry } from '@pellux/goodvibes-sdk/platform/watchers';
 import { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts';
 import {
@@ -96,6 +87,19 @@ import {
   type WorkflowServices,
 } from '@pellux/goodvibes-sdk/platform/tools';
 import { WorkPlanStore } from '../work-plans/work-plan-store.ts';
+import {
+  registerDaemonHandlers,
+  type DaemonHandlerSurfaces,
+} from '../daemon/handlers/index.ts';
+import type { HandlerContext, HandlerLogger } from '../daemon/handlers/context.ts';
+import { createDaemonCredentialStore } from '../daemon/handlers/credentials.ts';
+import { registerRouting } from '../daemon/handlers/routing/index.ts';
+import { registerInboxMethods } from '../daemon/handlers/inbox/index.ts';
+import { registerTriagedInbox } from '../daemon/handlers/triage/index.ts';
+import { registerDraftMethods } from '../daemon/handlers/drafts/index.ts';
+import { registerCalendar } from '../daemon/handlers/calendar/index.ts';
+import { registerEmailMethods } from '../daemon/handlers/email/index.ts';
+import { registerRemoteSurface } from '../daemon/handlers/remote/index.ts';
 
 const REGULAR_KNOWLEDGE_DB_FILE = 'knowledge-wiki.sqlite';
 const HOME_GRAPH_KNOWLEDGE_DB_FILE = 'knowledge-home-graph.sqlite';
@@ -178,7 +182,6 @@ export interface RuntimeServices {
   readonly deliveryManager: AutomationDeliveryManager;
   readonly automationManager: AutomationManager;
   readonly gatewayMethods: GatewayMethodCatalog;
-  readonly operatorSurfaces: DaemonOperatorSurfaces;
   readonly artifactStore: ArtifactStore;
   readonly knowledgeService: KnowledgeService;
   readonly agentKnowledgeService: KnowledgeService;
@@ -225,6 +228,7 @@ export interface RuntimeServices {
   readonly providerRegistry: ProviderRegistry;
   readonly toolLLM: ToolLLM;
   readonly distributedRuntime: DistributedRuntimeManager;
+  readonly daemonHandlers: DaemonHandlerSurfaces;
   readonly remoteRunnerRegistry: RemoteRunnerRegistry;
   readonly remoteSupervisor: RemoteSupervisor;
   readonly sessionMemoryStore: SessionMemoryStore;
@@ -281,30 +285,6 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     globalHome: homeDirectory,
     configManager,
   });
-  // Wire the daemon operator surfaces (routing / triaged inbox / drafts /
-  // calendar / email / remote) against the shared gateway-method catalog. Each
-  // surface initializes its stores lazily, so this stays synchronous.
-  const operatorLogger: OperatorLogger = {
-    info: (msg, meta) => console.info(`[operator] ${msg}`, meta ?? ''),
-    warn: (msg, meta) => console.warn(`[operator] ${msg}`, meta ?? ''),
-    error: (msg, meta) => console.error(`[operator] ${msg}`, meta ?? ''),
-  };
-  const operatorContext: OperatorContext = {
-    catalog: gatewayMethods,
-    secrets: secretsManager,
-    configManager,
-    workingDirectory,
-    homeDirectory,
-    logger: operatorLogger,
-  };
-  const operatorSurfaces = registerDaemonOperatorSurfaces(operatorContext);
-  // Wire the remote.peers.invoke route to the remote dispatch adapter, replacing
-  // the SDK builtin stub. This is the single faithful integration point: the
-  // DaemonHttpRouter resolves POST /api/remote/peers/{peerId}/invoke to
-  // catalog.invoke('remote.peers.invoke', ...), which now reaches the
-  // Docker/SSH/cloud-terminal/local-process backends via the dispatch adapter
-  // (which enforces confirm:true + explicitUserRequest before dispatch).
-  attachRemoteInvokeRoute(gatewayMethods, operatorSurfaces.remoteDispatch);
   const subscriptionManager = new SubscriptionManager(
     shellPaths.resolveUserPath('tui', 'subscriptions.json'),
   );
@@ -551,6 +531,39 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     approvalBridge: approvalBroker,
     automationBridge: automationManager,
   });
+
+  // Daemon handler surfaces: attach HOST handlers to the SDK-auto-registered
+  // builtin gateway descriptors (channels.* / email.* / calendar.*). The SDK
+  // owns every id/descriptor/schema; this only fills the handler slot via
+  // catalog.register(descriptor, handler, { replace: true }). Routing returns
+  // the resolver the inbox surface consumes; triage decorates channels.inbox.list.
+  // The remote surface reuses the SAME DistributedRuntimeManager the SDK facade
+  // injects, so its peer/work methods share one persistent store; remote.peers.*
+  // stay SDK-published routes (not catalog methods).
+  const handlerLogger: HandlerLogger = {
+    info: (message, meta) => console.info(message, meta ?? ''),
+    warn: (message, meta) => console.warn(message, meta ?? ''),
+    error: (message, meta) => console.error(message, meta ?? ''),
+  };
+  const handlerContext: HandlerContext = {
+    catalog: gatewayMethods,
+    credentials: createDaemonCredentialStore(secretsManager),
+    configManager,
+    workingDirectory,
+    homeDirectory,
+    logger: handlerLogger,
+  };
+  const daemonHandlers = registerDaemonHandlers(handlerContext, {
+    registerRouting,
+    registerInbox: (ctx, routing) =>
+      registerTriagedInbox(ctx, (inboxCtx) => registerInboxMethods(inboxCtx, routing))
+        .unregister,
+    registerDrafts: (ctx) => registerDraftMethods(ctx),
+    registerCalendar,
+    registerEmail: (ctx) => registerEmailMethods(ctx),
+    registerRemote: (ctx) => registerRemoteSurface(ctx, { manager: distributedRuntime }),
+  });
+
   const remoteRunnerRegistry = new RemoteRunnerRegistry(agentManager);
   const remoteSupervisor = new RemoteSupervisor(remoteRunnerRegistry);
   const sandboxSessionRegistry = new SandboxSessionRegistry(workingDirectory);
@@ -657,7 +670,6 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     deliveryManager,
     automationManager,
     gatewayMethods,
-    operatorSurfaces,
     artifactStore,
     knowledgeService,
     agentKnowledgeService,
@@ -704,6 +716,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     providerRegistry,
     toolLLM,
     distributedRuntime,
+    daemonHandlers,
     remoteRunnerRegistry,
     remoteSupervisor,
     sessionMemoryStore,

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.25.0';
+let _version = '0.26.0';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;

package/src/daemon/calendar/index.ts

@@ -1,52 +0,0 @@
-// Public surface barrel for the CalDAV calendar connector.
-//
-// Integration registers the surface by calling registerCalendarMethods(ctx).
-// All other exports are types / helpers for consumers and tests.
-
-export { registerCalendarMethods, CALENDAR_METHOD_IDS } from './register.ts';
-export type {
-  RegisterCalendarOptions,
-  CalDavClientFactory,
-  CalendarEventDetail,
-  CalendarEventSummaryResult,
-} from './register.ts';
-
-export {
-  createCalDavClient,
-  resolveCalDavConfig,
-  toRelativeHref,
-  parseMultiStatus,
-} from './caldav-client.ts';
-export type {
-  CalDavClient,
-  CalDavConfig,
-  CalDavEvent,
-  CreateCalDavClientOptions,
-  CreateEventInput,
-  CreatedEvent,
-  ImportResult,
-  ExportResult,
-  ListEventsOptions,
-  FetchLike,
-} from './caldav-client.ts';
-
-export {
-  parseICS,
-  generateICS,
-  generateCalendar,
-  foldLine,
-  unfoldLines,
-  escapeText,
-  unescapeText,
-  formatICalDate,
-  formatICalDateTime,
-  parseICalDate,
-  attendeeDisplayName,
-  eventToVEvent,
-  extractUid,
-} from './ics.ts';
-export type {
-  ParsedICalEvent,
-  ICalAttendee,
-  GenerateICalInput,
-} from './ics.ts';