ei-tui 1.4.1 → 1.6.0

package/src/integrations/slack/importer.ts

@@ -3,11 +3,12 @@ import type { Ei_Interface, Message, PersonaEntity, Person } from "../../core/ty
 import type { PersonIdentifier } from "../../core/types/data-items.js";
 import { ContextStatus } from "../../core/types/enums.js";
 import { queueAllScans, queuePersonScan, queuePersonUpdate, type ExtractionContext } from "../../core/orchestrators/human-extraction.js";
+import { queueTopicRewritePhase } from "../../core/orchestrators/ceremony.js";
 import type { ItemMatchResult } from "../../prompts/human/types.js";
 import { qualifySlackMessage } from "../../core/utils/message-id.js";
 import { SLACK_PERSONA_DEFINITION } from "../../templates/slack.js";
 import { SlackReader, SlackRateLimitError, type ResolvedMessage } from "./reader.js";
-import type { SlackChannelState } from "./types.js";
+import type { SlackChannelState, SlackWorkspaceConfig } from "./types.js";
 
 const SLACK_USER_ID_KEY = "Slack User ID";
 const WINDOW_MS = 24 * 60 * 60 * 1000;
@@ -170,10 +171,19 @@ export async function importSlackChannel(opts: {
 
   const human = stateManager.getHuman();
   const slackSettings = human.settings?.slack;
-  if (!slackSettings?.auth?.token) return result;
+  const workspaces = slackSettings?.workspaces ?? {};
+
+  // Find the workspace with the oldest unprocessed channel that has integration enabled
+  const enabledWorkspaces = Object.entries(workspaces).filter(([, ws]) => ws.integration);
+  if (enabledWorkspaces.length === 0) return result;
+
+  // We'll pick the right workspace after channel discovery — for now grab the first enabled one
+  // to bootstrap the reader. Multi-workspace candidate selection happens below.
+  // TODO: proper cross-workspace oldest-channel selection in a future pass
+  const [workspaceId, workspaceConfig] = enabledWorkspaces[0] as [string, SlackWorkspaceConfig];
 
   const persona = ensureSlackPersona(stateManager, opts.interface);
-  const reader = new SlackReader(slackSettings.auth.token);
+  const reader = new SlackReader(workspaceConfig.auth);
 
   // Seed caches from known people identifiers
   for (const person of human.people) {
@@ -190,15 +200,13 @@ export async function importSlackChannel(opts: {
   if (signal?.aborted) return result;
 
   let channels = await reader.listChannels();
-  const channelStates: Record<string, SlackChannelState> = { ...slackSettings.channels };
+  const channelStates: Record<string, SlackChannelState> = { ...workspaceConfig.channels };
 
   // Seed channel name cache from saved state
   for (const [id, state] of Object.entries(channelStates)) {
     if (state.name) reader.seedChannelCache(id, state.name);
   }
 
-  const workspaceId = slackSettings.auth?.workspace_id ?? "unknown";
-
   // Loop through candidate channels until we find one with messages to process,
   // or exhaust all candidates. Empty channels are marked caught up and skipped
   // so the next cycle doesn't re-examine them.
@@ -214,7 +222,7 @@ export async function importSlackChannel(opts: {
   while (true) {
     if (signal?.aborted) return result;
 
-    const candidate = reader.selectCandidateChannel(channels, channelStates, slackSettings, now);
+    const candidate = reader.selectCandidateChannel(channels, channelStates, workspaceConfig, now);
     if (!candidate) return result; // all channels caught up
 
     const { channel, state } = candidate;
@@ -228,7 +236,7 @@ export async function importSlackChannel(opts: {
     channelName = updatedState.name ?? channelId;
     reader.seedChannelCache(channelId, channelName);
 
-    const extractionPointMs = new Date(channelState.extraction_point ?? new Date(nowMs - (slackSettings.backfill_days?.public ?? 30) * 86400_000).toISOString()).getTime();
+    const extractionPointMs = new Date(channelState.extraction_point ?? new Date(nowMs - (workspaceConfig.backfill_days?.public ?? 30) * 86400_000).toISOString()).getTime();
     const extractionPointTs = (extractionPointMs / 1000).toFixed(6);
 
     // Probe for the next actual message — skips silent periods instantly
@@ -256,7 +264,13 @@ export async function importSlackChannel(opts: {
           ...updatedHuman.settings,
           slack: {
             ...updatedHuman.settings?.slack,
-            channels: { ...updatedHuman.settings?.slack?.channels, [channelId]: updatedState },
+            workspaces: {
+              ...updatedHuman.settings?.slack?.workspaces,
+              [workspaceId]: {
+                ...workspaceConfig,
+                channels: { ...workspaceConfig.channels, [channelId]: updatedState },
+              },
+            },
           },
         },
       });
@@ -323,7 +337,7 @@ export async function importSlackChannel(opts: {
       sourceTag,
       workspaceId,
       stateManager,
-      slackSettings.extraction_model,
+      workspaceConfig.extraction_model,
     );
   }
 
@@ -347,7 +361,7 @@ export async function importSlackChannel(opts: {
       result.scansQueued += queueScansForMessages(
         contextMsgs, analyzeMsgs, participants,
         persona.id, channelName, sourceTag, workspaceId,
-        stateManager, slackSettings.extraction_model,
+        stateManager, workspaceConfig.extraction_model,
       );
     }
 
@@ -375,7 +389,7 @@ export async function importSlackChannel(opts: {
       result.scansQueued += queueScansForMessages(
         contextMsgs, analyzeMsgs, participants,
         persona.id, channelName, sourceTag, workspaceId,
-        stateManager, slackSettings.extraction_model,
+        stateManager, workspaceConfig.extraction_model,
       );
     }
 
@@ -395,14 +409,21 @@ export async function importSlackChannel(opts: {
       ...updatedHuman.settings,
       slack: {
         ...updatedHuman.settings?.slack,
-        channels: {
-          ...updatedHuman.settings?.slack?.channels,
-          [channelId]: updatedState,
+        workspaces: {
+          ...updatedHuman.settings?.slack?.workspaces,
+          [workspaceId]: {
+            ...workspaceConfig,
+            channels: { ...workspaceConfig.channels, [channelId]: updatedState },
+          },
         },
       },
     },
   });
 
+  if (result.messagesImported > 0) {
+    queueTopicRewritePhase(stateManager);
+  }
+
   result.channelProcessed = channelName;
   return result;
 }

package/src/integrations/slack/reader.ts

@@ -1,4 +1,4 @@
-import type { SlackChannelState, SlackSettings } from "./types.js";
+import type { SlackAuth, SlackChannelState, SlackWorkspaceConfig } from "./types.js";
 
 export class SlackRateLimitError extends Error {
   constructor(method: string) {
@@ -7,6 +7,14 @@ export class SlackRateLimitError extends Error {
   }
 }
 
+function resolveEnvVar(value: string): string {
+  if (value.startsWith("$")) {
+    const name = value.slice(1);
+    return process.env[name] ?? value;
+  }
+  return value;
+}
+
 // =============================================================================
 // Slack API types
 // =============================================================================
@@ -75,12 +83,12 @@ export interface ResolvedMessage {
 // =============================================================================
 
 export class SlackReader {
-  private token: string;
+  private auth: SlackAuth;
   private userCache: Map<string, string> = new Map();   // userId → displayName
   private channelCache: Map<string, string> = new Map(); // channelId → name
 
-  constructor(token: string) {
-    this.token = token;
+  constructor(auth: SlackAuth) {
+    this.auth = auth;
   }
 
   // ---------------------------------------------------------------------------
@@ -92,9 +100,14 @@ export class SlackReader {
     for (const [k, v] of Object.entries(params)) {
       url.searchParams.set(k, String(v));
     }
-    const resp = await fetch(url.toString(), {
-      headers: { Authorization: `Bearer ${this.token}` },
-    });
+    const headers: Record<string, string> = {};
+    if (this.auth.type === "browser") {
+      headers["Authorization"] = `Bearer ${resolveEnvVar(this.auth.xoxc)}`;
+      headers["Cookie"] = `d=${resolveEnvVar(this.auth.xoxd)}`;
+    } else {
+      headers["Authorization"] = `Bearer ${this.auth.token}`;
+    }
+    const resp = await fetch(url.toString(), { headers });
     if (resp.status === 429) throw new SlackRateLimitError(method);
     if (!resp.ok) throw new Error(`Slack API ${method} failed: ${resp.status}`);
     const data = await resp.json() as Record<string, unknown>;
@@ -123,7 +136,7 @@ export class SlackReader {
     return allChannels;
   }
 
-  classifyChannel(ch: SlackChannel, settings: SlackSettings): ChannelTier {
+  classifyChannel(ch: SlackChannel, settings: SlackWorkspaceConfig): ChannelTier {
     const override = settings.channel_overrides?.[ch.id];
     if (override) return override === "skip" ? "skip" : override;
     if (ch.is_im || ch.is_mpim) return "dm";
@@ -133,7 +146,7 @@ export class SlackReader {
     return "public";
   }
 
-  backfillDaysForTier(tier: ChannelTier, settings: SlackSettings): number {
+  backfillDaysForTier(tier: ChannelTier, settings: SlackWorkspaceConfig): number {
     const defaults = { dm: 90, private: 90, public: 30 };
     if (tier === "dm" || tier === "private") return settings.backfill_days?.dm ?? defaults[tier];
     if (tier === "public") return settings.backfill_days?.public ?? defaults.public;
@@ -387,7 +400,7 @@ export class SlackReader {
   selectCandidateChannel(
     channels: SlackChannel[],
     channelStates: Record<string, SlackChannelState>,
-    settings: SlackSettings,
+    settings: SlackWorkspaceConfig,
     now: string,
   ): { channel: SlackChannel; state: SlackChannelState; tier: ChannelTier } | null {
     const nowMs = new Date(now).getTime();

package/src/integrations/slack/types.ts

@@ -1,11 +1,25 @@
-export interface SlackAuth {
-  type: "pkce" | "xoxp";
-  token: string;
-  refresh_token?: string;
-  workspace_id?: string;
+export type ChannelTier = "dm" | "private" | "public" | "broadcast" | "skip";
+
+// OAuth flow (PKCE) — produces a real xoxp token with auto-refresh
+export interface SlackAuthOAuth {
+  type: "oauth";
+  token: string;           // xoxp-... user token
+  refresh_token?: string;  // xoxe-xoxp-... rotating refresh token
+  workspace_name?: string;
+}
+
+// Browser session tokens — extracted from Slack desktop app or DevTools.
+// xoxc and xoxd may be literal token strings or env var references (e.g. $RNP_SLACK_XOXC_TOKEN).
+// Env vars are resolved at call time so rotating them in the shell updates Ei automatically.
+export interface SlackAuthBrowser {
+  type: "browser";
+  xoxc: string;
+  xoxd: string;
   workspace_name?: string;
 }
 
+export type SlackAuth = SlackAuthOAuth | SlackAuthBrowser;
+
 export interface SlackChannelState {
   extraction_point?: string;         // ISO — how far we've advanced in the timeline (spine cursor)
   last_run?: string;                 // ISO — when we last checked for updates (necro reply detection)
@@ -13,18 +27,22 @@ export interface SlackChannelState {
   threads?: Record<string, string>;  // threadTs → latest reply ts seen (reply cursor per thread)
 }
 
-export interface SlackSettings {
+export interface SlackWorkspaceConfig {
+  auth: SlackAuth;
   integration?: boolean;
-  polling_interval_ms?: number;
   extraction_model?: string;
   last_sync?: string;
-  auth?: SlackAuth;
   backfill_days?: {
     dm: number;
     private: number;
     public: number;
   };
   broadcast_threshold?: number;
-  channel_overrides?: Record<string, "dm" | "private" | "public" | "skip">;
+  channel_overrides?: Record<string, ChannelTier>;
   channels?: Record<string, SlackChannelState>;
 }
+
+export interface SlackSettings {
+  polling_interval_ms?: number;
+  workspaces?: Record<string, SlackWorkspaceConfig>;  // keyed by workspace_id (e.g. "T024GE9EL")
+}

package/src/prompts/message-utils.ts

@@ -1,7 +1,7 @@
 import type { Message } from "../core/types.js";
 import { getMessageContent } from "../core/handlers/utils.js";
 
-const MESSAGE_PLACEHOLDER_REGEX = /\[mid:([a-zA-Z0-9_:-]+):([^:\]]+)\]/g;
+const MESSAGE_PLACEHOLDER_REGEX = /\[mid:(.+):([^:\]]+)\]/g;
 
 export function getMessageDisplayText(message: Message): string | null {
   const parts: string[] = [];

package/tui/README.md

@@ -39,7 +39,7 @@ Enable any or all three in `/settings`. They work independently and feed into th
 
 Sessions are processed oldest-first, one per queue cycle. On first run Ei works through your backlog gradually — it won't flood your LLM provider.
 
-OpenCode also supports reading Ei's extracted knowledge back out via the [CLI tool](../src/cli/README.md), giving it persistent memory across sessions.
+All three tools also support reading Ei's knowledge back out via the [CLI tool](../src/cli/README.md) — run `ei --install` to wire up automatic context injection (hooks + persona plugin) so your coding agents receive relevant Ei memory before every message without any manual tool calls.
 
 ## Slack Integration
 

package/tui/src/commands/slack-auth.ts

@@ -66,19 +66,25 @@ export async function runSlackAuth(ctx: CommandContext): Promise<void> {
     clearSlackTokenCache();
 
     const team = tokens._raw.team as Record<string, string> | undefined;
-    const workspaceId = team?.id;
+    const workspaceId = team?.id ?? "unknown";
     const workspaceName = team?.name;
 
     const human = await ctx.ei.getHuman();
+    const existingWorkspace = human.settings?.slack?.workspaces?.[workspaceId] ?? {};
     await ctx.ei.updateSettings({
       slack: {
         ...human.settings?.slack,
-        auth: {
-          type: "pkce",
-          token: tokens.access_token,
-          refresh_token: tokens.refresh_token,
-          workspace_id: workspaceId,
-          workspace_name: workspaceName,
+        workspaces: {
+          ...human.settings?.slack?.workspaces,
+          [workspaceId]: {
+            ...existingWorkspace,
+            auth: {
+              type: "oauth",
+              token: tokens.access_token,
+              refresh_token: tokens.refresh_token,
+              workspace_name: workspaceName,
+            },
+          },
         },
       },
     });

package/tui/src/util/yaml-settings.ts

@@ -7,7 +7,7 @@ import type {
 } from "../../../src/core/types.js";
 import type { ClaudeCodeSettings } from "../../../src/integrations/claude-code/types.js";
 import type { CursorSettings } from "../../../src/integrations/cursor/types.js";
-import type { SlackSettings } from "../../../src/integrations/slack/types.js";
+import type { SlackSettings, SlackAuth } from "../../../src/integrations/slack/types.js";
 import { modelGuidToDisplay, displayToModelGuid } from "./yaml-shared.js";
 import { parseDuration, formatDuration } from "./duration.js";
 
@@ -48,10 +48,20 @@ interface EditableSettingsData {
     extraction_point?: string | null;
   };
   slack?: {
-    integration?: boolean | null;
     polling_interval_ms?: string | null;
-    last_sync?: string | null;
-    extraction_model?: string | null;
+    workspaces?: Record<string, {
+      auth?: {
+        type?: string | null;
+        token?: string | null;
+        refresh_token?: string | null;
+        xoxc?: string | null;
+        xoxd?: string | null;
+        workspace_name?: string | null;
+      } | null;
+      integration?: boolean | null;
+      extraction_model?: string | null;
+      last_sync?: string | null;
+    } | null>;
   };
   backup?: {
     enabled?: boolean | null;
@@ -103,10 +113,18 @@ export function settingsToYAML(settings: HumanSettings | undefined, accounts: Pr
       extraction_point: settings?.cursor?.extraction_point ?? null,
     },
     slack: {
-      integration: settings?.slack?.integration ?? false,
       polling_interval_ms: formatDuration(settings?.slack?.polling_interval_ms ?? 60000),
-      last_sync: settings?.slack?.last_sync ?? null,
-      extraction_model: guidToDisplay(settings?.slack?.extraction_model) ?? 'default',
+      workspaces: Object.fromEntries(
+        Object.entries(settings?.slack?.workspaces ?? {}).map(([wsId, ws]) => [
+          wsId,
+          {
+            auth: ws.auth,
+            integration: ws.integration ?? false,
+            extraction_model: guidToDisplay(ws.extraction_model) ?? 'default',
+            last_sync: ws.last_sync ?? null,
+          },
+        ])
+      ),
     },
     backup: {
       enabled: settings?.backup?.enabled ?? false,
@@ -188,12 +206,22 @@ export function settingsFromYAML(yamlContent: string, original: HumanSettings |
 
   let slack: SlackSettings | undefined;
   if (data.slack) {
+    const parsedWorkspaces: SlackSettings["workspaces"] = {};
+    for (const [wsId, wsData] of Object.entries(data.slack.workspaces ?? {})) {
+      if (!wsData) continue;
+      const originalWs = original?.slack?.workspaces?.[wsId] ?? {};
+      parsedWorkspaces[wsId] = {
+        ...originalWs,
+        auth: (wsData.auth ?? originalWs.auth) as SlackAuth,
+        integration: nullToUndefined(wsData.integration),
+        extraction_model: displayToGuid(wsData.extraction_model),
+        last_sync: originalWs.last_sync,
+      };
+    }
     slack = {
       ...original?.slack,
-      integration: nullToUndefined(data.slack.integration),
       polling_interval_ms: parseMsDuration(data.slack.polling_interval_ms, 60000),
-      last_sync: original?.slack?.last_sync,
-      extraction_model: displayToGuid(data.slack.extraction_model),
+      workspaces: Object.keys(parsedWorkspaces).length > 0 ? parsedWorkspaces : original?.slack?.workspaces,
     };
   }