slack-term 1.14.0 → 1.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slack-term",
-  "version": "1.14.0",
+  "version": "1.16.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/snomiao/slack-term.git"
@@ -22,7 +22,7 @@
     "vitest": "^4.1.4"
   },
   "bin": {
-    "slack": "./dist/cli.js"
+    "slack": "./ts/cli.ts"
   },
   "description": "Slack CLI — read activity/news/mentions, search, send messages with a confirm-hash safety gate.",
   "engines": {
@@ -49,7 +49,10 @@
     "@semantic-release/github": "^12"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "bin": {
+      "slack": "./dist/cli.js"
+    }
   },
   "scripts": {
     "dev": "bun run ts/cli.ts",

package/ts/auth.ts

@@ -1,8 +1,10 @@
 // Interactive auth setup: slack auth login / slack login
 import { createInterface, type Interface } from "node:readline/promises";
-import { addProfile, listProfiles } from "./profiles.ts";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { addProfile, listProfiles, setCookie, saveToEnvFile } from "./profiles.ts";
 import { authTest } from "./slack.ts";
-import { extractSessions } from "./slack-app.ts";
+import { extractSessions, discoverChromeCookies, discoverFirefoxCookies } from "./slack-app.ts";
 
 const USER_SCOPES = [
   "search:read",
@@ -50,7 +52,8 @@ async function ask(rl: Interface, q: string): Promise<string> {
   return (await rl.question(q)).trim();
 }
 
-async function saveToken(rl: Interface | null, token: string, nameOverride?: string): Promise<string> {
+
+async function saveToken(rl: Interface | null, token: string, nameOverride?: string, cookie?: string): Promise<string> {
   console.error("Verifying token...");
   const info = await authTest(token);
   const defaultName = slugify(info.team);
@@ -63,28 +66,67 @@ async function saveToken(rl: Interface | null, token: string, nameOverride?: str
   } else {
     name = defaultName;
   }
-  addProfile(name, { token, ...info });
-  console.log(`Saved workspace "${name}": ${info.team} (${info.user})`);
-  if (process.env.SLACK_MCP_XOXP_TOKEN) {
+
+  // Non-interactive: always save to profiles.json (predictable, backward-compatible for scripting).
+  // Interactive: ask where to save.
+  let filePath: string | null = null; // null = profiles.json
+  if (rl) {
+    console.log("");
+    console.log("Where to save the token?");
+    console.log("  1) ./.env.local                  (current directory)  [default]");
+    console.log("  2) ./.slack-term/.env.local       (current directory, slack-specific)");
+    console.log("  3) ~/.slack-term/.env.local       (global, available everywhere)");
+    console.log("  4) profiles.json                  (multi-workspace: slack auth use)");
     console.log("");
-    console.log("Warning: SLACK_MCP_XOXP_TOKEN is set in your environment - it conflicts with profiles.");
-    console.log("  Unset it so your new profile is used:");
-    console.log("    unset SLACK_MCP_XOXP_TOKEN");
-    console.log("  Also remove it from your shell config (~/.zshrc, ~/.bashrc, etc.)");
+    const choice = await ask(rl, "Choice [1/2/3/4, Enter=1]: ");
+    if (choice === "2") filePath = join(process.cwd(), ".slack-term", ".env.local");
+    else if (choice === "3") filePath = join(homedir(), ".slack-term", ".env.local");
+    else if (choice === "4") filePath = null;
+    else filePath = join(process.cwd(), ".env.local"); // 1 or Enter
+  }
+
+  if (filePath === null) {
+    addProfile(name, { token, ...info, ...(cookie ? { cookie } : {}) });
+    console.log(`Saved workspace "${name}" to profiles.json: ${info.team} (${info.user})`);
+    if (process.env.SLACK_MCP_XOXP_TOKEN) {
+      console.log("");
+      console.log("Warning: SLACK_MCP_XOXP_TOKEN is set — it conflicts with profiles.");
+      console.log("  Unset it: unset SLACK_MCP_XOXP_TOKEN  (and remove from ~/.zshrc / ~/.bashrc)");
+    } else {
+      console.log(`  Run: slack auth use -g ${name}`);
+    }
   } else {
-    console.log(`  Run: slack auth use -g ${name}`);
+    const updates: Record<string, string> = { SLACK_TOKEN: token };
+    if (cookie) updates.SLACK_COOKIE = cookie;
+    saveToEnvFile(filePath, updates);
+    console.log(`Saved token to ${filePath}`);
+    console.log(`  SLACK_TOKEN will be picked up automatically in this directory tree.`);
   }
   return name;
 }
 
 /** Shared logic for importing sessions from the Slack desktop app. */
-export async function importFromDesktop(): Promise<void> {
+export async function importFromDesktop(rl?: Interface): Promise<void> {
   console.error("Scanning Slack desktop app...");
   const sessions = await extractSessions();
   if (sessions.length === 0) {
     console.error("No sessions found. Make sure Slack is installed and you have signed in at least once.");
     process.exit(1);
   }
+
+  // Single workspace + interactive: offer save-destination choice
+  if (sessions.length === 1 && rl) {
+    const s = sessions[0]!;
+    const teamLabel = s.teamName ?? s.teamId;
+    console.log(`Found workspace: ${teamLabel}${s.cookie ? " (+ xoxd cookie)" : ""}`);
+    await saveToken(rl, s.token, slugify(teamLabel), s.cookie);
+    console.log("");
+    console.log("Note: desktop app tokens (xoxc-) are internal Slack tokens.");
+    console.log("If API calls fail, replace with an xoxp- token: slack auth login");
+    return;
+  }
+
+  // Multiple workspaces or non-interactive: save all to profiles.json
   for (const s of sessions) {
     const teamLabel = s.teamName ?? s.teamId;
     const name = slugify(teamLabel);
@@ -172,6 +214,219 @@ async function loginNewApp(rl: Interface, mode: "user" | "bot"): Promise<void> {
   await saveToken(rl, token);
 }
 
+/**
+ * Attach the xoxd session cookie from Chrome browser to an existing workspace profile.
+ *
+ * When run interactively, macOS will show a system dialog asking for the login password
+ * to grant access to the "Chrome Safe Storage" keychain item — click Allow.
+ */
+export async function cmdAuthChrome(opts: { workspace?: string } = {}): Promise<void> {
+  if (process.platform !== "darwin") {
+    console.error("Chrome cookie extraction is only supported on macOS.");
+    process.exit(1);
+  }
+
+  const profiles = listProfiles();
+  if (profiles.length === 0) {
+    console.error("No workspaces configured. Run: slack auth login");
+    process.exit(1);
+  }
+
+  let profileName: string;
+  if (opts.workspace) {
+    const found = profiles.find((p) => p.name === opts.workspace);
+    if (!found) {
+      console.error(`Workspace "${opts.workspace}" not found. Available: ${profiles.map((p) => p.name).join(", ")}`);
+      process.exit(1);
+    }
+    profileName = opts.workspace;
+  } else if (profiles.length === 1) {
+    profileName = profiles[0]!.name;
+  } else {
+    // Multiple profiles — ask the user to pick
+    const current = profiles.find((p) => p.current);
+    if (current) {
+      profileName = current.name;
+      console.log(`Using active workspace: ${profileName}`);
+    } else {
+      console.log("Multiple workspaces found. Choose one:");
+      profiles.forEach((p, i) => console.log(`  ${i + 1}) ${p.name}  (${p.profile.team})`));
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const choice = (await rl.question("Choice: ")).trim();
+      rl.close();
+      const idx = parseInt(choice, 10) - 1;
+      if (isNaN(idx) || idx < 0 || idx >= profiles.length) {
+        console.error("Invalid choice.");
+        process.exit(1);
+      }
+      profileName = profiles[idx]!.name;
+    }
+  }
+
+  console.log("Scanning Chrome profiles for Slack session...");
+  console.log("macOS may show a dialog asking for your login password — click Allow.");
+
+  let candidates: import("./slack-app.ts").ChromeCookieCandidate[];
+  let totalProfiles: number;
+  try {
+    ({ candidates, totalProfiles } = discoverChromeCookies());
+  } catch (e: unknown) {
+    console.error(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+    process.exit(1);
+  }
+
+  if (candidates.length === 0) {
+    console.error(`No Slack session found in Chrome (scanned ${totalProfiles} profile${totalProfiles !== 1 ? "s" : ""}). Possible reasons:`);
+    console.error("  - You denied the keychain dialog (try running again and click Allow)");
+    console.error("  - Chrome is not installed or has no Slack session");
+    console.error("  - You're not logged in to Slack in Chrome");
+    process.exit(1);
+  }
+
+  let cookie: string;
+  // Always prompt when multiple Chrome profiles exist, so users can confirm the right one.
+  if (candidates.length === 1 && totalProfiles <= 1) {
+    cookie = candidates[0]!.cookie;
+    console.log(`Found session in Chrome profile: ${candidates[0]!.profileName}`);
+  } else {
+    const label = candidates.length === 1
+      ? `Found 1 Slack session across ${totalProfiles} Chrome profiles:`
+      : `Found ${candidates.length} Slack sessions across ${totalProfiles} Chrome profiles:`;
+    console.log(label);
+    candidates.forEach((c, i) => console.log(`  ${i + 1}) ${c.profileName}  [${c.profileDir}]`));
+    console.log("");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const defaultChoice = candidates.length === 1 ? " [Enter=1]" : "";
+    const choice = (await rl.question(`Choice [1-${candidates.length}]${defaultChoice}: `)).trim();
+    rl.close();
+    const idx = choice === "" && candidates.length === 1 ? 0 : parseInt(choice, 10) - 1;
+    if (isNaN(idx) || idx < 0 || idx >= candidates.length) {
+      console.error("Invalid choice.");
+      process.exit(1);
+    }
+    cookie = candidates[idx]!.cookie;
+  }
+
+  setCookie(profileName, cookie);
+  console.log(`Saved xoxd cookie to workspace "${profileName}".`);
+  console.log(`RTM WebSocket mode is now available: slack tail @you`);
+}
+
+/**
+ * Attach the xoxd session cookie from Firefox browser to an existing workspace profile.
+ * Firefox stores cookies in plaintext — no keychain access needed.
+ */
+export async function cmdAuthFirefox(opts: { workspace?: string } = {}): Promise<void> {
+  const profiles = listProfiles();
+  if (profiles.length === 0) {
+    console.error("No workspaces configured. Run: slack auth token");
+    process.exit(1);
+  }
+
+  let profileName: string;
+  if (opts.workspace) {
+    const found = profiles.find((p) => p.name === opts.workspace);
+    if (!found) {
+      console.error(`Workspace "${opts.workspace}" not found. Available: ${profiles.map((p) => p.name).join(", ")}`);
+      process.exit(1);
+    }
+    profileName = opts.workspace;
+  } else if (profiles.length === 1) {
+    profileName = profiles[0]!.name;
+  } else {
+    const current = profiles.find((p) => p.current);
+    if (current) {
+      profileName = current.name;
+      console.log(`Using active workspace: ${profileName}`);
+    } else {
+      console.log("Multiple workspaces found. Choose one:");
+      profiles.forEach((p, i) => console.log(`  ${i + 1}) ${p.name}  (${p.profile.team})`));
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const choice = (await rl.question("Choice: ")).trim();
+      rl.close();
+      const idx = parseInt(choice, 10) - 1;
+      if (isNaN(idx) || idx < 0 || idx >= profiles.length) {
+        console.error("Invalid choice.");
+        process.exit(1);
+      }
+      profileName = profiles[idx]!.name;
+    }
+  }
+
+  console.log("Scanning Firefox profiles for Slack session...");
+  const candidates = discoverFirefoxCookies();
+
+  if (candidates.length === 0) {
+    console.error("No Slack session found in Firefox. Possible reasons:");
+    console.error("  - Firefox is not installed");
+    console.error("  - You are not logged in to Slack in Firefox");
+    process.exit(1);
+  }
+
+  let cookie: string;
+  if (candidates.length === 1) {
+    cookie = candidates[0]!.cookie;
+    console.log(`Found session in Firefox profile: ${candidates[0]!.profileName}`);
+  } else {
+    console.log("Multiple Firefox profiles have a Slack session. Choose one:");
+    candidates.forEach((c, i) => console.log(`  ${i + 1}) ${c.profileName}  [${c.profileDir}]`));
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const choice = (await rl.question("Choice: ")).trim();
+    rl.close();
+    const idx = parseInt(choice, 10) - 1;
+    if (isNaN(idx) || idx < 0 || idx >= candidates.length) {
+      console.error("Invalid choice.");
+      process.exit(1);
+    }
+    cookie = candidates[idx]!.cookie;
+  }
+
+  setCookie(profileName, cookie);
+  console.log(`Saved xoxd cookie to workspace "${profileName}".`);
+  console.log(`RTM WebSocket mode is now available: slack tail @you`);
+}
+
+/** Paste an existing xoxp-/xoxb- token (non-interactive or TTY). */
+export async function cmdAuthToken(opts: { token?: string; name?: string } = {}): Promise<void> {
+  if (opts.token) {
+    await saveToken(null, opts.token, opts.name);
+    return;
+  }
+  if (!process.stdin.isTTY) {
+    const chunks: Buffer[] = [];
+    for await (const chunk of process.stdin) chunks.push(chunk as Buffer);
+    const token = Buffer.concat(chunks).toString("utf8").trim();
+    if (!token) { console.error("No token provided on stdin."); process.exit(1); }
+    await saveToken(null, token, opts.name);
+    return;
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    await loginExisting(rl);
+  } finally {
+    rl.close();
+  }
+}
+
+/** Guided Slack app creation wizard (user or bot token). */
+export async function cmdAuthApp(opts: { bot?: boolean } = {}): Promise<void> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    if (opts.bot !== undefined) {
+      await loginNewApp(rl, opts.bot ? "bot" : "user");
+      return;
+    }
+    console.log("Which token type?");
+    console.log("  1) User token (xoxp-)  -full access including search  [default]");
+    console.log("  2) Bot token  (xoxb-)  -search and news unavailable");
+    console.log("");
+    const choice = await ask(rl, "Choice [1/2, Enter=1]: ");
+    await loginNewApp(rl, choice === "2" ? "bot" : "user");
+  } finally {
+    rl.close();
+  }
+}
+
 export async function cmdAuthLogin(opts: { token?: string; name?: string } = {}): Promise<void> {
   // Show existing profiles if any
   const existing = listProfiles();
@@ -225,7 +480,7 @@ export async function cmdAuthLogin(opts: { token?: string; name?: string } = {})
     console.log("");
 
     if (choice === "1") {
-      await importFromDesktop();
+      await importFromDesktop(rl);
     } else if (choice === "2") {
       await loginExisting(rl);
     } else if (choice === "3") {

package/ts/botdoctor.ts

@@ -0,0 +1,96 @@
+// Bot messaging diagnostics.
+//
+// A bot can *send* a DM with chat:write + im:write, but for an escalation DM to
+// be useful the user must also be able to *reply* and the bot must be able to
+// *read* that reply (im:history / im:read), and the app's Messages Tab must
+// allow user messages. Slack exposes granted scopes via the X-OAuth-Scopes
+// header (see slack.ts authScopes); the Messages-Tab toggle is not readable via
+// the API, so we surface it as a manual step whenever messaging looks incomplete.
+
+import { authScopes, botsInfo } from "./slack.ts";
+
+// Scopes required to DM a user as the bot.
+export const DM_SEND_SCOPES = ["chat:write", "im:write"];
+// Scopes required to read the user's reply to that DM.
+export const DM_REPLY_SCOPES = ["im:history", "im:read"];
+
+export type BotMessagingDiagnosis = {
+  ok: boolean; // can both send and receive replies
+  canSend: boolean;
+  canReceiveReplies: boolean;
+  botUserId: string;
+  appId: string;
+  team: string;
+  grantedScopes: string[];
+  missingSendScopes: string[];
+  missingReplyScopes: string[];
+};
+
+export async function diagnoseBotMessaging(token: string): Promise<BotMessagingDiagnosis> {
+  const { userId, botId, team, scopes } = await authScopes(token);
+  let appId = "";
+  if (botId) {
+    // app_id is best-effort: bots.info needs no extra scope, but never let a
+    // lookup failure block the diagnosis itself.
+    try {
+      appId = (await botsInfo(token, botId)).appId;
+    } catch {
+      appId = "";
+    }
+  }
+  const has = (s: string): boolean => scopes.includes(s);
+  const missingSendScopes = DM_SEND_SCOPES.filter((s) => !has(s));
+  const missingReplyScopes = DM_REPLY_SCOPES.filter((s) => !has(s));
+  return {
+    canSend: missingSendScopes.length === 0,
+    canReceiveReplies: missingReplyScopes.length === 0,
+    ok: missingSendScopes.length === 0 && missingReplyScopes.length === 0,
+    botUserId: userId,
+    appId,
+    team,
+    grantedScopes: scopes,
+    missingSendScopes,
+    missingReplyScopes,
+  };
+}
+
+function detailLines(d: BotMessagingDiagnosis): string[] {
+  return [
+    ``,
+    `  Bot user:       ${d.botUserId || "(unknown)"}`,
+    `  App ID:         ${d.appId || "(unknown — bots.info unavailable)"}`,
+    `  Granted scopes: ${d.grantedScopes.join(", ") || "(none reported)"}`,
+  ];
+}
+
+// Human-facing guidance. `compact` drops the trailing identity/scope dump used
+// by `slack doctor`. Note `ok` only means scopes are complete — the Messages Tab
+// toggle ("Allow users to send messages") is NOT readable via the API, so we
+// always surface it as a manual check rather than over-claiming readiness.
+export function formatDiagnosis(d: BotMessagingDiagnosis, compact = false): string[] {
+  const appUrl = d.appId ? `https://api.slack.com/apps/${d.appId}` : "https://api.slack.com/apps";
+
+  if (d.ok) {
+    const lines = [
+      `✓ Bot DM scopes are complete (send + read replies).`,
+      `  Two-way replies also require the Messages Tab, which is not API-detectable.`,
+      `  If recipients see "Sending messages to this app is turned off", enable it:`,
+      `  ${appUrl} → App Home → "Messages Tab" ON + "Allow users to send messages".`,
+    ];
+    return compact ? lines : [...lines, ...detailLines(d)];
+  }
+
+  const lines: string[] = [];
+  if (!d.canSend) {
+    lines.push(`⚠ This bot CANNOT send DMs — missing scope(s): ${d.missingSendScopes.join(", ")}.`);
+  } else {
+    lines.push(`⚠ This bot can send DMs, but the user's replies will NOT be readable.`);
+  }
+  lines.push(`  Make escalation DMs two-way:`);
+  lines.push(`  1. ${appUrl} → App Home → enable "Messages Tab" and check`);
+  lines.push(`     "Allow users to send Slash commands and messages".`);
+  lines.push(`  2. OAuth & Permissions → add Bot Token Scopes: ${[...d.missingSendScopes, ...d.missingReplyScopes].join(", ")}`);
+  lines.push(`  3. Reinstall the app to apply the new scopes.`);
+
+  return compact ? lines : [...lines, ...detailLines(d)];
+}