@pellux/goodvibes-tui 0.18.4

package/src/channels/delivery/strategies-enterprise.ts

@@ -0,0 +1,178 @@
+import { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts/index';
+import { ConfigManager } from '../../config/manager.ts';
+import { ServiceRegistry } from '../../config/service-registry.ts';
+import type { ChannelDeliveryStrategy } from './types.ts';
+import {
+  appendAttachmentSummary,
+  extractResponseId,
+  firstNonEmpty,
+  normalizeBaseUrl,
+  requireOkResponse,
+  resolveAttachments,
+  resolveChannelDeliverySurfaceKind,
+  resolveMSTeamsAccessToken,
+  success,
+  trimForSurface,
+} from './shared.ts';
+
+export function createMSTeamsDeliveryStrategy(
+  configManager: ConfigManager,
+  serviceRegistry: ServiceRegistry,
+  artifactStore: ArtifactStore,
+): ChannelDeliveryStrategy {
+  return {
+    id: 'channel-delivery:msteams',
+    canHandle(request) {
+      return resolveChannelDeliverySurfaceKind(request.target) === 'msteams';
+    },
+    async deliver(request) {
+      const attachments = await resolveAttachments(request, artifactStore, configManager, 128 * 1024);
+      const serviceUrl = firstNonEmpty(
+        typeof request.binding?.metadata.serviceUrl === 'string' ? request.binding.metadata.serviceUrl : undefined,
+        String(configManager.get('surfaces.msteams.serviceUrl') ?? ''),
+        process.env.MSTEAMS_SERVICE_URL,
+      );
+      const rawConversationId = firstNonEmpty(
+        request.target.address,
+        typeof request.binding?.metadata.conversationId === 'string' ? request.binding.metadata.conversationId : undefined,
+        request.binding?.channelId,
+        request.binding?.externalId,
+        String(configManager.get('surfaces.msteams.defaultConversationId') ?? ''),
+      );
+      if (!serviceUrl) throw new Error('Missing Microsoft Teams service URL');
+      if (!rawConversationId) throw new Error('Missing Microsoft Teams conversation id');
+      const threadId = firstNonEmpty(
+        request.binding?.threadId,
+        typeof request.binding?.metadata.replyToId === 'string' ? request.binding.metadata.replyToId : undefined,
+      );
+      const conversationId = threadId && !rawConversationId.includes(';messageid=')
+        ? `${rawConversationId};messageid=${threadId}`
+        : rawConversationId;
+      const accessToken = await resolveMSTeamsAccessToken(configManager, serviceRegistry);
+      const response = await fetch(`${normalizeBaseUrl(serviceUrl)}/v3/conversations/${encodeURIComponent(conversationId)}/activities`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${accessToken}`,
+        },
+        body: JSON.stringify({
+          type: 'message',
+          text: trimForSurface(appendAttachmentSummary(request.body, attachments), 4_000),
+          textFormat: 'plain',
+          ...(threadId ? { replyToId: threadId } : {}),
+        }),
+      });
+      const payload = await requireOkResponse('Microsoft Teams delivery failed', response);
+      return success(extractResponseId(payload) ?? conversationId);
+    },
+  };
+}
+
+export function createMattermostDeliveryStrategy(
+  configManager: ConfigManager,
+  serviceRegistry: ServiceRegistry,
+  artifactStore: ArtifactStore,
+): ChannelDeliveryStrategy {
+  return {
+    id: 'channel-delivery:mattermost',
+    canHandle(request) {
+      return resolveChannelDeliverySurfaceKind(request.target) === 'mattermost';
+    },
+    async deliver(request) {
+      const attachments = await resolveAttachments(request, artifactStore, configManager, 128 * 1024);
+      const baseUrl = firstNonEmpty(
+        String(configManager.get('surfaces.mattermost.baseUrl') ?? ''),
+        serviceRegistry.get('mattermost')?.baseUrl,
+        process.env.MATTERMOST_BASE_URL,
+      );
+      const botToken = firstNonEmpty(
+        await serviceRegistry.resolveSecret('mattermost', 'primary'),
+        String(configManager.get('surfaces.mattermost.botToken') ?? ''),
+        process.env.MATTERMOST_BOT_TOKEN,
+      );
+      const channelId = firstNonEmpty(
+        request.target.address,
+        request.binding?.channelId,
+        request.binding?.externalId,
+        String(configManager.get('surfaces.mattermost.defaultChannelId') ?? ''),
+      );
+      if (!baseUrl) throw new Error('Missing Mattermost base URL');
+      if (!botToken) throw new Error('Missing Mattermost bot token');
+      if (!channelId) throw new Error('Missing Mattermost channel id');
+      const response = await fetch(`${normalizeBaseUrl(baseUrl)}/api/v4/posts`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${botToken}`,
+        },
+        body: JSON.stringify({
+          channel_id: channelId,
+          message: trimForSurface(appendAttachmentSummary(request.body, attachments), 12_000),
+          ...(request.binding?.threadId ? { root_id: request.binding.threadId } : {}),
+        }),
+      });
+      const payload = await requireOkResponse('Mattermost delivery failed', response);
+      return success(extractResponseId(payload) ?? channelId);
+    },
+  };
+}
+
+export function createMatrixDeliveryStrategy(
+  configManager: ConfigManager,
+  serviceRegistry: ServiceRegistry,
+  artifactStore: ArtifactStore,
+): ChannelDeliveryStrategy {
+  return {
+    id: 'channel-delivery:matrix',
+    canHandle(request) {
+      return resolveChannelDeliverySurfaceKind(request.target) === 'matrix';
+    },
+    async deliver(request) {
+      const attachments = await resolveAttachments(request, artifactStore, configManager, 128 * 1024);
+      const homeserverUrl = firstNonEmpty(
+        String(configManager.get('surfaces.matrix.homeserverUrl') ?? ''),
+        serviceRegistry.get('matrix')?.baseUrl,
+        process.env.MATRIX_HOMESERVER,
+      );
+      const accessToken = firstNonEmpty(
+        await serviceRegistry.resolveSecret('matrix', 'primary'),
+        String(configManager.get('surfaces.matrix.accessToken') ?? ''),
+        process.env.MATRIX_ACCESS_TOKEN,
+      );
+      const roomId = firstNonEmpty(
+        request.target.address,
+        request.binding?.channelId,
+        request.binding?.externalId,
+        String(configManager.get('surfaces.matrix.defaultRoomId') ?? ''),
+      );
+      if (!homeserverUrl) throw new Error('Missing Matrix homeserver URL');
+      if (!accessToken) throw new Error('Missing Matrix access token');
+      if (!roomId) throw new Error('Missing Matrix room id');
+      const txnId = crypto.randomUUID();
+      const threadId = request.binding?.threadId;
+      const response = await fetch(`${normalizeBaseUrl(homeserverUrl)}/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${encodeURIComponent(txnId)}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${accessToken}`,
+        },
+        body: JSON.stringify({
+          msgtype: 'm.text',
+          body: trimForSurface(appendAttachmentSummary(request.body, attachments), 8_000),
+          ...(threadId
+            ? {
+                'm.relates_to': {
+                  rel_type: 'm.thread',
+                  event_id: threadId,
+                  is_falling_back: true,
+                  'm.in_reply_to': { event_id: threadId },
+                },
+              }
+            : {}),
+        }),
+      });
+      const payload = await requireOkResponse('Matrix delivery failed', response);
+      return success(extractResponseId(payload) ?? roomId);
+    },
+  };
+}

package/src/channels/delivery/types.ts

@@ -0,0 +1,59 @@
+import type { ArtifactReference } from '@pellux/goodvibes-sdk/platform/artifacts/index';
+import type { ConfigManager } from '../../config/manager.ts';
+import type { ServiceRegistry } from '../../config/service-registry.ts';
+import type { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts/index';
+import type { ControlPlaneGateway } from '../../control-plane/gateway.ts';
+import type { RouteSurfaceKind } from '@pellux/goodvibes-sdk/platform/runtime/events/routes';
+
+export type ChannelDeliverySurfaceKind = RouteSurfaceKind;
+export type ChannelDeliveryTargetKind = 'none' | 'webhook' | 'surface' | 'integration' | 'link';
+
+export interface ChannelDeliveryTarget {
+  readonly kind: ChannelDeliveryTargetKind;
+  readonly surfaceKind?: ChannelDeliverySurfaceKind;
+  readonly address?: string;
+  readonly routeId?: string;
+  readonly label?: string;
+}
+
+export interface ChannelDeliveryRouteBinding {
+  readonly id: string;
+  readonly surfaceKind: ChannelDeliverySurfaceKind;
+  readonly surfaceId: string;
+  readonly externalId: string;
+  readonly threadId?: string;
+  readonly channelId?: string;
+  readonly title?: string;
+  readonly metadata: Record<string, unknown>;
+}
+
+export interface ChannelDeliveryRequest {
+  readonly target: ChannelDeliveryTarget;
+  readonly body: string;
+  readonly title: string;
+  readonly jobId: string;
+  readonly runId: string;
+  readonly agentId?: string;
+  readonly status?: string;
+  readonly includeLinks: boolean;
+  readonly attachments?: readonly ArtifactReference[];
+  readonly binding?: ChannelDeliveryRouteBinding;
+}
+
+export interface ChannelDeliveryResult {
+  readonly responseId?: string;
+}
+
+export interface ChannelDeliveryStrategy {
+  readonly id: string;
+  canHandle(request: ChannelDeliveryRequest): boolean;
+  deliver(request: ChannelDeliveryRequest): Promise<ChannelDeliveryResult>;
+}
+
+export interface ChannelDeliveryRouterConfig {
+  readonly configManager?: ConfigManager;
+  readonly serviceRegistry?: ServiceRegistry;
+  readonly artifactStore?: ArtifactStore;
+  readonly controlPlaneGateway?: ControlPlaneGateway | null;
+  readonly strategies?: readonly ChannelDeliveryStrategy[];
+}

package/src/channels/delivery-router.ts

@@ -0,0 +1,127 @@
+import { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts/index';
+import { ConfigManager } from '../config/manager.ts';
+import { ServiceRegistry } from '../config/service-registry.ts';
+import type { ControlPlaneGateway } from '../control-plane/gateway.ts';
+import {
+  createDiscordDeliveryStrategy,
+  createGoogleChatDeliveryStrategy,
+  createNtfyDeliveryStrategy,
+  createSlackDeliveryStrategy,
+  createTelegramDeliveryStrategy,
+  createWebControlPlaneDeliveryStrategy,
+  createWebhookDeliveryStrategy,
+} from './delivery/strategies-core.ts';
+import {
+  createBlueBubblesDeliveryStrategy,
+  createIMessageDeliveryStrategy,
+  createSignalDeliveryStrategy,
+  createWhatsAppDeliveryStrategy,
+} from './delivery/strategies-bridge.ts';
+import {
+  createMSTeamsDeliveryStrategy,
+  createMattermostDeliveryStrategy,
+  createMatrixDeliveryStrategy,
+} from './delivery/strategies-enterprise.ts';
+import { resolveChannelDeliverySurfaceKind } from './delivery/shared.ts';
+import type {
+  ChannelDeliveryRequest,
+  ChannelDeliveryRouterConfig,
+  ChannelDeliveryStrategy,
+} from './delivery/types.ts';
+
+export type {
+  ChannelDeliveryResult,
+  ChannelDeliveryRouteBinding,
+  ChannelDeliveryRouterConfig,
+  ChannelDeliveryStrategy,
+  ChannelDeliverySurfaceKind,
+  ChannelDeliveryTarget,
+  ChannelDeliveryTargetKind,
+} from './delivery/types.ts';
+
+export { resolveChannelDeliverySurfaceKind } from './delivery/shared.ts';
+
+export function createDefaultChannelDeliveryStrategies(
+  configManager: ConfigManager,
+  serviceRegistry: ServiceRegistry,
+  artifactStore: ArtifactStore,
+  getControlPlaneGateway: () => ControlPlaneGateway | null,
+): ChannelDeliveryStrategy[] {
+  return [
+    createWebhookDeliveryStrategy(configManager, artifactStore),
+    createSlackDeliveryStrategy(serviceRegistry, configManager, artifactStore),
+    createDiscordDeliveryStrategy(serviceRegistry, configManager, artifactStore),
+    createNtfyDeliveryStrategy(configManager, serviceRegistry, artifactStore),
+    createWebControlPlaneDeliveryStrategy(configManager, artifactStore, getControlPlaneGateway),
+    createTelegramDeliveryStrategy(configManager, serviceRegistry, artifactStore),
+    createGoogleChatDeliveryStrategy(configManager, serviceRegistry, artifactStore),
+    createSignalDeliveryStrategy(configManager, serviceRegistry, artifactStore),
+    createWhatsAppDeliveryStrategy(configManager, serviceRegistry, artifactStore),
+    createIMessageDeliveryStrategy(configManager, serviceRegistry, artifactStore),
+    createMSTeamsDeliveryStrategy(configManager, serviceRegistry, artifactStore),
+    createBlueBubblesDeliveryStrategy(configManager, serviceRegistry, artifactStore),
+    createMattermostDeliveryStrategy(configManager, serviceRegistry, artifactStore),
+    createMatrixDeliveryStrategy(configManager, serviceRegistry, artifactStore),
+  ];
+}
+
+export class ChannelDeliveryRouter {
+  private readonly strategies: ChannelDeliveryStrategy[];
+  private controlPlaneGateway: ControlPlaneGateway | null;
+
+  constructor(config: ChannelDeliveryRouterConfig = {}) {
+    this.controlPlaneGateway = config.controlPlaneGateway ?? null;
+    if (config.strategies) {
+      this.strategies = [...config.strategies];
+      return;
+    }
+    if (!config.configManager || !config.serviceRegistry || !config.artifactStore) {
+      throw new Error(
+        'ChannelDeliveryRouter requires configManager, serviceRegistry, and artifactStore when using builtin delivery strategies.',
+      );
+    }
+    this.strategies = createDefaultChannelDeliveryStrategies(
+      config.configManager,
+      config.serviceRegistry,
+      config.artifactStore,
+      () => this.controlPlaneGateway,
+    );
+  }
+
+  setControlPlaneGateway(gateway: ControlPlaneGateway | null): void {
+    this.controlPlaneGateway = gateway;
+  }
+
+  listStrategies(): readonly ChannelDeliveryStrategy[] {
+    return [...this.strategies];
+  }
+
+  registerStrategy(strategy: ChannelDeliveryStrategy, options: { readonly replace?: boolean } = {}): void {
+    const existingIndex = this.strategies.findIndex((entry) => entry.id === strategy.id);
+    if (existingIndex >= 0) {
+      if (!options.replace) {
+        throw new Error(`Channel delivery strategy already registered: ${strategy.id}`);
+      }
+      this.strategies.splice(existingIndex, 1, strategy);
+      return;
+    }
+    this.strategies.push(strategy);
+  }
+
+  unregisterStrategy(strategyId: string): boolean {
+    const existingIndex = this.strategies.findIndex((entry) => entry.id === strategyId);
+    if (existingIndex < 0) return false;
+    this.strategies.splice(existingIndex, 1);
+    return true;
+  }
+
+  async deliver(request: ChannelDeliveryRequest): Promise<string | undefined> {
+    const strategy = this.strategies.find((entry) => entry.canHandle(request));
+    if (!strategy) {
+      const surfaceKind = resolveChannelDeliverySurfaceKind(request.target);
+      throw new Error(`Unsupported channel delivery target: ${request.target.kind}:${surfaceKind ?? 'unknown'}`);
+    }
+    const result = await strategy.deliver(request);
+    return result.responseId;
+  }
+}

package/src/channels/index.ts

@@ -0,0 +1,77 @@
+export type {
+  ChannelSurface,
+  ChannelCapability,
+  ChannelConversationKind,
+  ChannelDirectoryScope,
+  ChannelAccountLifecycleAction,
+  ChannelTargetSource,
+  ChannelIdentity,
+  ChannelRouteBinding,
+  ChannelAdapterDescriptor,
+  ChannelDirectoryEntry,
+  ChannelDirectoryQueryOptions,
+  ChannelTargetResolveOptions,
+  ChannelResolvedTarget,
+  ChannelStatusSnapshot,
+  ChannelSecretStatus,
+  ChannelAccountAction,
+  ChannelAccountRecord,
+  ChannelAccountLifecycleResult,
+  ChannelActorAuthorizationRequest,
+  ChannelActorAuthorizationResult,
+  ChannelCapabilityDescriptor,
+  ChannelToolDescriptor,
+  ChannelOperatorActionDescriptor,
+  ChannelPolicyRecord,
+  ChannelGroupPolicyRecord,
+  ChannelPolicyAuditRecord,
+  ChannelIngressPolicyInput,
+  ChannelPolicyDecision,
+  ChannelSecretBackend,
+  ChannelSetupFieldKind,
+  ChannelDoctorStatus,
+  ChannelLifecycleAction,
+  ChannelAllowlistTargetKind,
+  ChannelReasoningVisibility,
+  ChannelRenderFormat,
+  ChannelRenderPhase,
+  ChannelRenderEventKind,
+  ChannelSecretTargetDescriptor,
+  ChannelSetupFieldOption,
+  ChannelSetupFieldDescriptor,
+  ChannelSetupSchema,
+  ChannelDoctorCheck,
+  ChannelRepairAction,
+  ChannelDoctorReport,
+  ChannelLifecycleMigrationRecord,
+  ChannelLifecycleState,
+  ChannelAllowlistTarget,
+  ChannelAllowlistResolution,
+  ChannelAllowlistEditInput,
+  ChannelAllowlistEditResult,
+  ChannelRenderEvent,
+  ChannelRenderPolicy,
+  ChannelRenderRequest,
+  ChannelRenderResult,
+} from '@pellux/goodvibes-sdk/platform/channels/types';
+export type { UpsertRouteBindingInput } from './route-manager.ts';
+export { RouteBindingManager } from './route-manager.ts';
+export { SurfaceRegistry } from './surface-registry.ts';
+export type { ChannelPlugin } from './plugin-registry.ts';
+export { ChannelPluginRegistry } from './plugin-registry.ts';
+export { ChannelPolicyManager } from '@pellux/goodvibes-sdk/platform/channels/policy-manager';
+export { BuiltinChannelRuntime } from './builtin-runtime.ts';
+export { ChannelReplyPipeline, normalizeChannelRenderEventFromRuntime } from './reply-pipeline.ts';
+export { ChannelProviderRuntimeManager } from './provider-runtime.ts';
+export type { ProviderRuntimeActionResult, ProviderRuntimeStatus, ProviderRuntimeSurface } from './provider-runtime.ts';
+export { ChannelDeliveryRouter, createDefaultChannelDeliveryStrategies, resolveChannelDeliverySurfaceKind } from './delivery-router.ts';
+export type {
+  ChannelDeliveryResult,
+  ChannelDeliveryRouteBinding,
+  ChannelDeliveryRouterConfig,
+  ChannelDeliveryStrategy,
+  ChannelDeliverySurfaceKind,
+  ChannelDeliveryTarget,
+  ChannelDeliveryTargetKind,
+} from './delivery-router.ts';
+export type { ChannelDeliveryRequest } from './delivery/types.ts';