ei-tui 1.3.5 → 1.4.1

package/src/prompts/synthesis/index.ts

@@ -14,7 +14,7 @@ Your goal is to produce a well-structured markdown document that a human could s
 
 Everything below is complete as provided — do not use tools to re-fetch records already present here. Only use tools to fill genuine gaps not covered by the data below.
 
-- **Facts**: Ground-truth statements.
+- **Facts**: User demographics only (name, age, job title, location, family structure, physical traits) — not interests or opinions.
 - **Topics**: Areas of interest, work, or concern with descriptions.
 - **People**: Individuals with relationship context.
 - **Quotes**: Verbatim things said, with a \`message_id\`. Use \`fetch_message\` with the \`message_id\` if you want the surrounding conversation for additional context.${hasEntityMap ? `

package/src/templates/slack.ts

@@ -0,0 +1,17 @@
+export const SLACK_PERSONA_DEFINITION = {
+  entity: "system" as const,
+  aliases: ["Slack", "slack"],
+  short_description: "Your Slack workspace — conversations, threads, and the people you work with, indexed for memory.",
+  long_description: `Slack is the quiet archivist of your working life. It reads your channels and threads, extracts what matters — who said what, what topics are alive, what decisions were made — and feeds that into Ei's memory so your personas know what's been going on without you having to explain it.
+
+It doesn't chat. It doesn't have opinions. It's infrastructure with good taste about what's worth remembering.`,
+  model: undefined,
+  group_primary: "Integrations",
+  groups_visible: [] as string[],
+  traits: [],
+  topics: [],
+  heartbeat_delay_ms: 0,
+  is_archived: false,
+  is_paused: false,
+  is_static: true,
+};

package/tui/README.md

@@ -41,6 +41,32 @@ Sessions are processed oldest-first, one per queue cycle. On first run Ei works
 
 OpenCode also supports reading Ei's extracted knowledge back out via the [CLI tool](../src/cli/README.md), giving it persistent memory across sessions.
 
+## Slack Integration
+
+Slack is different from the coding tool integrations — it reads human conversations rather than coding sessions, and requires OAuth instead of local file access.
+
+**Setup:**
+
+```
+/auth slack
+```
+
+This opens a browser, walks you through OAuth, and stores your token. Then enable in `/settings`:
+
+```yaml
+slack:
+  integration: true
+  extraction_model: default  # optional override
+```
+
+Ei will index channels and DMs you're a member of, extracting topics, people, and context. Everything is processed locally — nothing is sent to the developer.
+
+**Notes:**
+- Ei uses a [published Slack app](https://github.com/Flare576/ei) — your workspace admin may need to approve it
+- Non-Marketplace apps are subject to Slack's rate limits on `conversations.history` (1 req/min). Backfill is gradual; steady-state is fast.
+- Your workspace admin may need to approve the [Ei Slack app](https://slack.com/oauth/v2/authorize?client_id=11080256060354.11080294064034&scope=&user_scope=channels:history,channels:read,groups:history,groups:read,im:history,im:read,mpim:history,mpim:read,users:read,users:read.email) — that link goes directly to the install flow
+- The Slack app is read-only — Ei never posts, reacts, or takes any action in your workspace
+
 # Installation
 
 ```bash
@@ -146,6 +172,7 @@ Rooms have three modes, set at creation time:
 | `/settings` | `/set` | Edit your global settings in `$EDITOR` |
 | `/setsync <user> <pass>` | `/ss` | Set sync credentials (triggers restart) |
 | `/tools` | | Manage tool providers — enable/disable tools per persona |
+| `/auth <service>` | | Authenticate with an external service via OAuth. Supported: `spotify`, `slack` |
 
 ### Editor
 

package/tui/src/commands/auth.ts

@@ -1,17 +1,18 @@
 import type { Command } from "./registry.js";
 import { runSpotifyAuth } from "./spotify-auth.js";
+import { runSlackAuth } from "./slack-auth.js";
 
 export const authCommand: Command = {
   name: "auth",
   aliases: [],
   description: "Authenticate with a service (e.g. /auth spotify)",
-  usage: "/auth <service>  — supported: spotify",
+  usage: "/auth <service>  — supported: spotify, slack",
 
   async execute(args, ctx) {
     const service = args[0]?.toLowerCase();
 
     if (!service) {
-      ctx.showNotification("Usage: /auth <service>  (supported: spotify)", "error");
+      ctx.showNotification("Usage: /auth <service>  (supported: spotify, slack)", "error");
       return;
     }
 
@@ -19,8 +20,11 @@ export const authCommand: Command = {
       case "spotify":
         await runSpotifyAuth(ctx);
         break;
+      case "slack":
+        await runSlackAuth(ctx);
+        break;
       default:
-        ctx.showNotification(`Unknown service: ${service}. Supported: spotify`, "error");
+        ctx.showNotification(`Unknown service: ${service}. Supported: spotify, slack`, "error");
     }
   },
 };

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

@@ -0,0 +1,167 @@
+import type { CommandContext } from "./registry.js";
+import { logger } from "../util/logger.js";
+import {
+  generateVerifier,
+  generateChallenge,
+  buildAuthUrl,
+  exchangeCode,
+} from "../../../src/core/tools/builtin/pkce.js";
+import {
+  SLACK_CLIENT_ID,
+  SLACK_USER_SCOPES,
+  SLACK_TUI_REDIRECT_URI,
+  SLACK_TUI_PORT,
+  clearSlackTokenCache,
+} from "../../../src/core/tools/builtin/slack-auth.js";
+
+export async function runSlackAuth(ctx: CommandContext): Promise<void> {
+  logger.info("[slack-auth] runSlackAuth() called");
+  ctx.showNotification("Starting Slack auth — opening browser…", "info");
+
+  const verifier = generateVerifier();
+  const challenge = await generateChallenge(verifier);
+  logger.info("[slack-auth] PKCE verifier + challenge generated");
+
+  const authUrl = buildAuthUrl({
+    clientId: SLACK_CLIENT_ID,
+    redirectUri: SLACK_TUI_REDIRECT_URI,
+    scopes: [],
+    userScopes: SLACK_USER_SCOPES,
+    challenge,
+    authEndpoint: "https://slack.com/oauth/v2/authorize",
+  });
+  logger.info("[slack-auth] Auth URL built", { redirectUri: SLACK_TUI_REDIRECT_URI });
+
+  const codePromise = waitForAuthCode(ctx);
+
+  const openCmd = process.platform === "darwin"
+    ? "open"
+    : process.platform === "win32"
+    ? "cmd /c start"
+    : "xdg-open";
+
+  logger.info("[slack-auth] Spawning browser", { openCmd });
+  Bun.spawn([openCmd, authUrl], { stdio: ["ignore", "ignore", "ignore"] });
+  logger.info("[slack-auth] Browser spawned — awaiting OAuth callback…");
+
+  const code = await codePromise;
+  logger.info("[slack-auth] codePromise resolved", { gotCode: !!code });
+
+  if (!code) return;
+
+  ctx.showNotification("Exchanging auth code for tokens…", "info");
+
+  try {
+    logger.info("[slack-auth] Exchanging code for tokens");
+    const tokens = await exchangeCode({
+      code,
+      verifier,
+      redirectUri: SLACK_TUI_REDIRECT_URI,
+      clientId: SLACK_CLIENT_ID,
+      tokenEndpoint: "https://slack.com/api/oauth.v2.access",
+      tokenResponsePath: ["authed_user"],
+    });
+    logger.info("[slack-auth] Token exchange succeeded — storing tokens");
+
+    clearSlackTokenCache();
+
+    const team = tokens._raw.team as Record<string, string> | undefined;
+    const workspaceId = team?.id;
+    const workspaceName = team?.name;
+
+    const human = await ctx.ei.getHuman();
+    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,
+        },
+      },
+    });
+
+    logger.info("[slack-auth] Tokens stored — done!");
+    ctx.showNotification("✓ Slack connected successfully!", "info");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.error("[slack-auth] Token exchange failed", { msg });
+    ctx.showNotification(`Slack auth failed: ${msg}`, "error");
+  }
+}
+
+async function waitForAuthCode(ctx: CommandContext): Promise<string | null> {
+  return new Promise<string | null>((resolve) => {
+    const TIMEOUT_MS = 120_000;
+
+    let resolved = false;
+    let server: ReturnType<typeof Bun.serve> | null = null;
+
+    const finish = (code: string | null) => {
+      if (resolved) return;
+      resolved = true;
+      logger.info("[slack-auth] finish() called", { gotCode: !!code });
+      try { server?.stop(true); } catch { /* ignore */ }
+      clearTimeout(timer);
+      resolve(code);
+    };
+
+    const timer = setTimeout(() => {
+      logger.warn("[slack-auth] Timed out waiting for callback");
+      ctx.showNotification("Slack auth timed out (2 min)", "error");
+      finish(null);
+    }, TIMEOUT_MS);
+
+    try {
+      server = Bun.serve({
+        port: SLACK_TUI_PORT,
+        hostname: "127.0.0.1",
+        fetch(req) {
+          const url = new URL(req.url);
+          logger.info("[slack-auth] Incoming request", { method: req.method, path: url.pathname });
+
+          if (url.pathname !== "/") {
+            return new Response("Not found", { status: 404 });
+          }
+
+          const code = url.searchParams.get("code");
+          const error = url.searchParams.get("error");
+          logger.info("[slack-auth] Callback params", { hasCode: !!code, error });
+
+          if (error || !code) {
+            const msg = error ?? "no code in callback";
+            logger.error("[slack-auth] Auth denied or missing code", { msg });
+            ctx.showNotification(`Slack denied auth: ${msg}`, "error");
+            finish(null);
+            return new Response(
+              "<html><body><h2>Auth failed — return to your terminal.</h2></body></html>",
+              { headers: { "Content-Type": "text/html" } }
+            );
+          }
+
+          const resp = new Response(
+            "<html><head><meta charset=\"utf-8\"></head><body><h2>✓ Slack connected! You can close this tab.</h2></body></html>",
+            { headers: { "Content-Type": "text/html; charset=utf-8" } }
+          );
+          setTimeout(() => finish(code), 0);
+          return resp;
+        },
+        error(err) {
+          logger.error("[slack-auth] Bun.serve error", { msg: err.message });
+          ctx.showNotification(`Local auth server error: ${err.message}`, "error");
+          finish(null);
+          return new Response("Internal Server Error", { status: 500 });
+        },
+      });
+      logger.info("[slack-auth] Bun.serve started", { port: server.port });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger.error("[slack-auth] Bun.serve failed to start", { msg });
+      ctx.showNotification(`Failed to start local auth server: ${msg}`, "error");
+      clearTimeout(timer);
+      resolve(null);
+    }
+  });
+}

package/tui/src/util/help-content.ts

@@ -126,6 +126,7 @@ EXTENDED COMMANDS
     /auth
         Authenticate with an external service.
         /auth spotify   Connect your Spotify account
+        /auth slack     Connect your Slack workspace
 
     /queue
         Pause the queue and inspect or edit active items in $EDITOR.

package/tui/src/util/logger.ts

@@ -1,6 +1,6 @@
 /** File-based logger for TUI debugging. Usage: tail -f $EI_DATA_PATH/tui.log */
 
-import { appendFileSync, mkdirSync, existsSync, readdirSync, unlinkSync, renameSync } from "node:fs";
+import { appendFileSync, mkdirSync, existsSync, readdirSync, unlinkSync, copyFileSync, truncateSync } from "node:fs";
 import { join } from "node:path";
 import { resolveDataPath } from "./resolve-data-path.js";
 
@@ -64,7 +64,8 @@ export function rotateLog(): void {
 
     if (existsSync(logPath)) {
       const ts = new Date().toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
-      renameSync(logPath, join(dataDir, `tui-${ts}.log`));
+      copyFileSync(logPath, join(dataDir, `tui-${ts}.log`));
+      truncateSync(logPath, 0);
     }
 
     const rolled = readdirSync(dataDir)

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

@@ -7,6 +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 { modelGuidToDisplay, displayToModelGuid } from "./yaml-shared.js";
 import { parseDuration, formatDuration } from "./duration.js";
 
@@ -46,6 +47,12 @@ interface EditableSettingsData {
     last_sync?: string | null;
     extraction_point?: string | null;
   };
+  slack?: {
+    integration?: boolean | null;
+    polling_interval_ms?: string | null;
+    last_sync?: string | null;
+    extraction_model?: string | null;
+  };
   backup?: {
     enabled?: boolean | null;
     max_backups?: number | null;
@@ -95,6 +102,12 @@ export function settingsToYAML(settings: HumanSettings | undefined, accounts: Pr
       last_sync: settings?.cursor?.last_sync ?? null,
       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',
+    },
     backup: {
       enabled: settings?.backup?.enabled ?? false,
       max_backups: settings?.backup?.max_backups ?? 24,
@@ -173,6 +186,17 @@ export function settingsFromYAML(yamlContent: string, original: HumanSettings |
     };
   }
 
+  let slack: SlackSettings | undefined;
+  if (data.slack) {
+    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),
+    };
+  }
+
   let backup: import('../../../src/core/types.js').BackupConfig | undefined;
   if (data.backup) {
     backup = {
@@ -197,6 +221,7 @@ export function settingsFromYAML(yamlContent: string, original: HumanSettings |
     opencode,
     claudeCode,
     cursor,
+    slack,
     backup,
   };
 }