slack-term 1.30.2 → 1.31.1

package/package.json

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

package/ts/ask.ts

@@ -101,8 +101,34 @@ export function isInvalidNotice(line: string | undefined): boolean {
 export const ASK_RESOLVED_MARKER = "white_check_mark";
 export const ASK_RESOLVED_PREFIX = `:${ASK_RESOLVED_MARKER}: `;
 
+/** How a keycap is WRITTEN into the body, and how it is read back.
+ *
+ *  Slack NORMALISES a unicode keycap in the stored `text`: post `1️⃣` and
+ *  `conversations.history` returns `:one:`. So a body built with glyphs never
+ *  reads back as what was sent, and `--waitFor` cannot recognise its own
+ *  question. `poll` already handled this; `ask` did not, which made every
+ *  pill-answered question uncollectable (reported from real use 2026-08-31:
+ *  four questions answered, nothing collected for ~20 minutes).
+ *
+ *  Both spellings are accepted on the way in: the shortcode is what Slack
+ *  stores, and the glyph is what a body hand-edited in the Slack UI can be. */
+function askStripPill(line: string, i: number): string | null {
+  const k = ASK_KEYCAPS[i]!;
+  for (const pre of [`:${k.name}:`, k.glyph]) {
+    if (line.startsWith(`${pre} `)) return line.slice(pre.length + 1);
+    if (line === pre) return "";
+  }
+  return null;
+}
+
+/** True if the line opens with ANY keycap — used only to find where the choice
+ *  block starts; WHICH keycap it is gets checked afterwards, in order. */
+function askIsPillLine(line: string): boolean {
+  return ASK_KEYCAPS.some((_k, i) => askStripPill(line, i) !== null);
+}
+
 /** One line, always: newlines inside a choice would break the line-based body. */
-function askFlatten(s: string): string {
+export function askFlatten(s: string): string {
   return s.replace(/\s*\n\s*/g, " ");
 }
 
@@ -154,6 +180,29 @@ export type AskParsed =
  *  by a loose heuristic: it is the one part of the body this command wrote
  *  verbatim, so matching it exactly is what keeps an unrelated message from
  *  being polled as if it were an ask. */
+/** Why `askParseMessage` rejected a body, in the reader's terms.
+ *
+ *  The single generic "this is not an ask" line sent a real user re-checking
+ *  permalinks that were fine, and cost ~20 minutes while pressed answers went
+ *  uncollected (2026-08-31). A rejection has to say WHICH check failed, because
+ *  the three causes have completely different fixes: wrong link, a body someone
+ *  edited, or a bug here. */
+export function askExplainReject(text: string): string {
+  if (!text.trim()) return "本文が空です (bot 投稿や添付のみのメッセージかもしれません)";
+  const lines = text.split("\n");
+  const last = lines[lines.length - 1] ?? "";
+  if (text.startsWith(ASK_RESOLVED_PREFIX)) {
+    return "回答済みマーク付きですが、引用された回答本文が見つかりません";
+  }
+  if (!/_$/.test(last)) {
+    return "末尾が `ask` の案内文ではありません — このメッセージは `slack ask` で投稿されたものではないか、本文が編集されています";
+  }
+  if (!lines[0]!.startsWith(ASK_MARKER_PREFIX) && !lines[0]!.startsWith("*")) {
+    return "先頭が質問文 (太字) ではありません — 本文が編集されている可能性があります";
+  }
+  return "選択肢の並びを読み取れません — 番号が 1 から連番になっていないか、本文が編集されています";
+}
+
 export function askParseMessage(text: string): AskParsed {
   const lines = text.split("\n");
 
@@ -221,7 +270,7 @@ export function askParseMessage(text: string): AskParsed {
     const raw: string[] = [];
     while (i >= 0) {
       const line = lines[i]!;
-      if (!ASK_KEYCAPS.some((k) => line.startsWith(`${k.glyph} `) || line === k.glyph)) break;
+      if (!askIsPillLine(line)) break;
       raw.unshift(line);
       i--;
     }
@@ -231,9 +280,9 @@ export function askParseMessage(text: string): AskParsed {
     // block starting at 2️⃣ would have it waiting on a pill nobody can press.
     if (!raw.length || raw.length > ASK_MAX_REACTION_CHOICES) return { kind: "other" };
     for (let k = 0; k < raw.length; k++) {
-      const glyph = ASK_KEYCAPS[k]!.glyph;
-      if (!(raw[k]!.startsWith(`${glyph} `) || raw[k] === glyph)) return { kind: "other" };
-      reactable.push(raw[k]!.slice(glyph.length + 1));
+      const rest = askStripPill(raw[k]!, k);
+      if (rest === null) return { kind: "other" };
+      reactable.push(rest);
     }
     if (lines[i] !== "") return { kind: "other" };
     if (i < end + 1) return { kind: "other" };

package/ts/cli.ts

@@ -21,6 +21,8 @@ import {
   askBuildText,
   askBuildResolvedText,
   askParseMessage,
+  askExplainReject,
+  askFlatten,
   applyInvalidNotice,
   readInvalidNotice,
   type AskFound,
@@ -32,6 +34,7 @@ import {
   POLL_MAX_CHOICES,
   pollBuildText,
   pollBuildClosedText,
+  pollFlatten,
   pollParseMessage,
   pollTally,
 } from "./poll.ts";
@@ -95,6 +98,7 @@ import {
   type ProgressState,
 } from "./todo.ts";
 import { setCacheEnabled } from "./cache.ts";
+import { unescapeArg } from "./escapes.ts";
 import { dayLabel, encodeMentions, encodeMentionsDetailed, findUntaggedMentions, formatYmdHm, mentionWarnings, resolveDateMarkup, resolveMentions, type MentionEncodeResult } from "./format.ts";
 import { quietHoursNotice } from "./quietHours.ts";
 
@@ -292,6 +296,17 @@ function slimMsg(m: Record<string, Json>): Record<string, Json> {
     // Thread stats, present only on thread parents. Without these a caller
     // reading top-level history cannot tell a post with replies from one
     // without, and silently misses everything said inside the thread.
+    // Reactions, when the message carries any. `ask` and `poll` record ANSWERS
+    // as reactions, so omitting them made `--json` useless as the fallback
+    // people reach for when a poller fails — the pressed pills were right there
+    // in the API response and the CLI dropped them (reported 2026-08-31).
+    ...(Array.isArray(m.reactions) && m.reactions.length
+      ? { reactions: asArray(m.reactions).map(asRecord).map((r) => ({
+          name: r.name ?? null,
+          count: r.count ?? null,
+          users: Array.isArray(r.users) ? r.users : [],
+        })) }
+      : {}),
     ...(m.reply_count !== undefined ? { reply_count: m.reply_count } : {}),
     ...(m.reply_users_count !== undefined ? { reply_users_count: m.reply_users_count } : {}),
     ...(m.latest_reply !== undefined ? { latest_reply: m.latest_reply } : {}),
@@ -1351,10 +1366,15 @@ async function cmdSend(token: string, args: SendArgs): Promise<void> {
   // Convert @handle / @名前 tokens to <@USERID> before hashing/sending so the
   // safety gate covers exactly what will be posted. Unresolved tokens stay as
   // text. The detailed report drives the confirm-gate mention preview below.
-  let message = args.message;
+  // Escapes first, before mentions and before the safety hash: the hash has to
+  // cover the text that will actually be POSTED, and the gate preview has to
+  // show the real line breaks so "how many lines is this?" is answered by
+  // looking rather than by guessing.
+  const rawMessage = unescapeArg(args.message);
+  let message = rawMessage;
   let mentionReport: MentionEncodeResult | null = null;
   if (args.mentions) {
-    mentionReport = await encodeMentionsDetailed(args.mentionToken ?? token, args.message, channelId, args.mentionCookie);
+    mentionReport = await encodeMentionsDetailed(args.mentionToken ?? token, rawMessage, channelId, args.mentionCookie);
     message = mentionReport.text;
     // Prominent, always-visible warning for any @token that will NOT notify —
     // so a mistyped or unresolved name (esp. a Japanese display name) is caught
@@ -1979,8 +1999,13 @@ async function cmdAsk(token: string, args: AskArgs): Promise<void> {
   // was never theirs to decide. So the audience is taken from the @tags in the
   // text — the same names the reader sees — and an untargeted ask is refused
   // outright rather than defaulted to "whoever gets there first".
-  const qEnc = askEncodeBroadcasts(args.question);
-  const bEnc = askEncodeBroadcasts(args.body ?? "");
+  // Unescaped BEFORE broadcast/mention encoding and before the body is built,
+  // which is what makes it work for choices too: `askBuildText` flattens a
+  // choice's newlines to spaces (a newline there would split the pill into a
+  // line the parser cannot read back), so unescaping afterwards would be a
+  // no-op that silently did nothing.
+  const qEnc = askEncodeBroadcasts(unescapeArg(args.question));
+  const bEnc = askEncodeBroadcasts(unescapeArg(args.body ?? ""));
   const broadcastKinds = new Set([...qEnc.kinds, ...bEnc.kinds]);
   const mentionToken = args.mentionToken ?? token;
   const qRep = await encodeMentionsDetailed(mentionToken, qEnc.text, channelId, args.mentionCookie);
@@ -2027,8 +2052,13 @@ async function cmdAsk(token: string, args: AskArgs): Promise<void> {
       .join(", ");
   }
 
-  const reactable = args.choices.slice(0, ASK_MAX_REACTION_CHOICES);
-  const overflow = args.choices.slice(ASK_MAX_REACTION_CHOICES);
+  // Choices too: a `\n` a caller put in a pill label is far more likely to be a
+  // typo than intent (the label is flattened to one line either way), but
+  // leaving it as the two characters `\` `n` in a button someone has to read is
+  // worse than turning it into the space it becomes.
+  const escChoices = args.choices.map(unescapeArg);
+  const reactable = escChoices.slice(0, ASK_MAX_REACTION_CHOICES);
+  const overflow = escChoices.slice(ASK_MAX_REACTION_CHOICES);
 
   // Where free-text answers may come from. A 1:1 DM carries no unrelated
   // traffic, so a plain reply there is an answer. A channel does, so only
@@ -2067,8 +2097,11 @@ async function cmdAsk(token: string, args: AskArgs): Promise<void> {
     const dest = await destLabel(token, channelId, ref, cookie);
     const choiceLines = reactable.length
       ? [`--- Choices (seeded as reactions) ------------`,
-         ...reactable.map((s, i) => `  ${ASK_KEYCAPS[i]!.glyph} ${s}`),
-         ...overflow.map((s, i) => `  (${i + 11}) ${s} — text answer only`)]
+         // Flattened here for the same reason the body is: the pill WILL be one
+         // line, so a preview showing two would be previewing something that
+         // never gets posted.
+         ...reactable.map((s, i) => `  ${ASK_KEYCAPS[i]!.glyph} ${askFlatten(s)}`),
+         ...overflow.map((s, i) => `  (${i + 11}) ${askFlatten(s)} — text answer only`)]
       : [`--- Choices ----------------------------------`, `  (none — free-text reply)`];
     requireCode(args.code, code, [
       `--- Last message in channel ------------------`,
@@ -2214,8 +2247,12 @@ async function cmdAskWaitFor(token: string, args: { link: string; timeout: numbe
   const parsed = askParseMessage(text);
   if (parsed.kind === "other") {
     console.error(
-      `Error: これは \`slack ask\` の質問ではありません (回答の読み取り方が分かりません)。\n` +
-      `  ${stripTerminalControls(args.link)}`,
+      `Error: これは \`slack ask\` の質問として読み取れません。\n` +
+      `  理由: ${askExplainReject(text)}\n` +
+      `  ${stripTerminalControls(args.link)}\n` +
+      // The pills are still readable by hand, so a failure here is not a dead
+      // end — say so, because the reported cost was not knowing that.
+      `  (押されたリアクションは残っています: slack read '${stripTerminalControls(args.link)}' で確認できます)`,
     );
     process.exit(ASK_EXIT_ERROR);
   }
@@ -2347,8 +2384,13 @@ async function cmdPoll(token: string, args: PollArgs): Promise<void> {
   // something, so it matters whose it is. A poll reports a distribution: an
   // extra voter changes the numbers, never the outcome's legitimacy. Tags are
   // still encoded so a poll CAN be pointed at people; they just are not required.
-  const qEnc = askEncodeBroadcasts(args.question);
-  const bEnc = askEncodeBroadcasts(args.body ?? "");
+  // Unescaped BEFORE broadcast/mention encoding and before the body is built,
+  // which is what makes it work for choices too: `askBuildText` flattens a
+  // choice's newlines to spaces (a newline there would split the pill into a
+  // line the parser cannot read back), so unescaping afterwards would be a
+  // no-op that silently did nothing.
+  const qEnc = askEncodeBroadcasts(unescapeArg(args.question));
+  const bEnc = askEncodeBroadcasts(unescapeArg(args.body ?? ""));
   const mentionToken = args.mentionToken ?? token;
   const qRep = await encodeMentionsDetailed(mentionToken, qEnc.text, channelId, args.mentionCookie);
   const bRep = bEnc.text
@@ -2360,7 +2402,7 @@ async function cmdPoll(token: string, args: PollArgs): Promise<void> {
     console.error(`⚠ ${stripTerminalControls(line)}`);
   }
 
-  const choices = args.choices;
+  const choices = args.choices.map(unescapeArg);
   const multi = !!args.multi;
   const until = args.until ?? "";
   const message = pollBuildText(question, body, choices, { multi, deadline: until });
@@ -2390,7 +2432,8 @@ async function cmdPoll(token: string, args: PollArgs): Promise<void> {
       `--- Last message in channel ------------------`,
       `  ${lastUser}: ${lastText.split("\n")[0]?.slice(0, 100) ?? "(empty)"}`,
       `--- Ballot (seeded as reactions) -------------`,
-      ...choices.map((s, i) => `  ${POLL_KEYCAPS[i]!.glyph} ${s}`),
+      // As posted: one line per pill (see the ask gate).
+      ...choices.map((s, i) => `  ${POLL_KEYCAPS[i]!.glyph} ${pollFlatten(s)}`),
       `--- Posting ----------------------------------`,
       fromLine(self, { asBot: args.asBot }),
       `  → ${dest}${threadTs ? " — THREAD REPLY" : " — NEW top-level message"}`,

package/ts/escapes.ts

@@ -0,0 +1,48 @@
+// Turning a literal `\n` in an argument into a real newline.
+//
+// WHY this exists at all: this CLI is driven by agents at least as often as by
+// people, and an agent composing a message emits `\n` the way it would in JSON —
+// it has no shell to interpret it. A person typing into a shell can produce a
+// real newline ($'a\nb', or just quoting across lines); an agent building an
+// argv array cannot. Without this, every multi-line message an agent sends
+// arrives as one line with `\n` printed in it.
+//
+// WHY `¥n` too: on a Japanese keyboard the ¥ key produces U+00A5 YEN SIGN, not
+// U+005C REVERSE SOLIDUS — they are different characters that merely LOOK
+// interchangeable, a holdover from Shift-JIS where 0x5C rendered as ¥. Someone
+// intending an escape reliably types the one that does nothing. Supporting it
+// costs one character in a regex and removes a whole class of "why is my
+// message on one line" confusion.
+//
+// The full-width ￥ (U+FFE5) is deliberately NOT accepted: it is a genuine
+// currency glyph that no keyboard produces where a backslash is meant.
+
+/** `\` U+005C, `¥` U+00A5. Not `￥` U+FFE5 — see above. */
+const ESCAPE_LEAD = "\\\\\u00A5";
+
+/** Interpret `\n`, `\t` and `\\` (and their ¥ spellings) in text the user
+ *  supplied as a command-line argument.
+ *
+ *  Consumes the lead character in ALL cases, which is what makes `\\n` an
+ *  escape hatch for a literal backslash-n rather than a special case: the pair
+ *  `\\` collapses to one `\`, and the following `n` is then ordinary text.
+ *  A lead followed by anything else is left alone, so `C:\path` and `¥1000`
+ *  pass through untouched — the latter matters, because a yen sign in this
+ *  workspace is overwhelmingly a price, not an escape. */
+export function unescapeArg(s: string): string {
+  return s.replace(new RegExp(`[${ESCAPE_LEAD}](.)`, "gs"), (whole, next: string) => {
+    switch (next) {
+      case "n": return "\n";
+      case "t": return "\t";
+      case "\\": case "\u00A5": return next === "\u00A5" ? "\u00A5" : "\\";
+      default: return whole;
+    }
+  });
+}
+
+/** True if `unescapeArg` would change this string — i.e. it carries an escape
+ *  the sender probably meant. Used to decide whether the confirm gate needs to
+ *  say so out loud. */
+export function hasEscapes(s: string): boolean {
+  return unescapeArg(s) !== s;
+}

package/ts/poll.ts

@@ -71,7 +71,7 @@ function pollIsPillLine(line: string): boolean {
 
 /** One line, always: a newline inside a choice would split it into a line the
  *  parser cannot tell from body text. */
-function pollFlatten(s: string): string {
+export function pollFlatten(s: string): string {
   return s.replace(/\s*\n\s*/g, " ");
 }