slack-term 1.34.0 → 1.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slack-term",
-  "version": "1.34.0",
+  "version": "1.36.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/snomiao/slack-term.git"

package/ts/agent.ts

@@ -0,0 +1,148 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import { constants } from "node:os";
+import type { Argv } from "yargs";
+import { resolveBotToken } from "./profiles.ts";
+import { renameAgentSession, resolveChannel, setAgentStatus, type AgentStatus, type AgentThread } from "./slack.ts";
+
+const statuses: AgentStatus[] = ["processing", "active", "suspended", "closed"];
+type ParseTarget = (target: string) => { ref: string; threadTs?: string };
+
+function botToken(envName?: string): string {
+  if (envName !== undefined && !/^[A-Za-z_][A-Za-z0-9_]*$/.test(envName)) {
+    throw new Error("--bot-token-env must name an environment variable, not contain a token.");
+  }
+  const token = envName === undefined ? resolveBotToken() : process.env[envName];
+  if (!token?.startsWith("xoxb-")) {
+    throw new Error("Agent commands require a bot token (xoxb). Set SLACK_BOT_TOKEN or --bot-token-env NAME; user tokens are refused.");
+  }
+  return token;
+}
+
+function validateTitle(title?: string): void {
+  if (title !== undefined && (!title.trim() || [...title].length > 200)) {
+    throw new Error("--title must contain 1–200 characters.");
+  }
+}
+
+async function threadTarget(token: string, target: string, parse: ParseTarget): Promise<AgentThread> {
+  const { ref, threadTs } = parse(target);
+  if (!threadTs || !/^\d{10}\.\d{6}$/.test(threadTs)) {
+    throw new Error("Target must include a thread root: C00000001:1700000000.000100, #channel:ts, or a message permalink.");
+  }
+  return { channel_id: await resolveChannel(token, ref), thread_ts: threadTs };
+}
+
+function report(context: string, error: unknown): void {
+  console.error(`agent: ${context}: ${error instanceof Error ? error.message : "request failed"}`);
+}
+
+/** Own the command's lifetime, and serialize the last refresh before final cleanup. */
+export async function runAgent(
+  token: string,
+  thread: AgentThread,
+  command: string[],
+  opts: { every: number; title?: string; close: boolean },
+): Promise<number> {
+  let child: ChildProcess | undefined;
+  let signal: NodeJS.Signals | undefined;
+  let killTimer: ReturnType<typeof setTimeout> | undefined;
+  let timer: ReturnType<typeof setInterval> | undefined;
+  let refreshing: Promise<void> | undefined;
+  let stopping = false;
+  let attempted = false;
+  let code = 1;
+
+  const stop = (received: NodeJS.Signals) => {
+    if (signal) return; // repeated interrupts must not bypass the final write
+    signal = received;
+    stopping = true;
+    if (child && child.exitCode === null && child.signalCode === null) {
+      child.kill(received);
+      killTimer = setTimeout(() => child?.kill("SIGKILL"), 5000);
+    }
+  };
+  const onInt = () => stop("SIGINT");
+  const onTerm = () => stop("SIGTERM");
+  process.on("SIGINT", onInt);
+  process.on("SIGTERM", onTerm);
+  try {
+    attempted = true; // even a lost response may have set processing remotely
+    await setAgentStatus(token, thread, "processing");
+    if (!stopping && opts.title !== undefined) await renameAgentSession(token, thread, opts.title);
+    if (!stopping) {
+      child = spawn(command[0]!, command.slice(1), { stdio: "inherit" });
+      const done = new Promise<number>((resolve) => {
+        child!.once("error", () => {
+          console.error("agent: could not start command");
+          resolve(127);
+        });
+        child!.once("exit", (exitCode, exitSignal) => {
+          resolve(exitCode ?? (exitSignal ? 128 + constants.signals[exitSignal] : 1));
+        });
+      });
+      timer = setInterval(() => {
+        if (stopping || refreshing) return;
+        refreshing = setAgentStatus(token, thread, "processing")
+          .then(() => {})
+          .catch((error: unknown) => report("heartbeat failed; retrying on next tick", error))
+          .finally(() => { refreshing = undefined; });
+      }, opts.every * 1000);
+      code = await done;
+    }
+  } catch (error) {
+    report("could not start agent session", error);
+  } finally {
+    stopping = true;
+    clearInterval(timer);
+    clearTimeout(killTimer);
+    // No late processing write may race with (and undo) the final active write.
+    await refreshing;
+    if (attempted) {
+      try {
+        await setAgentStatus(token, thread, opts.close ? "closed" : "active");
+      } catch (error) {
+        report("final status clear failed", error);
+        if (code === 0) code = 1;
+      }
+    }
+    process.removeListener("SIGINT", onInt);
+    process.removeListener("SIGTERM", onTerm);
+  }
+  return signal ? 128 + constants.signals[signal] : code;
+}
+
+export function agentCommands(y: Argv, parse: ParseTarget): Argv {
+  const common = (args: Argv) => args
+    .positional("target", { type: "string", demandOption: true, describe: "Thread root: raw channel ID:ts (avoids listing), #channel:ts, or permalink" })
+    .option("title", { type: "string", describe: "Rename the session (1–200 characters)" })
+    .option("bot-token-env", { type: "string", describe: "Environment variable holding an agent-enabled app's xoxb token (default SLACK_BOT_TOKEN); requires chat:write and channel membership" });
+  return y
+    .command("status <target> <status>", "Set a bot agent session's status", (args) => common(args)
+      .positional("status", { type: "string", choices: statuses, demandOption: true }), async (args) => {
+      validateTitle(args.title);
+      const token = botToken(args["bot-token-env"]);
+      const thread = await threadTarget(token, args.target, parse);
+      await setAgentStatus(token, thread, args.status as AgentStatus);
+      if (args.title !== undefined) await renameAgentSession(token, thread, args.title);
+    })
+    .command("run <target>", "Keep a thread working while a command runs: run <target> -- <command...>", (args) => common(args)
+      .parserConfiguration({ "populate--": true })
+      .option("every", { type: "number", default: 300, describe: "Heartbeat seconds (>0 and <3600); processing expires after one hour" })
+      .option("close", { type: "boolean", default: false, describe: "Finish with closed instead of active (also on failure or interrupt)" }), async (args) => {
+      validateTitle(args.title);
+      if (!Number.isFinite(args.every) || args.every <= 0 || args.every >= 3600) {
+        throw new Error("--every must be greater than 0 and less than 3600 seconds.");
+      }
+      // Preserve the exact argv, including numeric strings and the child's own --.
+      const separator = process.argv.indexOf("--");
+      const command = separator < 0 ? [] : process.argv.slice(separator + 1);
+      if (!command[0]) throw new Error("agent run requires -- <command...>");
+      const token = botToken(args["bot-token-env"]);
+      const thread = await threadTarget(token, args.target, parse);
+      process.exitCode = await runAgent(token, thread, command, {
+        every: args.every, close: args.close,
+        ...(args.title !== undefined ? { title: args.title } : {}),
+      });
+    })
+    .demandCommand(1, "Choose agent status or agent run.");
+}

package/ts/ask.ts

@@ -179,6 +179,12 @@ export function askBuildResolvedText(question: string, found: AskFound, who: str
   return `${ASK_RESOLVED_PREFIX}*${question}*\n_${found.how}で回答済み${who ? ` (${who})` : ""}_\n\n${quoted}`;
 }
 
+/** Undo Slack's storage escaping. Only these three are ever escaped, and `&`
+ *  goes LAST so an answer that literally contains `<` is not decoded twice. */
+function askDecodeEntities(s: string): string {
+  return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
+
 export type AskParsed =
   | { kind: "open"; question: string; reactable: string[]; overflow: string[]; threadOnly: boolean }
   | { kind: "resolved"; question: string; answer: string }
@@ -222,10 +228,15 @@ export function askParseMessage(text: string): AskParsed {
   // would re-poll a question that already has its answer.
   if (text.startsWith(ASK_RESOLVED_PREFIX)) {
     const head = lines[0]!.slice(ASK_RESOLVED_PREFIX.length);
-    const question = head.replace(/^\*/, "").replace(/\*$/, "");
+    const question = askDecodeEntities(head.replace(/^\*/, "").replace(/\*$/, ""));
+    // `&gt; `, not only `> `: Slack HTML-escapes `&`, `<` and `>` in the text it
+    // hands back, so the quote we wrote as `> ` is STORED as `&gt; `. Matching
+    // only the raw form made every collected question unreadable — re-running
+    // `--waitFor` on one exited 3 (measured 2026-09-27: 40 of 71 asks).
     const answer = lines
-      .filter((l) => l.startsWith("> "))
-      .map((l) => l.slice(2))
+      .map((l) => (l.startsWith("> ") ? l.slice(2) : l.startsWith("&gt; ") ? l.slice(5) : null))
+      .filter((l): l is string => l !== null)
+      .map(askDecodeEntities)
       .join("\n");
     // A ✅-stamped body with no quoted answer is not a settled question we can
     // report; treat it as unknown rather than answer with an empty string.

package/ts/auth.ts

@@ -1,10 +1,10 @@
 // Interactive auth setup: slack auth login / slack login
 import { createInterface, type Interface } from "node:readline/promises";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { homedir } from "node:os";
-import { addProfile, listProfiles, setCookie, saveToEnvFile } from "./profiles.ts";
+import { addProfile, listProfiles, setCookie, saveToEnvFile, resolveToken, resolveCookie, resolveBotToken } from "./profiles.ts";
 import { authTest } from "./slack.ts";
-import { extractSessions, discoverChromeCookies, discoverFirefoxCookies } from "./slack-app.ts";
+import { extractSessions, extractChromeSessions, discoverChromeCookies, discoverFirefoxCookies } from "./slack-app.ts";
 
 const USER_SCOPES = [
   "search:read",
@@ -53,9 +53,16 @@ async function ask(rl: Interface, q: string): Promise<string> {
 }
 
 
+async function allowBrowserProfileRead(rl: Interface | undefined, yes: boolean): Promise<boolean> {
+  if (yes) return true;
+  if (!rl) return false;
+  const answer = await ask(rl, "Read local browser profiles and Slack session cookies? [y/N]: ");
+  return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+}
+
 async function saveToken(rl: Interface | null, token: string, nameOverride?: string, cookie?: string): Promise<string> {
   console.error("Verifying token...");
-  const info = await authTest(token);
+  const info = await authTest(token, cookie);
   const defaultName = slugify(info.team);
   let name: string;
   if (nameOverride) {
@@ -106,16 +113,53 @@ async function saveToken(rl: Interface | null, token: string, nameOverride?: str
 }
 
 /** Shared logic for importing sessions from the Slack desktop app. */
-export async function importFromDesktop(rl?: Interface): Promise<void> {
+export async function importFromDesktop(
+  rl?: Interface, yes = false, browser: "auto" | "all" | "chrome" | "firefox" | "none" = "auto",
+  saveProfileOnly = false,
+): 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);
   }
+  if (process.platform === "linux" && browser !== "none" && sessions.some((s) => !s.cookie) && await allowBrowserProfileRead(rl, yes)) {
+    const found: { source: string; profileName: string; cookie: string }[] = [];
+    if (browser !== "chrome") {
+      for (const candidate of discoverFirefoxCookies()) {
+        found.push({ source: "Firefox", profileName: candidate.profileName, cookie: candidate.cookie });
+      }
+    }
+    if (browser === "chrome" || browser === "all" || (browser === "auto" && found.length === 0)) {
+      try {
+        for (const candidate of discoverChromeCookies().candidates) {
+          found.push({ source: "Chrome", profileName: candidate.profileName, cookie: candidate.cookie });
+        }
+      } catch (e: unknown) {
+        console.error(e instanceof Error ? e.message : String(e));
+      }
+    }
+    if (found.length === 1) {
+      for (const session of sessions) session.cookie ??= found[0]!.cookie;
+      console.log(`Found Slack session cookie in ${found[0]!.source} profile: ${found[0]!.profileName}`);
+    } else if (found.length > 1) {
+      console.log("Multiple browser sessions found. Choose one later with slack auth chrome or slack auth firefox.");
+    }
+    if (sessions.some((s) => !s.cookie)) {
+      console.log("Desktop session needs an xoxd cookie on Linux. Run: slack auth chrome or slack auth firefox");
+    }
+  }
+
+  await saveImportedSessions(sessions, rl, saveProfileOnly);
+}
 
-  // Single workspace + interactive: offer save-destination choice
-  if (sessions.length === 1 && rl) {
+async function saveImportedSessions(
+  sessions: import("./slack-app.ts").SlackAppSession[], rl?: Interface, saveProfileOnly = false,
+): Promise<void> {
+  // A session token without a cookie cannot pass auth.test yet. Save its
+  // LevelDB metadata as a profile so auth firefox can attach the cookie later.
+  // Single workspace + interactive + cookie: offer save-destination choice
+  if (sessions.length === 1 && rl && sessions[0]?.cookie && !saveProfileOnly) {
     const s = sessions[0]!;
     const teamLabel = s.teamName ?? s.teamId;
     console.log(`Found workspace: ${teamLabel}${s.cookie ? " (+ xoxd cookie)" : ""}`);
@@ -220,9 +264,9 @@ async function loginNewApp(rl: Interface, mode: "user" | "bot"): Promise<void> {
  * 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.");
+export async function cmdAuthChrome(opts: { workspace?: string; yes?: boolean } = {}): Promise<void> {
+  if (process.platform !== "darwin" && process.platform !== "linux") {
+    console.error("Chrome cookie extraction is supported on macOS and Linux.");
     process.exit(1);
   }
 
@@ -286,8 +330,21 @@ export async function cmdAuthChrome(opts: { workspace?: string } = {}): Promise<
     process.exit(1);
   }
 
+  if (!opts.yes && !process.stdin.isTTY) {
+    console.error("Reading browser profiles requires confirmation. Re-run interactively or pass --yes.");
+    process.exit(1);
+  }
+  const confirmRl = opts.yes ? undefined : createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    if (!await allowBrowserProfileRead(confirmRl, opts.yes ?? false)) {
+      console.log("Browser profile scan cancelled.");
+      return;
+    }
+  } finally {
+    confirmRl?.close();
+  }
   console.log("Scanning Chrome profiles for Slack session...");
-  console.log("macOS may show a dialog asking for your login password — click Allow.");
+  if (process.platform === "darwin") console.log("macOS may show a dialog asking for your login password — click Allow.");
 
   let candidates: import("./slack-app.ts").ChromeCookieCandidate[];
   let totalProfiles: number;
@@ -300,7 +357,7 @@ export async function cmdAuthChrome(opts: { workspace?: string } = {}): Promise<
 
   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)");
+    if (process.platform === "darwin") 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);
@@ -339,7 +396,7 @@ export async function cmdAuthChrome(opts: { workspace?: string } = {}): Promise<
  * 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> {
+export async function cmdAuthFirefox(opts: { workspace?: string; yes?: boolean } = {}): Promise<void> {
   const profiles = listProfiles();
   if (profiles.length === 0) {
     console.error("No workspaces configured. Run: slack auth login");
@@ -376,6 +433,19 @@ export async function cmdAuthFirefox(opts: { workspace?: string } = {}): Promise
     }
   }
 
+  if (!opts.yes && !process.stdin.isTTY) {
+    console.error("Reading browser profiles requires confirmation. Re-run interactively or pass --yes.");
+    process.exit(1);
+  }
+  const confirmRl = opts.yes ? undefined : createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    if (!await allowBrowserProfileRead(confirmRl, opts.yes ?? false)) {
+      console.log("Browser profile scan cancelled.");
+      return;
+    }
+  } finally {
+    confirmRl?.close();
+  }
   console.log("Scanning Firefox profiles for Slack session...");
   const candidates = discoverFirefoxCookies();
 
@@ -450,7 +520,44 @@ export async function cmdAuthApp(opts: { bot?: boolean } = {}): Promise<void> {
   }
 }
 
-export async function cmdAuthLogin(opts: { token?: string; name?: string } = {}): Promise<void> {
+/** Print the currently resolved credentials as dotenv assignments. */
+export function cmdAuthTokens(opts: { workspace?: string } = {}): void {
+  const format = (name: string, value: string): string => {
+    if (/[\r\n]/.test(value)) throw new Error(`Invalid newline in ${name}.`);
+    return `${name}=${/^[A-Za-z0-9._=-]+$/.test(value) ? value : JSON.stringify(value)}`;
+  };
+  const lines = [format("SLACK_TOKEN", resolveToken(opts.workspace))];
+  const cookie = resolveCookie(opts.workspace);
+  if (cookie) lines.push(format("SLACK_COOKIE", cookie));
+  if (!opts.workspace) {
+    const bot = resolveBotToken();
+    if (bot) lines.push(format("SLACK_BOT_TOKEN", bot));
+  }
+  console.log(lines.join("\n"));
+}
+
+/** Export a selected profile for env-file based CLI use. */
+export function cmdAuthSave(opts: { envfile: string; workspace?: string }): void {
+  const profiles = listProfiles();
+  const selected = opts.workspace
+    ? profiles.find((entry) => entry.name === opts.workspace)
+    : profiles.find((entry) => entry.current) ?? (profiles.length === 1 ? profiles[0] : undefined);
+  if (!selected) {
+    throw new Error(opts.workspace
+      ? `Workspace "${opts.workspace}" not found. Run: slack auth ls`
+      : "Select a workspace with slack auth use <name>, or pass --workspace <name>.");
+  }
+  if (!selected.profile.cookie) {
+    throw new Error(`Workspace "${selected.name}" has no session cookie. Run: slack auth chrome -w ${selected.name} or slack auth firefox -w ${selected.name}`);
+  }
+  const filePath = resolve(opts.envfile);
+  saveToEnvFile(filePath, { SLACK_TOKEN: selected.profile.token, SLACK_COOKIE: selected.profile.cookie });
+  console.log(`Saved token and cookie for workspace "${selected.name}" to ${filePath}`);
+}
+
+export async function cmdAuthLogin(opts: {
+  token?: string; name?: string; yes?: boolean; fromDesktop?: boolean; fromChrome?: boolean; fromFirefox?: boolean; fromAll?: boolean;
+} = {}): Promise<void> {
   // Show existing profiles if any
   const existing = listProfiles();
   if (existing.length > 0) {
@@ -462,6 +569,68 @@ export async function cmdAuthLogin(opts: { token?: string; name?: string } = {})
     console.log("");
   }
 
+  if ([opts.fromChrome, opts.fromFirefox, opts.fromAll].filter(Boolean).length > 1) {
+    throw new Error("Choose only one browser source: --from-chrome, --from-firefox, or --from-all.");
+  }
+  if (opts.fromChrome && !opts.fromDesktop) {
+    if (!opts.yes && !process.stdin.isTTY) {
+      throw new Error("Reading browser profiles requires confirmation. Re-run interactively or pass --yes.");
+    }
+    const rl = process.stdin.isTTY ? createInterface({ input: process.stdin, output: process.stdout }) : undefined;
+    try {
+      if (!await allowBrowserProfileRead(rl, opts.yes ?? false)) {
+        console.log("Browser profile scan cancelled.");
+        return;
+      }
+      const sessions = await extractChromeSessions();
+      if (sessions.length === 0) throw new Error("No Slack session token found in Chrome profiles.");
+      await saveImportedSessions(sessions, rl, true);
+    } finally {
+      rl?.close();
+    }
+    return;
+  }
+  if (opts.fromAll && !opts.fromDesktop) {
+    if (!opts.yes && !process.stdin.isTTY) {
+      throw new Error("Reading browser profiles requires confirmation. Re-run interactively or pass --yes.");
+    }
+    const rl = process.stdin.isTTY ? createInterface({ input: process.stdin, output: process.stdout }) : undefined;
+    try {
+      try {
+        await importFromDesktop(rl, opts.yes ?? false, "all", true);
+      } catch (e: unknown) {
+        if (!(e instanceof Error) || !e.message.startsWith("Slack desktop app LevelDB not found")) throw e;
+        if (!await allowBrowserProfileRead(rl, opts.yes ?? false)) {
+          console.log("Browser profile scan cancelled.");
+          return;
+        }
+        const sessions = await extractChromeSessions();
+        if (sessions.length === 0) throw new Error("No Slack session token found in Chrome profiles.");
+        if (sessions.every((s) => !s.cookie)) {
+          const firefox = discoverFirefoxCookies();
+          if (firefox.length === 1) for (const session of sessions) session.cookie = firefox[0]!.cookie;
+        }
+        await saveImportedSessions(sessions, rl, true);
+      }
+    } finally {
+      rl?.close();
+    }
+    return;
+  }
+  if (opts.fromDesktop || opts.fromChrome || opts.fromFirefox || opts.fromAll) {
+    const browser = opts.fromChrome ? "chrome" : opts.fromFirefox ? "firefox" : opts.fromAll ? "all" : "none";
+    if (browser !== "none" && !opts.yes && !process.stdin.isTTY) {
+      throw new Error("Reading browser profiles requires confirmation. Re-run interactively or pass --yes.");
+    }
+    const rl = process.stdin.isTTY ? createInterface({ input: process.stdin, output: process.stdout }) : undefined;
+    try {
+      await importFromDesktop(rl, opts.yes ?? false, browser, true);
+    } finally {
+      rl?.close();
+    }
+    return;
+  }
+
   // Non-interactive: token passed via --token flag or piped via stdin
   if (opts.token) {
     await saveToken(null, opts.token, opts.name);
@@ -485,7 +654,7 @@ export async function cmdAuthLogin(opts: { token?: string; name?: string } = {})
   console.log("");
   console.log("  1) Slack desktop app - import session token");
   console.log("     Reads the xoxc- token directly from the installed app.");
-  console.log("     Token: all platforms  |  xoxd cookie: macOS only");
+  console.log("     Token: all platforms  |  xoxd cookie: macOS, or Chrome/Firefox on Linux");
   console.log("");
   console.log("  2) Connect existing Slack app  [recommended if you have one]");
   console.log("     Paste a token from an app you already created.");
@@ -503,7 +672,7 @@ export async function cmdAuthLogin(opts: { token?: string; name?: string } = {})
     console.log("");
 
     if (choice === "1") {
-      await importFromDesktop(rl);
+      await importFromDesktop(rl, opts.yes ?? false);
     } else if (choice === "2") {
       await loginExisting(rl);
     } else if (choice === "3") {