slack-term 1.39.1 → 1.40.0

package/package.json

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

package/ts/attachments.ts

@@ -0,0 +1,71 @@
+// Message attachments — forwarded/shared messages and legacy bot attachments.
+//
+// A message forwarded with Slack's "Forward" (or shared via its link) arrives
+// as an ordinary message whose own `text` is only the comment typed with it;
+// the forwarded message itself lives in `attachments[]`, flagged `is_share`
+// (or `is_msg_unfurl` for a pasted message link), carrying the original
+// author, channel, ts, text and permalink (`from_url`). Older shares put the
+// text in `message_blocks[].message` instead, with `fallback` as the summary.
+// Plain link unfurls (`original_url` set) are previews of a web page, not
+// content anyone wrote, so the text view leaves them out.
+
+import type { Json } from "./slack.ts";
+
+const rec = (v: Json | undefined): Record<string, Json> =>
+  v && typeof v === "object" && !Array.isArray(v) ? (v as Record<string, Json>) : {};
+const str = (v: Json | undefined): string => (typeof v === "string" ? v : "");
+
+export type Attachment = {
+  /** A forwarded/shared Slack message (as opposed to a bot or link attachment). */
+  shared: boolean;
+  /** A web-page link preview — omitted from the text view. */
+  unfurl: boolean;
+  author_id: string | null;
+  author_name: string | null;
+  channel_id: string | null;
+  ts: string | null;
+  title: string | null;
+  text: string;
+  permalink: string | null;
+};
+
+// Older shares carry the text only inside message_blocks[].message.text.
+function messageBlocksText(a: Record<string, Json>): string {
+  const blocks = Array.isArray(a.message_blocks) ? a.message_blocks : [];
+  return blocks.map((b) => str(rec(rec(b).message).text)).filter(Boolean).join("\n");
+}
+
+export function parseAttachments(m: Record<string, Json>): Attachment[] {
+  const list = Array.isArray(m.attachments) ? m.attachments : [];
+  return list.map(rec).map((a) => {
+    const shared = a.is_share === true || a.is_msg_unfurl === true || Array.isArray(a.message_blocks);
+    const mb = rec(rec((Array.isArray(a.message_blocks) ? a.message_blocks : [])[0]));
+    return {
+      shared,
+      unfurl: !shared && !!str(a.original_url),
+      author_id: str(a.author_id) || str(rec(mb.message).user) || null,
+      author_name: str(a.author_name) || null,
+      channel_id: str(a.channel_id) || str(mb.channel) || null,
+      ts: str(a.ts) || str(mb.ts) || null,
+      title: str(a.title) || null,
+      text: str(a.text) || messageBlocksText(a) || str(a.pretext) || str(a.fallback),
+      permalink: str(a.from_url) || str(a.title_link) || str(a.original_url) || null,
+    };
+  });
+}
+
+/** The text-view lines for a message's attachments (each starts with "\n   "). */
+export function attachmentLines(atts: Attachment[], tsLabel: (ts: string) => string): string {
+  return atts
+    .filter((a) => !a.unfurl && (a.text || a.title))
+    .map((a) => {
+      const who = a.author_name ?? a.author_id;
+      const head = a.shared
+        ? `↪ shared message${who ? ` from @${who}` : ""}${a.channel_id ? ` in <#${a.channel_id}>` : ""}${a.ts ? ` · ${tsLabel(a.ts)}` : ""}`
+        : `▸ ${a.title ?? "attachment"}`;
+      const lines = a.text ? a.text.replace(/\n+$/, "").split("\n").map((l) => `\n     │ ${l}`).join("") : "";
+      const link = a.permalink ? `\n     ${a.permalink}` : "";
+      return `\n   ${head}${lines}${link}`;
+    })
+    .join("");
+}

package/ts/cli.ts

@@ -50,6 +50,7 @@ import {
   authTestSession,
   conversationInfoSession,
   createChannel,
+  renameChannel,
   inviteToChannel,
   createDraft,
   deleteDraft,
@@ -95,7 +96,9 @@ import {
   userName,
   getPath,
   type Json,
+  savedList,
 } from "./slack.ts";
+import { isDone, messagePermalink, parseSavedItems, sortTodos, TODO_FILTERS, todoStatus, type TodoFilter, type TodoItem } from "./slackTodos.ts";
 import {
   buildTodoQuery,
   loadTodoConfig,
@@ -114,8 +117,10 @@ import {
 } from "./todo.ts";
 import { setCacheEnabled } from "./cache.ts";
 import { escapeArg, unescapeArg } from "./escapes.ts";
+import { attachmentLines, parseAttachments } from "./attachments.ts";
 import { dayLabel, encodeMentions, encodeMentionsDetailed, findUntaggedMentions, formatYmdHm, maskSecrets, mentionWarnings, resolveDateMarkup, resolveMentions, type MentionEncodeResult } from "./format.ts";
 import { quietHoursNotice } from "./quietHours.ts";
+import { installSyncConsole } from "./stdout.ts";
 import { LockBusyError, PINLOG_MARKER, acquireLock, composeHead, formatJst, headUpdatedAt, isPinlogHead, parsePinlogId, pinlogId, stripPinlogFooter } from "./pinlog.ts";
 
 function loadDotenv(path: string): void {
@@ -273,7 +278,12 @@ async function formatMsgLine(
   // top-level history can see there is more to read without opening each ts.
   const replyCount = Number(m.reply_count ?? 0);
   const threadMark = replyCount > 0 ? `  [+${replyCount} ${replyCount === 1 ? "reply" : "replies"}]` : "";
-  const tail = (reactions ? `\n   ${reactions}` : "") + attachTail;
+  // Forwarded/shared messages live in attachments[], not in the message text.
+  const atts = await Promise.all(parseAttachments(m).map(async (a) => ({
+    ...a,
+    text: a.text ? resolveDateMarkup(await resolveMentions(token, a.text, cache, cookie)) : "",
+  })));
+  const tail = (reactions ? `\n   ${reactions}` : "") + attachTail + attachmentLines(atts, slackTsToIso);
   return `${stamp}  ${who}:  ${body}${threadMark}${tail}`;
 }
 
@@ -302,6 +312,7 @@ function slimFiles(m: Record<string, Json>): Record<string, Json>[] {
 // users.list) so callers can resolve mentions without scraping history by hand.
 function slimMsg(m: Record<string, Json>): Record<string, Json> {
   const files = slimFiles(m);
+  const attachments = parseAttachments(m);
   return {
     ts: m.ts ?? null,
     user: m.user ?? null,
@@ -329,6 +340,10 @@ function slimMsg(m: Record<string, Json>): Record<string, Json> {
     // Present only when the message carries attachments, so scripts can reliably
     // detect files without the key adding noise to every plain-text line.
     ...(files.length > 0 ? { files } : {}),
+    // Forwarded/shared messages (and bot attachments): the original author,
+    // channel, ts, text and permalink. The message's own `text` is only the
+    // comment typed with the share.
+    ...(attachments.length > 0 ? { attachments } : {}),
   };
 }
 
@@ -747,6 +762,8 @@ function blocksToText(blocks: Json[]): string {
     if (node && typeof node === "object") {
       const obj = node as Record<string, Json>;
       if (typeof obj.text === "string") { parts.push(obj.text); return; }
+      // A bare `link` element carries only its url — which IS its visible text.
+      if (obj.type === "link" && typeof obj.url === "string") { parts.push(obj.url); return; }
       if (Array.isArray(obj.elements)) walk(obj.elements);
       else if (Array.isArray(obj.content)) walk(obj.content);
     }
@@ -829,6 +846,65 @@ async function cmdDrafts(token: string, cookie?: string, showAll = false): Promi
   }
 }
 
+// --- todos (Slack's To-dos tab) ---
+// Read-only. Pages through saved.list up to `limit` items, then shows each
+// to-do with its due date, where it lives, and the message it points at.
+async function cmdTodos(
+  token: string,
+  cookie: string | undefined,
+  opts: { filter: TodoFilter; limit: number; json: boolean },
+): Promise<void> {
+  const items: TodoItem[] = [];
+  let cursor: string | undefined;
+  do {
+    const resp = asRecord((await savedList(token, { filter: opts.filter, limit: Math.min(opts.limit, 100), cursor }, cookie)) as Json);
+    items.push(...parseSavedItems(resp as Json));
+    const next = asRecord(resp.response_metadata).next_cursor;
+    cursor = typeof next === "string" && next ? next : undefined;
+  } while (cursor && items.length < opts.limit);
+  const shown = sortTodos(items).slice(0, opts.limit);
+
+  if (shown.length === 0) {
+    // --json is JSONL on stdout: an empty list is no lines, the note goes to stderr.
+    (opts.json ? console.error : console.log)(`No ${opts.filter === "todo" ? "to-dos" : `${opts.filter} items`}.`);
+    return;
+  }
+
+  let teamUrl = "";
+  let myUserId = "";
+  try { ({ url: teamUrl, userId: myUserId } = await authScopes(token, cookie)); } catch { /* links degrade to channel:ts */ }
+  const resolveChLabel = await buildChLabelResolver(token, cookie, myUserId);
+  const now = Date.now() / 1000;
+
+  for (const t of shown) {
+    // The message a to-do points at. conversations.replies on its own ts
+    // returns it whether or not it has a thread; a thread reply comes back
+    // inside its thread, so match by ts. Fail-soft: an unreadable message
+    // still lists, with its link.
+    let msg: Record<string, Json> | undefined;
+    if (t.channel && t.ts) {
+      try {
+        const r = asRecord((await replies(token, t.channel, t.ts, 1, cookie)) as Json);
+        msg = asArray(r.messages).map(asRecord).find((m) => m.ts === t.ts);
+      } catch { /* not readable */ }
+    }
+    const link = t.channel && t.ts
+      ? (teamUrl ? messagePermalink(teamUrl, t.channel, t.ts) : `${t.channel}:${t.ts}`)
+      : "";
+    if (opts.json) {
+      console.log(JSON.stringify({ ...t, done: isDone(t), permalink: link, user: msg?.user ?? null, text: msg?.text ?? null }));
+      continue;
+    }
+    const where = t.channel ? await resolveChLabel(t.channel) : `(${t.itemType || "item"})`;
+    const author = typeof msg?.user === "string" ? `@${await userName(token, msg.user, cookie)}: ` : "";
+    const raw = typeof msg?.text === "string" ? msg.text.split("\n")[0] ?? "" : "(message not readable)";
+    const head = raw.length > 100 ? `${raw.slice(0, 100)}…` : raw;
+    console.log(`${todoStatus(t, now, formatYmdHm)}  ${stripTerminalControls(where)}`);
+    console.log(`   ${stripTerminalControls(author + head)}`);
+    if (link) console.log(`   ${link}`);
+  }
+}
+
 // --- drafts get ---
 async function cmdDraftGet(token: string, cookie: string | undefined, draftId: string): Promise<void> {
   const resp = (await listDrafts(token, cookie)) as Record<string, Json>;
@@ -892,6 +968,7 @@ const SCOPE_FOR_METHOD: Record<string, string> = {
   "slackLists.items.update": "lists:write",
   "slackLists.items.list": "lists:read",
   "slackLists.access.set": "lists:write",
+  "conversations.rename": "channels:manage (or groups:write for a private channel)",
   "conversations.replies": "channels:history (or groups:history)",
   "conversations.history": "channels:history (or groups:history)",
 };
@@ -1975,6 +2052,31 @@ async function isSelfDmChannel(
   }
 }
 
+/** Everyone a thread reply notifies: the thread's starter and its repliers.
+ *  From the fetched messages, plus the parent's `reply_users` (Slack's own
+ *  participant list), which still names a replier past the fetched window. */
+function threadParticipants(msgs: Record<string, Json>[]): Set<string> {
+  const out = new Set<string>();
+  for (const m of msgs) {
+    if (typeof m.user === "string") out.add(m.user);
+    if (typeof m.parent_user_id === "string") out.add(m.parent_user_id);
+    for (const u of asArray(m.reply_users)) if (typeof u === "string") out.add(u);
+  }
+  return out;
+}
+
+/** The other member of a 1:1 DM, or undefined for anything else (or an
+ *  unreadable channel). Only asked for `D…` ids, so channel sends pay nothing. */
+async function dmCounterparty(token: string, channelId: string, cookie?: string): Promise<string | undefined> {
+  if (!channelId.startsWith("D")) return undefined;
+  try {
+    const ch = asRecord(asRecord((await conversationInfo(token, channelId, cookie)) as Json).channel);
+    return ch.is_im === true && typeof ch.user === "string" ? ch.user : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 async function cmdSend(token: string, args: SendArgs): Promise<void> {
   const { ref, threadTs } = parseTargetThread(args.target);
   const cookie = args.cookie;
@@ -2023,19 +2125,6 @@ async function cmdSend(token: string, args: SendArgs): Promise<void> {
     for (const line of mentionWarnings(mentionReport.unresolved)) console.error(`⚠ ${stripTerminalControls(line)}`);
   }
 
-  // Warn-only lint: names written as plain text (no leading @) that map to a
-  // known workspace member but aren't <@USERID>-tagged — they won't be notified.
-  // Never blocks; fail-soft (a missing users:read scope or API error must not
-  // stall a send).
-  try {
-    for (const u of await findUntaggedMentions(args.mentionToken ?? token, message, args.mentionCookie)) {
-      // u.surface / u.display carry Slack-controlled display text — strip control chars.
-      console.error(`⚠ possible untagged mention: ${stripTerminalControls(u.surface)} — @${stripTerminalControls(u.display)} won't be notified (did you mean <@${u.userId}>?)`);
-    }
-  } catch {
-    // best-effort; ignore
-  }
-
   // Confirm-gate mention preview: exactly who resolves (→ notified) and who
   // stays literal. Inserted into the dry-run block so the sender eyeballs the
   // tagging before committing with --code.
@@ -2114,6 +2203,26 @@ async function cmdSend(token: string, args: SendArgs): Promise<void> {
     }
   }
 
+  // Warn-only lint: names written as plain text (no leading @) that map to a
+  // known workspace member but aren't <@USERID>-tagged — they won't be notified.
+  // Skipped for people Slack notifies anyway: a thread reply reaches everyone
+  // who started or replied in that thread, and a 1:1 DM reaches its other
+  // member — warning there is noise that makes agents stop for nothing.
+  // Never blocks; fail-soft (a missing users:read scope or API error must not
+  // stall a send).
+  try {
+    const notified = threadTs
+      ? threadParticipants(threadMsgs)
+      : new Set([await dmCounterparty(token, channelId, cookie)].filter((u): u is string => !!u));
+    for (const u of await findUntaggedMentions(args.mentionToken ?? token, message, args.mentionCookie)) {
+      if (notified.has(u.userId)) continue;
+      // u.surface / u.display carry Slack-controlled display text — strip control chars.
+      console.error(`⚠ possible untagged mention: ${stripTerminalControls(u.surface)} — @${stripTerminalControls(u.display)} won't be notified (did you mean <@${u.userId}>?)`);
+    }
+  } catch {
+    // best-effort; ignore
+  }
+
   // Unreplied guard: the destination's last message is our own and no one has
   // replied since (by definition, since it's still the most recent message) —
   // sending another new message risks spamming the same person twice. Warn
@@ -3101,6 +3210,7 @@ interface PollArgs {
   cookie?: string;
   mentionToken?: string;
   mentionCookie?: string;
+  allowUrlAdjacent?: boolean;
 }
 
 /** The `slack poll --results=…` line handed back after posting. Printed as a
@@ -3164,6 +3274,7 @@ async function cmdPoll(token: string, args: PollArgs): Promise<void> {
   const multi = !!args.multi;
   const until = args.until ?? "";
   const message = pollBuildText(question, body, choices, { multi, deadline: until });
+  guardUrlBoundaries(message, args.allowUrlAdjacent);
 
   // Preview the destination's last message, exactly as `send`/`ask` do. Fail-soft.
   let lastText = "";
@@ -3448,8 +3559,10 @@ interface ScheduleSendArgs {
   /** How the caller overrode the target text, e.g. `--user-id U0123`. Set only
    *  when a FLAG supplied it — never when the command resolved the id itself. */
   targetOverride?: string;
+  allowUrlAdjacent?: boolean;
 }
 async function cmdScheduleSend(token: string, args: ScheduleSendArgs): Promise<void> {
+  guardUrlBoundaries(args.message, args.allowUrlAdjacent);
   const getSelf = selfLookup(token, args.cookie);
   const { ref, threadTs } = parseTargetThread(args.target);
 
@@ -3595,8 +3708,10 @@ interface UploadArgs {
   channelId?: string;
   userId?: string;
   cookie?: string;
+  allowUrlAdjacent?: boolean;
 }
 async function cmdUpload(token: string, args: UploadArgs): Promise<void> {
+  if (args.comment !== undefined) guardUrlBoundaries(args.comment, args.allowUrlAdjacent);
   const getSelf = selfLookup(token, args.cookie);
   const { statSync, existsSync } = await import("node:fs");
   const { basename } = await import("node:path");
@@ -3992,6 +4107,8 @@ async function cmdDownload(token: string, cookie: string | undefined, ref: strin
 // --- dispatch ---
 
 async function main(): Promise<void> {
+  // Before any output: Bun drops console writes that meet a full pipe (see stdout.ts).
+  installSyncConsole();
   loadDotenvFiles();
 
   type W = { workspace?: string };
@@ -4216,6 +4333,89 @@ async function main(): Promise<void> {
             }
           },
         )
+        .command(
+          ["rename <channel> <new-name>", "mv <channel> <new-name>"],
+          "Rename a channel (confirm-hash safety gate)",
+          (y2) => y2
+            .positional("channel", { type: "string", demandOption: true, describe: "#name, name, or channel ID (C…/G…)" })
+            .positional("new-name", { type: "string", demandOption: true, describe: "New channel name (Slack lowercases it; no spaces)" })
+            .option("dry-run", { type: "boolean", default: false, describe: "Resolve the channel and print old -> new without renaming" })
+            .option("code", { type: "string", describe: "Safety hash to confirm rename" }),
+          async (argv) => {
+            const token = tok(argv as W);
+            const cookie = ck(argv as W);
+            const ref = argv.channel!;
+            if (ref.startsWith("@")) {
+              console.error(`Error: ${ref} is a DM — only channels can be renamed.`);
+              process.exit(1);
+            }
+            // A bare word is a channel name unless it is shaped like an ID.
+            const channelRef = ref.startsWith("#") || /^[CG][A-Z0-9]{8,}$/.test(ref) ? ref : `#${ref}`;
+            const newName = argv.newName!.replace(/^#/, "").toLowerCase();
+            let channelId: string;
+            let oldName: string;
+            try {
+              channelId = await resolveChannel(token, channelRef, cookie);
+            } catch (e: unknown) {
+              console.error(`Error: could not resolve channel ${ref}: ${e instanceof Error ? e.message : String(e)}`);
+              process.exit(1);
+            }
+            try {
+              const ch = asRecord(asRecord((await conversationInfo(token, channelId, cookie)) as Json).channel);
+              if (ch.is_im === true || ch.is_mpim === true) {
+                console.error(`Error: ${channelId} is a DM — only channels can be renamed.`);
+                process.exit(1);
+              }
+              oldName = typeof ch.name === "string" ? ch.name : channelRef.replace(/^#/, "");
+            } catch (e: unknown) {
+              // conversations.info is only for the preview label — a token without
+              // channels:read can still rename. A channel that doesn't exist can't.
+              const raw = e instanceof Error ? e.message : String(e);
+              if (/channel_not_found/.test(raw)) {
+                console.error(`Error: could not resolve channel ${ref}: channel not found (or not visible to this token).`);
+                process.exit(1);
+              }
+              oldName = channelRef.replace(/^#/, "");
+            }
+            if (argv.dryRun === true) {
+              console.log(`#${oldName} -> #${newName}  (${channelId})`);
+              console.log(`(dry run — conversations.rename not called)`);
+              return;
+            }
+            // The renamer is the actor of record in the channel's history, so the
+            // gate names them and the code is bound to them.
+            const self = await selfIdentity(token, cookie);
+            const code = safetyCode("rename", channelId, newName, self?.userId ?? "");
+            if (argv.code !== code) requireCode(argv.code, code, [
+              `--- Renaming channel -------------------------`,
+              fromLine(self, { pad: 9 }),
+              `  channel: ${channelId}`,
+              `  from:    #${oldName}`,
+              `  to:      #${newName}`,
+              `--------------------------------────────────`,
+            ]);
+            let renamed: { id: string; name: string };
+            try {
+              renamed = await renameChannel(token, channelId, newName, cookie);
+            } catch (e: unknown) {
+              const raw = e instanceof Error ? e.message : String(e);
+              const errCode = raw.match(/Slack error on conversations\.rename: (\w+)/)?.[1];
+              const hint: Record<string, string> = {
+                name_taken: `Error: a channel named #${newName} already exists.`,
+                invalid_name: `Error: "${newName}" is not a valid channel name (lowercase letters, numbers, hyphens, underscores; max 80 chars).`,
+                invalid_name_specials: `Error: "${newName}" contains characters Slack doesn't allow in channel names.`,
+                invalid_name_maxlength: `Error: "${newName}" is too long (max 80 chars).`,
+                invalid_name_required: `Error: the new channel name can't be empty.`,
+                not_authorized: `Error: this token isn't allowed to rename #${oldName} (workspace settings may restrict renaming to admins or the channel creator).`,
+                not_in_channel: `Error: this token isn't a member of #${oldName} — join it first.`,
+                is_archived: `Error: #${oldName} is archived — unarchive it before renaming.`,
+              };
+              console.error((errCode && hint[errCode]) ?? friendlySlackError(e));
+              process.exit(1);
+            }
+            console.log(`✓ Renamed #${oldName} -> #${renamed.name}  (${renamed.id})`);
+          },
+        )
         .demandCommand(1, "")
         .showHelpOnFail(true),
     )
@@ -4411,6 +4611,15 @@ async function main(): Promise<void> {
         .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) => {
+        // An empty body is never a meaningful send. `ask` already refuses one
+        // ("Error: question is empty"); `send` did not, so an empty draft
+        // staged a confirm code and posting it produced a blank message.
+        // Verification cannot catch this: an empty publish reads back as an
+        // exact match, so refusing here is the only mechanism.
+        if (!String(argv.message ?? "").trim()) {
+          console.error("Error: message is empty");
+          process.exit(1);
+        }
         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"];
@@ -4626,6 +4835,7 @@ async function main(): Promise<void> {
         .option("no-notify", { type: "boolean", default: false, describe: "With --results: do not write the invalid-ballot notice back into the message (keeps it strictly read-only)" })
         .option("code", { type: "string", describe: "Safety hash to confirm the post" })
         .option("body", { type: "string", describe: "Extra context shown under the question" })
+        .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: "Post via the bot token (xoxb / SLACK_BOT_TOKEN) so a DM notifies the recipient — and so YOUR OWN vote counts, since the seeds are then the bot's" }),
@@ -4695,6 +4905,7 @@ async function main(): Promise<void> {
         if (argv.until) args.until = String(argv.until);
         if (argv.code) args.code = argv.code;
         if (argv.body) args.body = argv.body;
+        if (argv["allow-url-adjacent"]) args.allowUrlAdjacent = true;
         if (argv["channel-id"]) args.channelId = argv["channel-id"];
         if (argv["user-id"]) args.userId = argv["user-id"];
         // Always resolve @tags with the user token (it has users:read), even
@@ -4811,12 +5022,23 @@ async function main(): Promise<void> {
             .positional("message", { type: "string", demandOption: true })
             .option("at", { type: "string", demandOption: true, describe: "Delivery time (ISO datetime or Unix ts)" })
             .option("code", { type: "string", describe: "Safety hash to confirm" })
+            .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: "Schedule via the bot token (xoxb / SLACK_BOT_TOKEN) so a DM notifies the recipient. Without it a scheduled DM to yourself is posted by you, and Slack never notifies you of your own message — it fires into silence." }),
           async (argv) => {
+            // An empty body is never a meaningful send. `ask` already refuses one
+            // ("Error: question is empty"); `send` did not, so an empty draft
+            // staged a confirm code and posting it produced a blank message.
+            // Verification cannot catch this: an empty publish reads back as an
+            // exact match, so refusing here is the only mechanism.
+            if (!String(argv.message ?? "").trim()) {
+              console.error("Error: message is empty");
+              process.exit(1);
+            }
             const args: ScheduleSendArgs = { target: argv.target!, message: argv.message!, at: argv.at! };
             if (argv.code) args.code = argv.code;
+            if (argv["allow-url-adjacent"]) args.allowUrlAdjacent = true;
             // Recorded here, not in the command, because only a flag counts as an
             // override — under --as-bot the command sets args.userId itself from
             // the target, and claiming THAT was an override would be a new lie.
@@ -5306,6 +5528,7 @@ async function main(): Promise<void> {
         .positional("file", { type: "string", array: true, demandOption: true, describe: "Path(s) to file(s)" })
         .option("title", { type: "string", describe: "Title (single file only)" })
         .option("comment", { type: "string", describe: "Initial comment (first file)" })
+        .option("allow-url-adjacent", { type: "boolean", default: false, describe: "Warn instead of refusing ambiguous bare URL boundaries" })
         .option("code", { type: "string", describe: "4-hex safety code to confirm upload" })
         .option("channel-id", { type: "string" })
         .option("user-id", { type: "string" }),
@@ -5313,6 +5536,7 @@ async function main(): Promise<void> {
         const args: UploadArgs = { target: argv.target!, filePaths: argv.file as string[] };
         if (argv.title) args.title = argv.title;
         if (argv.comment) args.comment = argv.comment;
+        if (argv["allow-url-adjacent"]) args.allowUrlAdjacent = true;
         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"];
@@ -5478,6 +5702,25 @@ async function main(): Promise<void> {
         await cmdDump(tok(argv as W), argv.days, argv.limit, argv.filter);
       },
     )
+    .command(
+      "todos",
+      "Slack's To-dos tab — your personal to-dos (read-only; requires xoxc desktop token). Not `slack todo` (reaction tasks)",
+      (y) => y.command(
+        ["$0", "ls", "list"],
+        "List your To-dos, soonest due first",
+        (y2) => y2
+          .option("filter", { type: "string", choices: [...TODO_FILTERS], default: "todo", describe: "todo = open to-dos; saved = everything saved; completed; archived" })
+          .option("limit", { alias: "n", type: "number", default: 50, describe: "At most this many items" })
+          .option("json", { type: "boolean", default: false, describe: "One JSON object per item (raw fields + permalink + message text)" }),
+        async (argv) => {
+          if (!Number.isInteger(argv.limit) || argv.limit < 1) {
+            console.error(`Error: --limit must be a whole number of at least 1 (got ${argv.limit}).`);
+            process.exit(2);
+          }
+          await cmdTodos(tok(argv as W), ck(argv as W), { filter: argv.filter as TodoFilter, limit: argv.limit, json: argv.json });
+        },
+      ),
+    )
     .command(
       "drafts",
       "Manage message drafts (requires xoxc desktop token)",
@@ -5495,11 +5738,15 @@ async function main(): Promise<void> {
           "Create a draft",
           (y2) => y2
             .positional("channel", { type: "string", demandOption: true })
-            .positional("text", { type: "string", array: true, default: [] }),
+            .positional("text", { type: "string", array: true, default: [] })
+            .option("allow-url-adjacent", { type: "boolean", default: false, describe: "Warn instead of refusing a bare URL that runs into non-ASCII text (it would link only up to that point)" }),
           async (argv) => {
             const token = tok(argv as W); const cookie = ck(argv as W);
             const text = (argv.text as string[]).join(" ");
             if (!text) { console.error("Usage: slack drafts new <#channel|@user> <text>"); process.exit(2); }
+            // Drafts emit explicit link elements, so a URL glued BEFORE is fine
+            // here; one that runs into text AFTER would be cut at a guess.
+            guardUrlBoundaries(text, argv["allow-url-adjacent"], undefined, { sides: ["after"], markdown: false });
             const channelId = await resolveChannel(token, argv.channel!, cookie);
             const resp = (await createDraft(token, channelId, text, cookie)) as Record<string, Json>;
             console.log(`✓ Draft created (id: ${asRecord(resp.draft).id ?? "?"})`);
@@ -5519,11 +5766,13 @@ async function main(): Promise<void> {
           (y2) => y2
             .positional("id", { type: "string", demandOption: true })
             .positional("text", { type: "string", array: true, default: [] })
-            .option("code", { type: "string" }),
+            .option("code", { type: "string" })
+            .option("allow-url-adjacent", { type: "boolean", default: false, describe: "Warn instead of refusing a bare URL that runs into non-ASCII text (it would link only up to that point)" }),
           async (argv) => {
             const token = tok(argv as W); const cookie = ck(argv as W);
             const text = (argv.text as string[]).join(" ");
             if (!text) { console.error("Usage: slack drafts edit <id> <new-text>"); process.exit(2); }
+            guardUrlBoundaries(text, argv["allow-url-adjacent"], undefined, { sides: ["after"], markdown: false });
             const listResp = (await listDrafts(token, cookie)) as Record<string, Json>;
             const d = asArray(listResp.drafts).map(asRecord).find((x) => String(x.id) === argv.id);
             if (!d) { console.error(`Draft not found: ${argv.id}`); process.exit(1); }