slack-term 1.31.3 → 1.31.5

package/package.json

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

package/ts/cli.ts

@@ -38,6 +38,7 @@ import {
   pollParseMessage,
   pollTally,
 } from "./poll.ts";
+import { seedReactionsInOrder } from "./reactionSeed.ts";
 import {
   authTest,
   authScopes,
@@ -2133,25 +2134,21 @@ async function cmdAsk(token: string, args: AskArgs): Promise<void> {
   // NOTE the colons: the modifier's argument is itself colon-wrapped, and the
   // bare `has:question` form does NOT error — it silently degrades to a
   // full-text search and returns plausible-looking counts. See ts/todo.ts.
-  try {
-    await reactionAdd(token, channelId, ts, ASK_MARKER, cookie);
-  } catch (e: unknown) {
-    // Cosmetic + searchability, not correctness: the body still identifies it.
-    console.error(`  (marker ${ASK_MARKER} を付けられませんでした: ${e instanceof Error ? e.message : String(e)})`);
-  }
-
-  // Seeded one at a time and in order: Slack keeps reactions in the order they
-  // were added, so sequential adds are what make the pills read 1,2,3 rather
-  // than shuffled. A parallel add is not an optimization here, it is a bug.
-  for (let i = 0; i < reactable.length; i++) {
-    try {
-      await reactionAdd(token, channelId, ts, ASK_KEYCAPS[i]!.name, cookie);
-    } catch (e: unknown) {
-      // A missing seed only costs the answerer a trip to the emoji picker, so
-      // warn and keep going rather than abandon a question already posted.
-      console.error(`  (リアクション ${ASK_KEYCAPS[i]!.name} を付けられませんでした: ${e instanceof Error ? e.message : String(e)})`);
-    }
-  }
+  // Marker first, then 1,2,3 — and spaced out. Sequential awaits alone are NOT
+  // enough: measured on two real questions from the same build, one came back
+  // `two|one|question|three`. See ts/reactionSeed.ts for the evidence and for
+  // SLACK_REACTION_SEED_GAP_MS.
+  await seedReactionsInOrder(
+    [ASK_MARKER, ...reactable.map((_, i) => ASK_KEYCAPS[i]!.name)],
+    (name) => reactionAdd(token, channelId, ts, name, cookie),
+    (name, e) => {
+      const why = e instanceof Error ? e.message : String(e);
+      // The marker is cosmetic + searchability; a keycap only costs the
+      // answerer a trip to the emoji picker. Neither abandons a posted question.
+      if (name === ASK_MARKER) console.error(`  (marker ${name} を付けられませんでした: ${why})`);
+      else console.error(`  (リアクション ${name} を付けられませんでした: ${why})`);
+    },
+  );
 
   let permalink = "";
   try {
@@ -2453,24 +2450,19 @@ async function cmdPoll(token: string, args: PollArgs): Promise<void> {
   // `has::ballot_box_with_ballot:` list every poll. An unrelated reaction on the message is
   // already ignored by the tally (it counts keycap names only), so this costs
   // the ballot nothing.
-  try {
-    await reactionAdd(token, channelId, ts, POLL_MARKER, cookie);
-  } catch (e: unknown) {
-    console.error(`  (marker ${POLL_MARKER} を付けられませんでした: ${e instanceof Error ? e.message : String(e)})`);
-  }
-
-  // Sequential and in order: Slack keeps reactions in the order they were added,
-  // so this is what makes the pills read 1,2,3 rather than shuffled. Parallel
-  // adds are not an optimization here, they are a bug.
-  for (let i = 0; i < choices.length; i++) {
-    try {
-      await reactionAdd(token, channelId, ts, POLL_KEYCAPS[i]!.name, cookie);
-    } catch (e: unknown) {
+  // Marker first, then 1,2,3 — and spaced out, for the reason `ask` documents
+  // at its own seeding call and ts/reactionSeed.ts documents in full.
+  await seedReactionsInOrder(
+    [POLL_MARKER, ...choices.map((_, i) => POLL_KEYCAPS[i]!.name)],
+    (name) => reactionAdd(token, channelId, ts, name, cookie),
+    (name, e) => {
+      const why = e instanceof Error ? e.message : String(e);
       // A missing seed costs a voter a trip to the emoji picker; it does not
       // invalidate a poll that is already posted.
-      console.error(`  (リアクション ${POLL_KEYCAPS[i]!.name} を付けられませんでした: ${e instanceof Error ? e.message : String(e)})`);
-    }
-  }
+      if (name === POLL_MARKER) console.error(`  (marker ${name} を付けられませんでした: ${why})`);
+      else console.error(`  (リアクション ${name} を付けられませんでした: ${why})`);
+    },
+  );
 
   let permalink = "";
   try {

package/ts/reactionSeed.ts

@@ -0,0 +1,82 @@
+// Seeding the answer pills on an `ask` / `poll` message, in order.
+//
+// MEASURED, 2026-08-31, two real questions posted five seconds apart by the
+// SAME build:
+//
+//   07:42:31   two | one | question | three          ← shuffled
+//   07:42:36   question | one | two | three | four   ← correct
+//
+// The adds have been sequential (`await` inside a `for`) since the first commit
+// of `ask`, and there has never been a `Promise.all` here — so the reordering
+// happens on Slack's side, not ours. The comments that used to sit at both call
+// sites ("Slack keeps reactions in the order they were added, so sequential
+// adds are what make the pills read 1,2,3") asserted a guarantee that does not
+// exist, and the shuffled message above is the counter-example.
+//
+// The working theory is that the display order comes from a reaction timestamp
+// stored at second resolution: adds landing inside one second are tie-broken
+// arbitrarily, while adds that straddle a boundary keep their order. That fits
+// both samples — the slower message came out right — and it is why the gap
+// below is just over a second rather than a token 100ms.
+//
+// It is a THEORY. Confirming it needs `reactions.add` against a real workspace,
+// which this repo's QA rule forbids (see CLAUDE.md: read-only only), and Slack
+// exposes no timestamp on a reaction to measure it from. So the gap is tunable
+// without a code change: set SLACK_REACTION_SEED_GAP_MS, and 0 restores the old
+// back-to-back behaviour.
+
+/** Just over one second, so two consecutive seeds cannot share a second. */
+export const DEFAULT_SEED_GAP_MS = 1100;
+
+/** True under vitest or `bun test`. Same check as ts/todo.ts, and for the same
+ *  reason: a seam that only tests replace gets forgotten, and then the suite
+ *  waits real seconds per seeded reaction.
+ *
+ *  It takes `env` so it can be tested by VALUE. Testing it by deleting
+ *  NODE_ENV/VITEST from `process.env` and putting them back is what a first
+ *  version did, and under `bun test --parallel=2` the deletion was visible to
+ *  every CLI subprocess another test file spawned in that window: the suite
+ *  went from 45s to 169s because those children then waited the real gap. */
+export function isTestEnv(env: NodeJS.ProcessEnv = process.env): boolean {
+  return !!env.VITEST || env.NODE_ENV === "test" || !!env.BUN_TEST;
+}
+
+export const _internals = {
+  isTestEnv: (): boolean => isTestEnv(),
+  sleep: (ms: number): Promise<void> =>
+    _internals.isTestEnv() ? Promise.resolve() : new Promise((res) => setTimeout(res, ms)),
+};
+
+/** The configured gap. Invalid values fall back to the default rather than
+ *  disabling the gap silently — a typo must not quietly restore the bug. */
+export function seedGapMs(env: NodeJS.ProcessEnv = process.env): number {
+  const raw = env.SLACK_REACTION_SEED_GAP_MS;
+  if (raw === undefined || raw === "") return DEFAULT_SEED_GAP_MS;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n < 0) return DEFAULT_SEED_GAP_MS;
+  return n;
+}
+
+/** Add `names` one at a time, in order, pausing between them.
+ *
+ *  A failed seed is reported and skipped, never fatal: the message is already
+ *  posted, and a missing pill costs the answerer a trip to the emoji picker.
+ *  The pause is skipped after the last add, and after one that failed — there
+ *  is nothing left to keep in order. */
+export async function seedReactionsInOrder(
+  names: readonly string[],
+  add: (name: string) => Promise<void>,
+  onError: (name: string, e: unknown) => void,
+  gapMs: number = seedGapMs(),
+): Promise<void> {
+  for (let i = 0; i < names.length; i++) {
+    let ok = true;
+    try {
+      await add(names[i]!);
+    } catch (e: unknown) {
+      ok = false;
+      onError(names[i]!, e);
+    }
+    if (ok && gapMs > 0 && i < names.length - 1) await _internals.sleep(gapMs);
+  }
+}