slack-term 1.39.2 → 1.40.0

package/package.json

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

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,
@@ -759,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);
     }
@@ -841,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>;
@@ -904,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)",
 };
@@ -3145,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
@@ -3208,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 = "";
@@ -3492,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);
 
@@ -3639,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");
@@ -4262,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),
     )
@@ -4457,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"];
@@ -4672,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" }),
@@ -4741,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
@@ -4857,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.
@@ -5352,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" }),
@@ -5359,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"];
@@ -5524,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)",
@@ -5541,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 ?? "?"})`);
@@ -5565,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); }

package/ts/slack.ts

@@ -1,12 +1,30 @@
 // Slack Web API client (user token, Authorization: Bearer)
 import { resolveCookie } from "./profiles.ts";
+import { linkifyRichText } from "./urlGuard.ts";
 
 export class RateLimitError extends Error {
   retryAfter: number;
-  constructor(retryAfter: number) {
-    super(`Slack rate limited — retry after ${retryAfter}s`);
+  /**
+   * The Web API method that was throttled ("conversations.history", ...).
+   *
+   * Slack's limits are PER METHOD, so "retry after 30s" alone cannot say whether
+   * a caller's own polling caused the 429 or something else sharing the token
+   * did. The method name is already in scope at every throw site below; not
+   * passing it was the only reason the question was unanswerable.
+   *
+   * Optional because callers (and tests) constructed this with one argument
+   * before, and a required field would break them for no diagnostic gain.
+   */
+  method?: string;
+  constructor(retryAfter: number, method?: string) {
+    super(
+      method
+        ? `Slack rate limited on ${method} — retry after ${retryAfter}s`
+        : `Slack rate limited — retry after ${retryAfter}s`,
+    );
     this.name = "RateLimitError";
     this.retryAfter = retryAfter;
+    if (method) this.method = method;
   }
 }
 
@@ -36,12 +54,12 @@ async function call(token: string, method: string, init: RequestInit, cookie?: s
   });
   if (res.status === 429) {
     const retryAfter = parseInt(res.headers.get("retry-after") ?? "60", 10);
-    throw new RateLimitError(isNaN(retryAfter) ? 60 : retryAfter);
+    throw new RateLimitError(isNaN(retryAfter) ? 60 : retryAfter, method);
   }
   const body = (await res.json()) as { ok?: boolean; error?: string } & Record<string, Json>;
   if (body.ok !== true) {
     const err = body.error ?? "unknown";
-    if (err === "ratelimited") throw new RateLimitError(60);
+    if (err === "ratelimited") throw new RateLimitError(60, method);
     // A desktop session token (xoxc-) is only accepted by the public Web API when
     // paired with its xoxd session cookie — without one, point at the xoxp fallback.
     if (err === "invalid_auth" && token.startsWith("xoxc-") && !cookie) {
@@ -89,21 +107,21 @@ async function callSession(token: string, method: string, init: RequestInit, coo
   });
   if (res.status === 429) {
     const retryAfter = parseInt(res.headers.get("retry-after") ?? "60", 10);
-    throw new RateLimitError(isNaN(retryAfter) ? 60 : retryAfter);
+    throw new RateLimitError(isNaN(retryAfter) ? 60 : retryAfter, method);
   }
   const body = (await res.json()) as { ok?: boolean; error?: string } & Record<string, Json>;
   if (body.ok !== true) {
     const err = body.error ?? "unknown";
-    if (err === "ratelimited") throw new RateLimitError(60);
+    if (err === "ratelimited") throw new RateLimitError(60, method);
     if ((err === "invalid_auth" || err === "not_authed") && !token.startsWith("xoxc-")) {
       throw new Error(
-        `The draft API requires a desktop app session token (xoxc-).\n` +
+        `${method} requires a desktop app session token (xoxc-).\n` +
         `Import from Slack desktop:  slack auth login`,
       );
     }
     if ((err === "invalid_auth" || err === "not_authed") && !cookie) {
       throw new Error(
-        `drafts.list also requires the xoxd session cookie.\n` +
+        `${method} also requires the xoxd session cookie.\n` +
         `Attach it with:  slack auth firefox   (Linux/macOS/Windows)   or   slack auth chrome   (macOS/Linux)`,
       );
     }
@@ -185,7 +203,7 @@ export async function authScopes(token: string, cookie?: string): Promise<{
   const res = await fetch(`${base()}/auth.test`, { method: "GET", headers });
   if (res.status === 429) {
     const retryAfter = parseInt(res.headers.get("retry-after") ?? "60", 10);
-    throw new RateLimitError(isNaN(retryAfter) ? 60 : retryAfter);
+    throw new RateLimitError(isNaN(retryAfter) ? 60 : retryAfter, "auth.test");
   }
   const scopesHeader = res.headers.get("x-oauth-scopes") ?? "";
   const body = (await res.json()) as {
@@ -594,6 +612,20 @@ export async function createChannel(
   return { id: resp.channel?.id ?? "", name: resp.channel?.name ?? name };
 }
 
+// Rename a channel via conversations.rename. Needs channels:manage (public) or
+// groups:write (private) — and, for a user token, rights to rename it.
+export async function renameChannel(
+  token: string,
+  channel: string,
+  name: string,
+  cookie?: string,
+): Promise<{ id: string; name: string }> {
+  const resp = (await post(token, "conversations.rename", { channel, name }, cookie)) as {
+    channel?: { id?: string; name?: string };
+  };
+  return { id: resp.channel?.id ?? channel, name: resp.channel?.name ?? name };
+}
+
 // Invite users to a channel via conversations.invite (up to ~1000 ids).
 export async function inviteToChannel(
   token: string,
@@ -1025,6 +1057,19 @@ export async function listConversationMembers(token: string, channel: string, co
   return all;
 }
 
+// To-dos tab (internal — requires xoxc session token + xoxd cookie). The
+// desktop client's own read of Slack's personal To-dos; see slackTodos.ts.
+export async function savedList(
+  token: string,
+  opts: { filter?: string; limit?: number; cursor?: string | undefined } = {},
+  cookie?: string,
+): Promise<Json> {
+  const params: Record<string, string> = { limit: String(opts.limit ?? 50) };
+  if (opts.filter) params.filter = opts.filter;
+  if (opts.cursor) params.cursor = opts.cursor;
+  return postSession(token, "saved.list", params, cookie);
+}
+
 // Draft API (internal — requires xoxc session token + xoxd cookie)
 export async function listDrafts(token: string, cookie?: string): Promise<Json> {
   return postSession(token, "drafts.list", {}, cookie);
@@ -1039,7 +1084,7 @@ export async function createDraft(
   const { randomUUID } = await import("node:crypto");
   const blocks = JSON.stringify([{
     type: "rich_text",
-    elements: [{ type: "rich_text_section", elements: [{ type: "text", text }] }],
+    elements: [{ type: "rich_text_section", elements: linkifyRichText(text) }],
   }]);
   return postSession(token, "drafts.create", {
     client_msg_id: randomUUID(),
@@ -1059,7 +1104,7 @@ export async function updateDraft(
 ): Promise<Json> {
   const blocks = JSON.stringify([{
     type: "rich_text",
-    elements: [{ type: "rich_text_section", elements: [{ type: "text", text }] }],
+    elements: [{ type: "rich_text_section", elements: linkifyRichText(text) }],
   }]);
   // client_last_updated_ts must be the current time (server uses it as new stored ts)
   const nowTs = (Date.now() / 1000).toFixed(6);

package/ts/slackTodos.ts

@@ -0,0 +1,85 @@
+// Slack's To-dos tab (app.slack.com/client/<team>/to-dos) — read-only helpers.
+//
+// Not to be confused with `slack todo` (todo.ts), which tracks tasks as
+// reactions on messages. To-dos are Slack's own PERSONAL list: it replaced
+// "Later" in Oct 2026, and there is no public API for it. The desktop client
+// reads it through the internal `saved.list` (xoxc session token + d cookie),
+// which is what `slack todos` calls — so it is per-user, and bot tokens cannot
+// see it at all.
+//
+// A saved item points at a message: `item_id` is the channel id, `ts` the
+// message ts. `todo_state` is "to_do" for a to-do and "saved" for a plain
+// saved item; `state` is "in_progress" until it is checked off. Dates are
+// epoch seconds, 0 when unset. The shape is undocumented, so every field is
+// read defensively.
+
+import type { Json } from "./slack.ts";
+
+/** `--filter` values `saved.list` accepts (verified against the live API). */
+export const TODO_FILTERS = ["todo", "saved", "completed", "archived"] as const;
+export type TodoFilter = (typeof TODO_FILTERS)[number];
+
+export type TodoItem = {
+  channel: string;
+  ts: string;
+  /** Epoch seconds; 0 = no due date. */
+  due: number;
+  /** Epoch seconds; 0 = not completed. */
+  completed: number;
+  /** "to_do" | "saved" (as Slack reports it). */
+  todoState: string;
+  state: string;
+  archived: boolean;
+  itemType: string;
+};
+
+const str = (v: Json | undefined): string => (typeof v === "string" ? v : "");
+const num = (v: Json | undefined): number => {
+  const n = typeof v === "number" || typeof v === "string" ? Number(v) : 0;
+  return Number.isFinite(n) ? n : 0;
+};
+
+/** The items of one `saved.list` page, normalized. Non-message items are kept
+ *  (their `itemType` says what they are) but carry no channel/ts to read. */
+export function parseSavedItems(resp: Json): TodoItem[] {
+  const r = (resp && typeof resp === "object" && !Array.isArray(resp) ? resp : {}) as Record<string, Json>;
+  const items = Array.isArray(r.saved_items) ? r.saved_items : [];
+  return items
+    .filter((x): x is Record<string, Json> => !!x && typeof x === "object" && !Array.isArray(x))
+    .map((x) => ({
+      channel: str(x.item_id),
+      ts: str(x.ts),
+      due: num(x.date_due),
+      completed: num(x.date_completed),
+      todoState: str(x.todo_state),
+      state: str(x.state),
+      archived: x.is_archived === true,
+      itemType: str(x.item_type),
+    }));
+}
+
+/** Soonest due first; items without a due date last, newest message first among them. */
+export function sortTodos(items: TodoItem[]): TodoItem[] {
+  return [...items].sort((a, b) => {
+    if (a.due && b.due) return a.due - b.due;
+    if (a.due !== b.due) return a.due ? -1 : 1;
+    return Number(b.ts) - Number(a.ts);
+  });
+}
+
+export function isDone(t: TodoItem): boolean {
+  return t.completed > 0 || t.state === "completed";
+}
+
+/** The status column: a checkbox, plus the due date (and OVERDUE when past it). */
+export function todoStatus(t: TodoItem, nowSec: number, fmt: (epochSec: number) => string): string {
+  const box = isDone(t) ? "☑" : t.todoState === "to_do" ? "☐" : "·";
+  if (!t.due) return `${box} no due date`;
+  const overdue = !isDone(t) && t.due < nowSec ? "  OVERDUE" : "";
+  return `${box} due ${fmt(t.due)}${overdue}`;
+}
+
+/** A message permalink built from the workspace URL — no API call per item. */
+export function messagePermalink(teamUrl: string, channel: string, ts: string): string {
+  return `${teamUrl.replace(/\/+$/, "")}/archives/${channel}/p${ts.replace(".", "")}`;
+}