@pellux/goodvibes-tui 0.18.4

package/src/input/submission-intent.ts

@@ -0,0 +1,18 @@
+export type SubmissionIntentKind =
+  | 'empty'
+  | 'prompt'
+  | 'slash-command'
+  | 'orchestration'
+  | 'plan'
+  | 'review'
+  | 'panel-action'
+  | 'shell'
+  | 'memory-pin';
+
+export interface SubmissionIntent {
+  readonly kind: SubmissionIntentKind;
+  readonly label: string;
+  readonly commandName?: string;
+  readonly hasAttachments: boolean;
+}
+

package/src/input/submission-router.ts

@@ -0,0 +1,64 @@
+import type { SubmissionIntent } from './submission-intent.ts';
+
+export interface SubmissionRouterInput {
+  readonly text: string;
+  readonly commandMode?: boolean;
+  readonly panelFocused?: boolean;
+  readonly hasAttachments?: boolean;
+}
+
+const PLAN_COMMANDS = new Set(['plan']);
+const REVIEW_COMMANDS = new Set(['review']);
+const PANEL_COMMANDS = new Set(['panel']);
+const ORCHESTRATION_COMMANDS = new Set([
+  'wrfc',
+  'orchestration',
+  'teamwork',
+  'tasks',
+  'agents',
+  'remote',
+  'bridge',
+  'teleport',
+  'sandbox',
+]);
+
+export function routeSubmissionIntent(input: SubmissionRouterInput): SubmissionIntent {
+  const trimmed = input.text.trim();
+  const hasAttachments = input.hasAttachments ?? false;
+
+  if (!trimmed) {
+    return {
+      kind: input.panelFocused ? 'panel-action' : 'empty',
+      label: input.panelFocused ? 'panel action' : 'prompt',
+      hasAttachments,
+    };
+  }
+
+  if (trimmed.startsWith('!#')) {
+    return { kind: 'memory-pin', label: 'memory pin', hasAttachments };
+  }
+
+  if (trimmed.startsWith('!')) {
+    return { kind: 'shell', label: 'shell', hasAttachments };
+  }
+
+  if (input.commandMode || trimmed.startsWith('/')) {
+    const commandName = trimmed.replace(/^\//, '').split(/\s+/, 1)[0] ?? '';
+    if (PLAN_COMMANDS.has(commandName)) {
+      return { kind: 'plan', label: 'plan', commandName, hasAttachments };
+    }
+    if (REVIEW_COMMANDS.has(commandName)) {
+      return { kind: 'review', label: 'review', commandName, hasAttachments };
+    }
+    if (PANEL_COMMANDS.has(commandName)) {
+      return { kind: 'panel-action', label: 'panel action', commandName, hasAttachments };
+    }
+    if (ORCHESTRATION_COMMANDS.has(commandName)) {
+      return { kind: 'orchestration', label: 'orchestration', commandName, hasAttachments };
+    }
+    return { kind: 'slash-command', label: 'command', commandName, hasAttachments };
+  }
+
+  return { kind: 'prompt', label: 'prompt', hasAttachments };
+}
+

package/src/integrations/index.ts

@@ -0,0 +1,42 @@
+export { SlackIntegration, SlackSocketModeClient } from '@pellux/goodvibes-sdk/platform/integrations/slack';
+export type {
+  SlackAuthTestResult,
+  SlackConversationRecord,
+  SlackCursorPage,
+  SlackEvent,
+  SlackEventCallback,
+  SlackInteraction,
+  SlackOAuthAuthorizeOptions,
+  SlackOAuthExchangeOptions,
+  SlackOAuthExchangeResult,
+  SlackSlashCommand,
+  SlackSocketModeConnection,
+  SlackSocketModeEnvelope,
+  SlackSocketModeClientOptions,
+  SlackUserRecord,
+} from '@pellux/goodvibes-sdk/platform/integrations/slack';
+export { DiscordGatewayClient, DiscordGatewayIntent, DiscordGatewayOpcode, DiscordIntegration } from '@pellux/goodvibes-sdk/platform/integrations/discord';
+export type {
+  DiscordApplicationCommand,
+  DiscordApplicationCommandOption,
+  DiscordGatewayBotResponse,
+  DiscordGatewayClientOptions,
+  DiscordGatewayDispatch,
+  DiscordInteraction,
+  DiscordOAuthAuthorizeOptions,
+} from '@pellux/goodvibes-sdk/platform/integrations/discord';
+export { DiscordInteractionType, DiscordInteractionResponseType } from '@pellux/goodvibes-sdk/platform/integrations/discord';
+export { Notifier } from './notifier.ts';
+export { GitHubIntegration } from '@pellux/goodvibes-sdk/platform/integrations/github';
+export type { GitHubWebhookEvent } from '@pellux/goodvibes-sdk/platform/integrations/github';
+export { DeliveryQueue, DeliveryError, classifyDeliveryError, snapshotQueueStatus } from '@pellux/goodvibes-sdk/platform/integrations/delivery';
+export { NtfyIntegration } from '@pellux/goodvibes-sdk/platform/integrations/ntfy';
+export type {
+  DeliveryOutcome,
+  DeliveryFailureClass,
+  DeadLetterEntry,
+  DeliveryMetrics,
+  DeliveryQueueConfig,
+  IntegrationQueueStatus,
+} from '@pellux/goodvibes-sdk/platform/integrations/delivery';
+export type { NtfyMessage, NtfyPublishOptions, NtfySubscribeOptions, NtfyWebSocketOptions } from '@pellux/goodvibes-sdk/platform/integrations/ntfy';

package/src/integrations/notifier.ts

@@ -0,0 +1,206 @@
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import type { RuntimeEventBus, AgentEvent, WorkflowEvent } from '../runtime/events/index.ts';
+import { SlackIntegration } from '@pellux/goodvibes-sdk/platform/integrations/slack';
+import { DiscordIntegration } from '@pellux/goodvibes-sdk/platform/integrations/discord';
+import { DeliveryQueue } from '@pellux/goodvibes-sdk/platform/integrations/delivery';
+import type { DeliveryQueueConfig, IntegrationQueueStatus } from '@pellux/goodvibes-sdk/platform/integrations/delivery';
+import { snapshotQueueStatus } from '@pellux/goodvibes-sdk/platform/integrations/delivery';
+import { ServiceRegistry } from '../config/service-registry.ts';
+
+// ---------------------------------------------------------------------------
+// Notifier
+// ---------------------------------------------------------------------------
+
+/**
+ * Notifier — unified notification dispatcher.
+ *
+ * Reads configuration from environment variables:
+ *   SLACK_WEBHOOK_URL, SLACK_BOT_TOKEN
+ *   DISCORD_WEBHOOK_URL, DISCORD_BOT_TOKEN
+ *
+ * Attach to the RuntimeEventBus to automatically post notifications for key events.
+ */
+export class Notifier {
+  private slack?: SlackIntegration;
+  private discord?: DiscordIntegration;
+  private unsubscribers: Array<() => void> = [];
+  private readonly _queue: DeliveryQueue;
+
+  constructor(options?: {
+    slack?: SlackIntegration;
+    discord?: DiscordIntegration;
+    delivery?: Partial<DeliveryQueueConfig>;
+  }) {
+    this.slack = options?.slack;
+    this.discord = options?.discord;
+    this._queue = new DeliveryQueue(options?.delivery ?? {});
+  }
+
+  /**
+   * Create a Notifier pre-wired from configured services and environment variables.
+   */
+  static async fromConfig(serviceRegistry: Pick<ServiceRegistry, 'resolveSecret'>): Promise<Notifier> {
+    const [
+      slackWebhookFromService,
+      slackTokenFromService,
+      discordWebhookFromService,
+      discordTokenFromService,
+    ] = await Promise.all([
+      serviceRegistry.resolveSecret('slack', 'webhookUrl'),
+      serviceRegistry.resolveSecret('slack', 'primary'),
+      serviceRegistry.resolveSecret('discord', 'webhookUrl'),
+      serviceRegistry.resolveSecret('discord', 'primary'),
+    ]);
+
+    const slackWebhook = slackWebhookFromService ?? process.env.SLACK_WEBHOOK_URL;
+    const slackToken = slackTokenFromService ?? process.env.SLACK_BOT_TOKEN;
+    const discordWebhook = discordWebhookFromService ?? process.env.DISCORD_WEBHOOK_URL;
+    const discordToken = discordTokenFromService ?? process.env.DISCORD_BOT_TOKEN;
+
+    const slack =
+      slackWebhook || slackToken
+        ? new SlackIntegration(slackWebhook, slackToken)
+        : undefined;
+
+    const discord =
+      discordWebhook || discordToken
+        ? new DiscordIntegration(discordWebhook, discordToken)
+        : undefined;
+
+    return new Notifier({ slack, discord });
+  }
+
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+
+  /**
+   * Send a notification to all configured channels.
+   *
+   * @param event  - Human-readable event name (used as message text)
+   * @param data   - Arbitrary key/value payload for formatting
+   */
+  async notify(event: string, data: Record<string, unknown>): Promise<void> {
+    const text = this.formatText(event, data);
+
+    if (this.slack) {
+      const slack = this.slack;
+      await this._queue.enqueue('slack', event, text, () => slack.postWebhook(text));
+    }
+
+    if (this.discord) {
+      const discord = this.discord;
+      await this._queue.enqueue('discord', event, text, () => discord.postWebhook(text));
+    }
+  }
+
+  /**
+   * Get delivery queue status snapshots for all active channels.
+   * Used by integration diagnostics to surface queue and DLQ state.
+   */
+  getQueueStatus(): IntegrationQueueStatus[] {
+    const sloEnforced = this._queue.sloEnforced;
+    const statuses: IntegrationQueueStatus[] = [];
+    if (this.slack) {
+      statuses.push(snapshotQueueStatus('slack', this._queue, sloEnforced));
+    }
+    if (this.discord) {
+      statuses.push(snapshotQueueStatus('discord', this._queue, sloEnforced));
+    }
+    return statuses;
+  }
+
+  /**
+   * Replay all dead-letter entries to their respective channels.
+   * Re-attempts delivery for each DLQ entry; results are returned per-entry.
+   */
+  async replayDeadLetters(): Promise<Array<{ id: string; outcome: import('@pellux/goodvibes-sdk/platform/integrations/delivery').DeliveryOutcome }>> {
+    return this._queue.replay(async (dlqEntry) => {
+      const text = dlqEntry.payload;
+      if (dlqEntry.channel === 'slack' && this.slack) {
+        await this.slack.postWebhook(text);
+      } else if (dlqEntry.channel === 'discord' && this.discord) {
+        await this.discord.postWebhook(text);
+      } else {
+        throw new Error(`No active integration for channel: ${dlqEntry.channel}`);
+      }
+    });
+  }
+
+  /** Dispose the delivery queue (cancel pending timers). Call on shutdown. */
+  dispose(): void {
+    this._queue.dispose();
+  }
+
+  attachToRuntimeBus(bus: RuntimeEventBus): void {
+    this.detach();
+
+    this.unsubscribers.push(
+      bus.on<Extract<AgentEvent, { type: 'AGENT_COMPLETED' }>>('AGENT_COMPLETED', ({ payload }) => {
+        void this.notify('AGENT_COMPLETED', {
+          event: 'AGENT_COMPLETED',
+          agentId: payload.agentId,
+          task: payload.output?.slice(0, 100) ?? payload.agentId,
+          result: payload.output,
+        });
+      }),
+    );
+
+    this.unsubscribers.push(
+      bus.on<Extract<WorkflowEvent, { type: 'WORKFLOW_CHAIN_PASSED' }>>('WORKFLOW_CHAIN_PASSED', ({ payload }) => {
+        void this.notify('WORKFLOW_CHAIN_PASSED', {
+          event: 'WORKFLOW_CHAIN_PASSED',
+          chainId: payload.chainId,
+        });
+      }),
+    );
+
+    this.unsubscribers.push(
+      bus.on<Extract<WorkflowEvent, { type: 'WORKFLOW_CHAIN_FAILED' }>>('WORKFLOW_CHAIN_FAILED', ({ payload }) => {
+        void this.notify('WORKFLOW_CHAIN_FAILED', {
+          event: 'WORKFLOW_CHAIN_FAILED',
+          chainId: payload.chainId,
+          reason: payload.reason,
+        });
+      }),
+    );
+
+    logger.info('Notifier: attached to RuntimeEventBus');
+  }
+
+  /** Remove all notification subscriptions. */
+  detach(): void {
+    for (const unsub of this.unsubscribers) {
+      unsub();
+    }
+    this.unsubscribers = [];
+  }
+
+  // -------------------------------------------------------------------------
+  // Private helpers
+  // -------------------------------------------------------------------------
+
+  private formatText(event: string, data: Record<string, unknown>): string {
+    switch (event) {
+      case 'AGENT_COMPLETED': {
+        const task = typeof data.task === 'string' ? data.task : String(data.agentId ?? '');
+        return `Agent completed: ${task}`;
+      }
+      case 'WORKFLOW_CHAIN_PASSED': {
+        const score = typeof data.score === 'number' ? `${data.score}/10` : 'passed';
+        return `Review passed: ${score}`;
+      }
+      case 'WORKFLOW_CHAIN_FAILED': {
+        const reason = typeof data.reason === 'string' ? data.reason : 'unknown reason';
+        return `Review chain failed: ${reason}`;
+      }
+      default: {
+        const extras = Object.entries(data)
+          .filter(([k]) => k !== 'event')
+          .map(([k, v]) => `${k}=${String(v)}`)
+          .join(', ');
+        return extras ? `${event}: ${extras}` : event;
+      }
+    }
+  }
+}

package/src/integrations/webhooks.ts

@@ -0,0 +1,177 @@
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import type { RuntimeEventBus, AgentEvent, WorkflowEvent } from '../runtime/events/index.ts';
+
+// ---------------------------------------------------------------------------
+// WebhookNotifier
+// ---------------------------------------------------------------------------
+
+/**
+ * WebhookNotifier — sends HTTP POST notifications to configured webhook URLs.
+ *
+ * Defaults to ntfy.sh-compatible format: plain text body, no auth required.
+ * Works with any service that accepts a plain POST with a text/plain body,
+ * including ntfy.sh, generic webhooks, and custom endpoints.
+ *
+ * Usage:
+ *   const notifier = new WebhookNotifier(['https://ntfy.sh/my-topic']);
+ *   notifier.attachToRuntimeBus(runtimeBus);
+ */
+export class WebhookNotifier {
+  private urls: string[];
+  private unsubscribers: Array<() => void> = [];
+
+  constructor(urls: string[] = []) {
+    this.urls = [...urls];
+  }
+
+  /**
+   * Create a WebhookNotifier from a list of URLs (e.g. from persisted config).
+   */
+  static fromConfig(urls: string[]): WebhookNotifier {
+    return new WebhookNotifier(urls);
+  }
+
+  // -------------------------------------------------------------------------
+  // URL management
+  // -------------------------------------------------------------------------
+
+  /** Add a webhook URL. Ignores duplicates. Throws on invalid URL. */
+  addUrl(url: string): void {
+    new URL(url); // throws TypeError if url is invalid
+    if (!this.urls.includes(url)) {
+      this.urls.push(url);
+      logger.info('WebhookNotifier: added URL', { url });
+    }
+  }
+
+  /** Remove a webhook URL. */
+  removeUrl(url: string): boolean {
+    const before = this.urls.length;
+    this.urls = this.urls.filter((u) => u !== url);
+    const removed = this.urls.length < before;
+    if (removed) logger.info('WebhookNotifier: removed URL', { url });
+    return removed;
+  }
+
+  /** Replace all webhook URLs. */
+  setUrls(urls: string[]): void {
+    this.urls = [...urls];
+  }
+
+  /** Get a copy of all configured webhook URLs. */
+  getUrls(): string[] {
+    return [...this.urls];
+  }
+
+  /** Returns true if at least one URL is configured. */
+  isConfigured(): boolean {
+    return this.urls.length > 0;
+  }
+
+  // -------------------------------------------------------------------------
+  // Sending
+  // -------------------------------------------------------------------------
+
+  /**
+   * Send a plain-text notification to all configured webhooks.
+   *
+   * Uses ntfy.sh format by default: POST with text/plain body.
+   * All URLs are fired in parallel; individual failures are logged but do not
+   * throw — remaining URLs still receive the notification.
+   */
+  async send(text: string): Promise<void> {
+    if (this.urls.length === 0) return;
+
+    const results = await Promise.allSettled(
+      this.urls.map((url) => this.postOne(url, text)),
+    );
+
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      if (result.status === 'rejected') {
+        const msg = result.reason instanceof Error ? result.reason.message : String(result.reason);
+        logger.warn('WebhookNotifier: delivery failed', { url: this.urls[i], error: msg });
+      }
+    }
+  }
+
+  /**
+   * Send a test notification to all configured webhooks.
+   */
+  async test(): Promise<{ url: string; ok: boolean; error?: string }[]> {
+    if (this.urls.length === 0) return [];
+
+    const results = await Promise.allSettled(
+      this.urls.map((url) => this.postOne(url, 'goodvibes-tui: webhook test')),
+    );
+
+    return this.urls.map((url, i) => {
+      const result = results[i];
+      if (result.status === 'fulfilled') {
+        return { url, ok: true };
+      } else {
+        const error = result.reason instanceof Error ? result.reason.message : String(result.reason);
+        return { url, ok: false, error };
+      }
+    });
+  }
+
+  // -------------------------------------------------------------------------
+  // Runtime event integration
+  // -------------------------------------------------------------------------
+
+  attachToRuntimeBus(bus: RuntimeEventBus): void {
+    this.detach();
+
+    this.unsubscribers.push(
+      bus.on<Extract<AgentEvent, { type: 'AGENT_COMPLETED' }>>('AGENT_COMPLETED', ({ payload }) => {
+        void this.send(`Agent completed: ${payload.agentId}`);
+      }),
+    );
+
+    this.unsubscribers.push(
+      bus.on<Extract<AgentEvent, { type: 'AGENT_FAILED' }>>('AGENT_FAILED', ({ payload }) => {
+        void this.send(`Agent failed: ${payload.agentId} — ${payload.error}`);
+      }),
+    );
+
+    this.unsubscribers.push(
+      bus.on<Extract<WorkflowEvent, { type: 'WORKFLOW_CHAIN_PASSED' }>>('WORKFLOW_CHAIN_PASSED', ({ payload }) => {
+        void this.send(`WRFC passed: chain ${payload.chainId}`);
+      }),
+    );
+
+    this.unsubscribers.push(
+      bus.on<Extract<WorkflowEvent, { type: 'WORKFLOW_CHAIN_FAILED' }>>('WORKFLOW_CHAIN_FAILED', ({ payload }) => {
+        void this.send(`WRFC failed: ${payload.reason}`);
+      }),
+    );
+
+    logger.info('WebhookNotifier: attached to RuntimeEventBus', { urlCount: this.urls.length });
+  }
+
+  /** Remove all webhook subscriptions. */
+  detach(): void {
+    for (const unsub of this.unsubscribers) {
+      unsub();
+    }
+    this.unsubscribers = [];
+  }
+
+  // -------------------------------------------------------------------------
+  // Private helpers
+  // -------------------------------------------------------------------------
+
+  private async postOne(url: string, text: string): Promise<void> {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'text/plain' },
+      body: text,
+      signal: AbortSignal.timeout(10_000),
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => '');
+      throw new Error(`HTTP ${res.status}: ${body}`);
+    }
+  }
+}