ei-tui 1.3.4 → 1.4.0

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,
   };
 }