slack-term 1.32.2 → 1.32.4

package/package.json

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

package/ts/cli.ts

@@ -8,6 +8,7 @@ import { join } from "node:path";
 
 import yargs, { type Options } from "yargs";
 import { hideBin } from "yargs/helpers";
+import { guardUrlBoundaries } from "./urlGuard.ts";
 import { listProfiles, removeProfile, resolveBotToken, resolveCookie, resolveToken, useProfile, type Profile } from "./profiles.ts";
 import { diagnoseBotMessaging, formatDiagnosis } from "./botdoctor.ts";
 import { cmdAuthLogin, cmdAuthChrome, cmdAuthFirefox, cmdAuthToken, cmdAuthApp } from "./auth.ts";
@@ -1160,6 +1161,7 @@ function sumCounts(m: Map<string, number>): number {
 
 // --- edit ---
 interface EditArgs {
+  allowUrlAdjacent?: boolean;
   target: string;
   newText: string;
   code?: string;
@@ -1168,7 +1170,62 @@ interface EditArgs {
   // Session cookie (xoxd) for `token` — required for an xoxc- desktop session
   // token to be accepted by the public Slack API at all.
   cookie?: string;
+  asBot?: boolean;
+  /** The USER token, kept for mention resolution when the edit itself runs as
+   *  the bot. A bot token has no users:read, and an unresolved @handle degrades
+   *  to plain text SILENTLY — which is the precise failure `edit` exists to
+   *  correct, so re-introducing it here would be circular. Same split as
+   *  `send --as-bot`. */
+  mentionToken?: string;
+  mentionCookie?: string;
+}
+/** The bot token, plus the bot↔user DM when the target names an `@handle`.
+ *
+ *  Both halves are load-bearing. A bot token has no `users:read`, so resolving
+ *  `@bob` with it does not merely pick the wrong channel — it fails outright with
+ *  `missing_scope`, before the confirm gate is ever printed. And even where it
+ *  could resolve, a BOT-authored DM lives in the bot's conversation with that
+ *  person, not in the user's: looking the handle up as the user and opening the
+ *  DM as the bot is the only combination that names the message being corrected.
+ *  Same split `send --as-bot` makes.
+ *
+ *  Found by the cross-vendor review of this change, which also named why the
+ *  first round of tests missed it: they all targeted a permalink, and
+ *  `resolveChannel` parses those locally without touching the API. */
+async function asBotTarget(
+  target: string,
+  userToken: string,
+  userCookie: string | undefined,
+  /** Already known from `--channel-id`. Passed in so the DM lookup is SKIPPED
+   *  rather than performed and discarded: `conversations.open` is a side effect,
+   *  and opening a DM the caller did not ask for is not undone by ignoring the
+   *  result. */
+  knownChannelId?: string,
+): Promise<{ botToken: string; channelId?: string }> {
+  const botToken = resolveBotToken();
+  if (!botToken) {
+    console.error(
+      "Error: --as-bot needs a bot token, but no xoxb- token was found.\n" +
+      "  Set SLACK_BOT_TOKEN=xoxb-... in ~/.config/slack-cli/.env (or your shell).",
+    );
+    process.exit(1);
+  }
+  if (knownChannelId) return { botToken };
+  const { ref } = splitRefTs(target);
+  if (!ref.startsWith("@")) return { botToken };
+  try {
+    const userId = await resolveUserId(userToken, ref, userCookie);
+    return { botToken, channelId: await openDm(botToken, userId) };
+  } catch (e: unknown) {
+    console.error(
+      `Error: could not resolve ${stripTerminalControls(ref)} to the bot's DM.\n` +
+      `  ${e instanceof Error ? e.message : String(e)}\n` +
+      `  Tip: pass the message permalink, or --channel-id <D…>, to skip the lookup.`,
+    );
+    process.exit(1);
+  }
 }
+
 async function cmdEdit(token: string, args: EditArgs): Promise<void> {
   const getSelf = selfLookup(token, args.cookie);
   const { ref, ts } = splitRefTs(args.target);
@@ -1192,10 +1249,13 @@ async function cmdEdit(token: string, args: EditArgs): Promise<void> {
   const originalText = typeof original.text === "string" ? original.text : "";
 
   // Convert @handle → <@USERID> before hashing/editing (unresolved stay as text).
+  const mentionCookie = args.mentionCookie ?? args.cookie;
   const newText = args.mentions
-    ? await encodeMentions(token, args.newText, channelId, args.cookie ? { cookie: args.cookie } : {})
+    ? await encodeMentions(args.mentionToken ?? token, args.newText, channelId, mentionCookie ? { cookie: mentionCookie } : {})
     : args.newText;
 
+  guardUrlBoundaries(newText, args.allowUrlAdjacent);
+
   // Identity is part of the hash for the same reason it is on `send`: a code
   // minted while previewing as one identity must not confirm the write as
   // another (Slack only lets you edit your own messages, so a silent profile
@@ -1205,7 +1265,7 @@ async function cmdEdit(token: string, args: EditArgs): Promise<void> {
   if (args.code !== code) {
     requireCode(args.code, code, [
       `--- Editing as -------------------------------`,
-      fromLine(self),
+      fromLine(self, { asBot: args.asBot }),
       `--- Original message -------------------------`,
       ...originalText.split("\n").map((l) => `  ${l}`),
       `--- Replacing with ---------------------------`,
@@ -1224,6 +1284,7 @@ interface DeleteArgs {
   code?: string;
   channelId?: string;
   cookie?: string;
+  asBot?: boolean;
 }
 async function cmdDelete(token: string, args: DeleteArgs): Promise<void> {
   const getSelf = selfLookup(token, args.cookie);
@@ -1255,7 +1316,7 @@ async function cmdDelete(token: string, args: DeleteArgs): Promise<void> {
     const dest = await destLabel(token, channelId, ref, args.cookie);
     requireCode(args.code, code, [
       `--- Deleting message -------------------------`,
-      fromLine(self),
+      fromLine(self, { asBot: args.asBot }),
       `  → ${dest} at ${slackTsToIso(ts)}`,
       ...originalText.split("\n").map((l) => `  ${l}`),
       `---------------------------------------------`,
@@ -1301,6 +1362,7 @@ async function cmdReact(token: string, args: ReactArgs): Promise<void> {
 
 // --- send ---
 interface SendArgs {
+  allowUrlAdjacent?: boolean;
   target: string;
   message: string;
   code?: string;
@@ -1386,6 +1448,7 @@ async function cmdSend(token: string, args: SendArgs): Promise<void> {
   // show the real line breaks so "how many lines is this?" is answered by
   // looking rather than by guessing.
   const rawMessage = unescapeArg(args.message);
+  guardUrlBoundaries(rawMessage, args.allowUrlAdjacent);
   let message = rawMessage;
   let mentionReport: MentionEncodeResult | null = null;
   if (args.mentions) {
@@ -1663,6 +1726,7 @@ const ASK_MAX_CONSECUTIVE_ERRORS = 8;
 
 
 interface AskArgs {
+  allowUrlAdjacent?: boolean;
   target: string;
   question: string;
   choices: string[];
@@ -2162,6 +2226,7 @@ async function cmdAsk(token: string, args: AskArgs): Promise<void> {
   // INTO a thread is thread-scoped for the same reason.
   const threadOnly = !channelId.startsWith("D") || !!threadTs;
   const message = askBuildText(question, body, reactable, overflow, threadOnly);
+  guardUrlBoundaries(message, args.allowUrlAdjacent);
 
   // Preview the destination's last message, exactly as `send` does — the gate's
   // job is to make you look at where this is going before it goes. Fail-soft:
@@ -3564,13 +3629,14 @@ async function main(): Promise<void> {
         .positional("target", { type: "string", demandOption: true, describe: "#chan, @user, #chan:thread_ts, or permalink (a message permalink replies in its thread)" })
         .positional("message", { type: "string", demandOption: true })
         .option("code", { type: "string", describe: "Safety hash to confirm send" })
+        .option("allow-url-adjacent", { type: "boolean", default: false, describe: "Warn instead of refusing ambiguous bare URL boundaries" })
         .option("channel-id", { type: "string", describe: "Raw channel ID" })
         .option("user-id", { type: "string", describe: "Raw user ID (opens DM)" })
         .option("as-bot", { type: "boolean", default: false, describe: "Send via the bot token (xoxb / SLACK_BOT_TOKEN) so a DM notifies the recipient and can be two-way" })
         .option("broadcast", { type: "boolean", default: false, describe: "Also send to channel: broadcast a threaded reply back to the channel (Slack's \"Also send to #channel\" checkbox). Only effective with a thread target." })
         .option("mentions", { type: "boolean", default: true, describe: "Convert @handle tokens to real <@USERID> mentions (on by default; resolves via users.list, then channel members for Slack Connect guests). Unresolved handles stay as plain text. The confirm preview shows the converted message before sending. Disable with --no-mentions for literal @text." }),
       async (argv) => {
-        const args: SendArgs = { target: argv.target!, message: argv.message! };
+        const args: SendArgs = { target: argv.target!, message: argv.message!, allowUrlAdjacent: argv["allow-url-adjacent"] };
         if (argv.code) args.code = argv.code;
         if (argv["channel-id"]) args.channelId = argv["channel-id"];
         if (argv["user-id"]) args.userId = argv["user-id"];
@@ -3642,6 +3708,7 @@ async function main(): Promise<void> {
         .positional("question", { type: "string", describe: "The question. Must @tag whoever may answer (@alice), or the whole channel (@here / @channel / @everyone) — only their answer counts. In a 1:1 DM the other party counts automatically." })
         .positional("choices", { type: "string", array: true, describe: "Up to 10 choices, seeded as 1️⃣..🔟 reactions. Beyond 10 they are listed but answerable only by text. With none, the question asks for a free-text reply." })
         .option("code", { type: "string", describe: "Safety hash to confirm the ask" })
+        .option("allow-url-adjacent", { type: "boolean", default: false, describe: "Warn instead of refusing ambiguous bare URL boundaries" })
         .option("body", { type: "string", describe: "Extra context shown under the question" })
         .option("wait", { type: "boolean", default: false, describe: "Block until answered; print ONLY the answer on stdout. Exit 0 = answered, 2 = nobody replied, 3 = transport failure, 4 = somebody replied but picked none of the choices (stdout empty — do not act on it)." })
         .option("waitFor", { type: "string", describe: "Collect the answer to a question already posted: pass its permalink. Nothing is posted. Same stdout/exit contract as --wait; --timeout 0 checks once and exits 2 if still open." })
@@ -3702,6 +3769,7 @@ async function main(): Promise<void> {
           process.exit(ASK_EXIT_ERROR);
         }
         const args: AskArgs = {
+          allowUrlAdjacent: argv["allow-url-adjacent"],
           target: argv.target!,
           question,
           choices: ((argv.choices as string[] | undefined) ?? []).map((s) => String(s).trim()).filter(Boolean),
@@ -4020,16 +4088,41 @@ async function main(): Promise<void> {
         .positional("target", { type: "string", demandOption: true, describe: "#chan:ts, @user:ts, or permalink" })
         .positional("newText", { type: "string", demandOption: true })
         .option("code", { type: "string", describe: "Safety hash to confirm edit" })
+        .option("allow-url-adjacent", { type: "boolean", default: false, describe: "Warn instead of refusing ambiguous bare URL boundaries" })
         .option("channel-id", { type: "string", describe: "Raw channel ID" })
-        .option("mentions", { type: "boolean", default: true, describe: "Convert @handle tokens in the new text to real <@USERID> mentions (on by default). Unresolved handles stay as plain text. Disable with --no-mentions for literal @text." }),
+        .option("mentions", { type: "boolean", default: true, describe: "Convert @handle tokens in the new text to real <@USERID> mentions (on by default). Unresolved handles stay as plain text. Disable with --no-mentions for literal @text." })
+        .option("as-bot", { type: "boolean", default: false, describe: "Edit as the bot (xoxb / SLACK_BOT_TOKEN). REQUIRED to correct a message the bot posted: Slack only lets a token edit its OWN messages, so a bot-authored message is uneditable by the user token and chat.update returns cant_update_message. Address it by permalink or --channel-id; an @user target resolves against the BOT's DM list, which is where a bot-authored DM actually lives." }),
       async (argv) => {
-        const args: EditArgs = { target: argv.target!, newText: argv.newText! };
+        const args: EditArgs = { target: argv.target!, newText: argv.newText!, allowUrlAdjacent: argv["allow-url-adjacent"] };
         if (argv.code) args.code = argv.code;
         if (argv["channel-id"]) args.channelId = argv["channel-id"];
         if (argv.mentions !== false) args.mentions = true;
-        const cookie = ck(argv as W);
-        if (cookie) args.cookie = cookie;
-        await cmdEdit(tok(argv as W), args);
+        let editToken: string;
+        if (argv["as-bot"]) {
+          // --as-bot is not a switch on chat.update. It selects a DIFFERENT
+          // resolved token, and until now `edit` never wired one — so every
+          // message the bot posted was uncorrectable, and the workaround people
+          // reached for was RESENDING, which this repo's own etiquette forbids.
+          // Bot identity is what makes a DM notify at all, so "uncorrectable"
+          // applied to exactly the messages that matter most.
+          const resolved = await asBotTarget(args.target, tok(argv as W), ck(argv as W), args.channelId);
+          editToken = resolved.botToken;
+          if (resolved.channelId && !args.channelId) args.channelId = resolved.channelId;
+          args.asBot = true;
+          // Mentions still resolve on the USER token: the bot has no users:read,
+          // and a silently unresolved @handle in a CORRECTION is the same defect
+          // twice.
+          args.mentionToken = tok(argv as W);
+          const mc = ck(argv as W);
+          if (mc) args.mentionCookie = mc;
+        } else {
+          editToken = tok(argv as W);
+          // Not set under --as-bot: a bot token needs no session cookie, and
+          // attaching one is how a working call starts failing.
+          const cookie = ck(argv as W);
+          if (cookie) args.cookie = cookie;
+        }
+        await cmdEdit(editToken, args);
       },
     )
     .command(
@@ -4038,14 +4131,28 @@ async function main(): Promise<void> {
       (y) => y
         .positional("target", { type: "string", demandOption: true, describe: "#chan:ts, @user:ts, or permalink" })
         .option("code", { type: "string", describe: "Safety hash to confirm delete" })
-        .option("channel-id", { type: "string", describe: "Raw channel ID" }),
+        .option("channel-id", { type: "string", describe: "Raw channel ID" })
+        .option("as-bot", { type: "boolean", default: false, describe: "Delete as the bot (xoxb / SLACK_BOT_TOKEN). REQUIRED for a message the bot posted: chat.delete refuses another token's message exactly as chat.update does." }),
       async (argv) => {
         const args: DeleteArgs = { target: argv.target! };
         if (argv.code) args.code = argv.code;
         if (argv["channel-id"]) args.channelId = argv["channel-id"];
-        const cookie = ck(argv as W);
-        if (cookie) args.cookie = cookie;
-        await cmdDelete(tok(argv as W), args);
+        let deleteToken: string;
+        if (argv["as-bot"]) {
+          // The SECOND call site of one defect, not a second defect: `delete`
+          // had the identical unconditional `tok(argv)`, and chat.delete refuses
+          // another token's message exactly as chat.update does. Fixing one and
+          // leaving the other is how the next person finds it the hard way.
+          const resolved = await asBotTarget(args.target, tok(argv as W), ck(argv as W), args.channelId);
+          deleteToken = resolved.botToken;
+          if (resolved.channelId && !args.channelId) args.channelId = resolved.channelId;
+          args.asBot = true;
+        } else {
+          deleteToken = tok(argv as W);
+          const cookie = ck(argv as W);
+          if (cookie) args.cookie = cookie;
+        }
+        await cmdDelete(deleteToken, args);
       },
     )
     .command(

package/ts/urlGuard.ts

@@ -0,0 +1,20 @@
+/** Bare Unicode URL text has an ambiguous boundary for Slack's autolinker.
+ * Explicit Slack links delimit the URL, including intentional Unicode paths.
+ * ASCII whitespace (especially newlines) is a safe boundary; Unicode spaces
+ * should be made explicit too. Do not rewrite the message or its newlines. */
+export function adjacentUrls(text: string): string[] {
+  const tokens = text.matchAll(/<https?:\/\/[^\s<>|]+(?:\|[^<>\r\n]*)?>|https?:\/\/[^\t\n\v\f\r <]+/gi);
+  return [...tokens]
+    .map(([token]) => token)
+    .filter((token) => !token.startsWith("<") && (/[^\x00-\x7f]/.test(token) || token.includes(">")));
+}
+
+export function guardUrlBoundaries(text: string, allow = false, warn: (message: string) => void = console.error): void {
+  const urls = adjacentUrls(text);
+  if (!urls.length) return;
+  const message = `Ambiguous URL boundary: ${urls.map((url) => JSON.stringify(url)).join(", ")}. ` +
+    "Put the URL on its own line, or wrap it as <url> / <url|label>. " +
+    "Use --allow-url-adjacent to warn only.";
+  if (!allow) throw new Error(message);
+  warn(`Warning: ${message}`);
+}