@pellux/goodvibes-tui 0.24.1 → 0.26.0

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

@@ -87,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';
@@ -215,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;
@@ -517,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);
@@ -669,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.24.1';
+let _version = '0.26.0';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;