slack-term 1.7.0 → 1.14.0

package/ts/cli.ts

@@ -1,17 +1,18 @@
 #!/usr/bin/env bun
 // Slack CLI entry — mirrors the Rust impl in src/main.rs.
 
-import { parseArgs } from "node:util";
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
-import { addProfile, listProfiles, removeProfile, resolveCookie, resolveToken, setCookie, useProfile } from "./profiles.ts";
-import { extractSessions } from "./slack-app.ts";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { listProfiles, removeProfile, resolveCookie, resolveToken, useProfile } from "./profiles.ts";
+import { cmdAuthLogin } from "./auth.ts";
+import { cmdTail } from "./tail.ts";
 
 import {
-  authTest,
   authTestSession,
   conversationInfoSession,
   createDraft,
@@ -21,6 +22,9 @@ import {
   history,
   listConversations,
   listDrafts,
+  listUsers,
+  userInfo,
+  conversationInfo,
   openDm,
   parseSlackPermalink,
   replies,
@@ -28,13 +32,16 @@ import {
   search,
   searchAll,
   send as slackSend,
+  scheduleMessage,
+  listScheduledMessages,
+  deleteScheduledMessage,
   uploadFile,
   userInfoPair,
   userName,
   getPath,
   type Json,
 } from "./slack.ts";
-import { dayLabel, formatHm, formatYmdHm, resolveDateMarkup, resolveMentions } from "./format.ts";
+import { dayLabel, formatYmdHm, resolveDateMarkup, resolveMentions } from "./format.ts";
 
 function loadDotenv(path: string): void {
   if (!existsSync(path)) return;
@@ -109,52 +116,87 @@ function formatYmdHmsUtc(epochSec: number): string {
   return `${y}-${mo}-${da} ${h}:${mi}:${s}`;
 }
 
-// Format one message line: `[YYYY-MM-DD HH:MM:SS] <real|@handle> text` (UTC)
+// Lossless Slack ts → ISO string: "2026-05-11T06:01:04.000100"
+function slackTsToIso(tsRaw: string): string {
+  const [secStr, fracStr = "000000"] = tsRaw.split(".");
+  const epochSec = Number(secStr);
+  const d = new Date(epochSec * 1000);
+  const y = d.getUTCFullYear();
+  const mo = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const da = String(d.getUTCDate()).padStart(2, "0");
+  const h = String(d.getUTCHours()).padStart(2, "0");
+  const mi = String(d.getUTCMinutes()).padStart(2, "0");
+  const s = String(d.getUTCSeconds()).padStart(2, "0");
+  const frac = fracStr.padEnd(6, "0").slice(0, 6);
+  return `${y}-${mo}-${da}T${h}:${mi}:${s}.${frac}`;
+}
+
+// Parse ISO ts back to Slack ts — throws if fractional is absent or not exactly 6 digits.
+function isoToSlackTs(iso: string): string {
+  const m = iso.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})\.(\d{6})$/);
+  if (!m) throw new Error(`Invalid message timestamp "${iso}" — expected 2026-05-11T06:01:04.000100`);
+  const epochMs = Date.parse(m[1] + "Z");
+  if (isNaN(epochMs)) throw new Error(`Cannot parse date in "${iso}"`);
+  return `${Math.floor(epochMs / 1000)}.${m[2]}`;
+}
+
+function parseInputTs(s: string): string {
+  return /^\d{4}-\d{2}-\d{2}T/.test(s) ? isoToSlackTs(s) : s;
+}
+
+// Format one message line: `[ts]  @handle  text` (UTC). Pass chLabel (e.g. "#general") for search.
 async function formatMsgLine(
   token: string,
   m: Record<string, Json>,
   cache: Map<string, string>,
+  chLabel?: string,
 ): Promise<string> {
-  const ts = tsNum(m);
-  const stamp = formatYmdHmsUtc(ts);
-  let real = "?";
+  const rawTs = typeof m.ts === "string" ? m.ts : `${tsNum(m)}.000000`;
+  const stamp = slackTsToIso(rawTs);
   let handle = "?";
   if (typeof m.user === "string") {
     const uid = m.user;
-    const realKey = uid;
     const handleKey = "@" + uid;
-    if (!cache.has(realKey) || !cache.has(handleKey)) {
-      const [d, h] = await userInfoPair(token, uid);
-      cache.set(realKey, d);
+    if (!cache.has(handleKey)) {
+      const [, h] = await userInfoPair(token, uid);
       cache.set(handleKey, h);
     }
-    real = cache.get(realKey) ?? uid;
     handle = cache.get(handleKey) ?? uid;
   } else if (typeof m.username === "string") {
-    real = m.username;
     handle = m.username;
   }
   const raw = typeof m.text === "string" ? m.text : "";
   const resolved = resolveDateMarkup(await resolveMentions(token, raw, cache));
-  const oneline = resolved.split("\n").join(" ↵ ");
-  return `[${stamp}] <${real}|@${handle}> ${oneline}`;
+  const lines = resolved.split("\n");
+  const body = lines[0] + (lines.length > 1 ? "\n" + lines.slice(1).map(l => `  ${l}`).join("\n") : "");
+  const who = chLabel ? `${chLabel}  @${handle}` : `@${handle}`;
+  return `${stamp}  ${who}:  ${body}`;
 }
 
 // --- msgs <target> — channel/DM history with timestamps ---
 async function cmdMsgsTarget(token: string, target: string, limit: number): Promise<void> {
+  const parsed = parseSlackPermalink(target);
   const channelId = await resolveChannel(token, target);
-  const hist = (await history(token, channelId, limit)) as Record<string, Json>;
-  const msgs = asArray(hist.messages).map(asRecord);
   const cache = new Map<string, string>();
-  for (const m of msgs.reverse()) {
-    console.log(await formatMsgLine(token, m, cache));
+  if (parsed?.threadTs) {
+    const resp = (await replies(token, channelId, parsed.threadTs, limit)) as Record<string, Json>;
+    const msgs = asArray(resp.messages).map(asRecord);
+    for (const m of msgs) {
+      console.log(await formatMsgLine(token, m, cache));
+    }
+  } else {
+    const hist = (await history(token, channelId, limit)) as Record<string, Json>;
+    const msgs = asArray(hist.messages).map(asRecord);
+    for (const m of msgs.reverse()) {
+      console.log(await formatMsgLine(token, m, cache));
+    }
   }
 }
 
 // --- thread ---
 async function cmdThread(token: string, target: string, ts: string, limit: number): Promise<void> {
   const channelId = await resolveChannel(token, target);
-  const resp = (await replies(token, channelId, ts, limit)) as Record<string, Json>;
+  const resp = (await replies(token, channelId, parseInputTs(ts), limit)) as Record<string, Json>;
   const msgs = asArray(resp.messages).map(asRecord);
   const cache = new Map<string, string>();
   for (const m of msgs) {
@@ -183,9 +225,10 @@ async function cmdMsgs(token: string): Promise<void> {
         const t = typeof m.text === "string" ? m.text : "";
         return t.length > 0 && !t.startsWith("<@");
       })
-      .slice(0, 3);
+      .slice(0, 3)
+      .reverse();
     if (msgs.length === 0) continue;
-    console.log(`── #${name} ─────────────────────────────────`);
+    console.log(`-- #${name} --------------------------------`);
     for (const m of msgs) {
       const who = await displayUser(token, m, cache);
       const raw = (typeof m.text === "string" ? m.text : "").split("\n")[0] ?? "";
@@ -198,44 +241,49 @@ async function cmdMsgs(token: string): Promise<void> {
 // --- news ---
 async function cmdNews(token: string, limit: number): Promise<void> {
   const resp = (await search(token, "to:me")) as Record<string, Json>;
-  const matches = asArray(getPath(resp, ["messages", "matches"])).map(asRecord);
+  const matches = asArray(getPath(resp, ["messages", "matches"])).map(asRecord).slice(0, limit);
   const cache = new Map<string, string>();
-  let lastDay = "";
-  for (const m of matches.slice(0, limit)) {
-    const ts = tsNum(m);
-    const label = dayLabel(ts);
-    if (label !== lastDay) {
-      if (lastDay !== "") console.log("");
-      console.log(`  ${label}`);
-      console.log("  ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄");
-      lastDay = label;
-    }
-    const ch = asRecord(m.channel);
-    const isIm = ch.is_im === true;
-    const rawName = typeof ch.name === "string" ? ch.name : "dm";
-    let chLabel: string;
-    if (isIm && rawName.startsWith("U")) {
-      if (!cache.has(rawName)) cache.set(rawName, await userName(token, rawName));
-      chLabel = `@${cache.get(rawName) ?? rawName}`;
-    } else if (isIm) {
-      chLabel = `@${rawName}`;
-    } else {
-      chLabel = `#${rawName}`;
+
+  // Group by day (API returns newest-first; reverse within each group for chronological reading)
+  const groups: { label: string; msgs: Record<string, Json>[] }[] = [];
+  for (const m of matches) {
+    const label = dayLabel(tsNum(m));
+    const last = groups[groups.length - 1];
+    if (last?.label === label) last.msgs.push(m);
+    else groups.push({ label, msgs: [m] });
+  }
+
+  for (let gi = 0; gi < groups.length; gi++) {
+    const { label, msgs } = groups[gi]!;
+    if (gi > 0) console.log("");
+    console.log(`  ${label}`);
+    console.log("  ----------------------------");
+    for (const m of [...msgs].reverse()) {
+      const ch = asRecord(m.channel);
+      const isIm = ch.is_im === true;
+      const rawName = typeof ch.name === "string" ? ch.name : "dm";
+      let chLabel: string;
+      if (isIm && rawName.startsWith("U")) {
+        const handleKey = "@" + rawName;
+        if (!cache.has(handleKey)) {
+          const [, h] = await userInfoPair(token, rawName);
+          cache.set(handleKey, h);
+        }
+        chLabel = `@${cache.get(handleKey) ?? rawName}`;
+      } else if (isIm) {
+        chLabel = `@${rawName}`;
+      } else {
+        chLabel = `#${rawName}`;
+      }
+      console.log(await formatMsgLine(token, m, cache, chLabel));
     }
-    const display = await displayUser(token, m, cache);
-    const raw = typeof m.text === "string" ? m.text : "";
-    const resolved = resolveDateMarkup(await resolveMentions(token, raw, cache));
-    const firstLine = (resolved.split("\n")[0] ?? "").slice(0, 80);
-    const icon = isIm ? "💬" : "🔔";
-    console.log(`  ${icon} ${chLabel}  ${formatHm(ts)}`);
-    console.log(`     ${display}: ${firstLine}`);
   }
 }
 
 // --- channels ---
-async function cmdChannels(token: string, limit: number, filter?: string, all?: boolean): Promise<void> {
+async function cmdChannels(token: string, limit: number, filter?: string, all?: boolean, format = "text"): Promise<void> {
   const resp = (await listConversations(token)) as Record<string, Json>;
-  let channels = asArray(resp.channels)
+  const channels = asArray(resp.channels)
     .map(asRecord)
     .filter((c) => all || c.is_member === true)
     .filter((c) => {
@@ -246,6 +294,10 @@ async function cmdChannels(token: string, limit: number, filter?: string, all?:
     .sort((a, b) => Number(b.updated ?? 0) - Number(a.updated ?? 0))
     .slice(0, limit);
 
+  if (format === "jsonl") {
+    for (const ch of channels) console.log(JSON.stringify(ch));
+    return;
+  }
   for (const ch of channels) {
     const id = String(ch.id ?? "");
     const name = typeof ch.name === "string" ? ch.name : typeof ch.user === "string" ? ch.user : id;
@@ -253,14 +305,40 @@ async function cmdChannels(token: string, limit: number, filter?: string, all?:
     const isMpim = ch.is_mpim === true;
     const prefix = isIm || isMpim ? "@" : "#";
     const memberMark = ch.is_member === true ? "" : " (not joined)";
-    console.log(`${prefix}${name}\t${id}${memberMark}`);
+    const purpose = typeof asRecord(ch.purpose).value === "string" ? String(asRecord(ch.purpose).value) : "";
+    const meta = purpose ? `  ${purpose.split("\n")[0]?.slice(0, 60)}` : "";
+    console.log(`${prefix}${name}  ${id}${memberMark}${meta}`);
   }
 }
 
 // --- search ---
-async function cmdSearch(token: string, query: string, count: number): Promise<void> {
+async function cmdSearch(token: string, query: string, count: number, json: boolean): Promise<void> {
   const resp = await searchAll(token, query, count);
-  console.log(JSON.stringify(resp, null, 2));
+  if (json) {
+    console.log(JSON.stringify(resp, null, 2));
+    return;
+  }
+  const matches = asArray(getPath(resp as Record<string, Json>, ["messages", "matches"])).map(asRecord);
+  const cache = new Map<string, string>();
+  for (const m of matches) {
+    const ch = asRecord(m.channel);
+    const isIm = ch.is_im === true;
+    const rawName = typeof ch.name === "string" ? ch.name : "dm";
+    let chLabel: string;
+    if (isIm && rawName.startsWith("U")) {
+      const handleKey = "@" + rawName;
+      if (!cache.has(handleKey)) {
+        const [, h] = await userInfoPair(token, rawName);
+        cache.set(handleKey, h);
+      }
+      chLabel = `@${cache.get(handleKey) ?? rawName}`;
+    } else if (isIm) {
+      chLabel = `@${rawName}`;
+    } else {
+      chLabel = `#${rawName}`;
+    }
+    console.log(await formatMsgLine(token, m, cache, chLabel));
+  }
 }
 
 // --- dump ---
@@ -400,7 +478,7 @@ async function cmdDrafts(token: string, cookie?: string, showAll = false): Promi
     const id = typeof d.id === "string" ? d.id : "";
     const sentTag = d.is_sent === true ? "  [SENT]" : "";
     const resolved = resolveDateMarkup(await resolveMentions(token, text, mentionCache));
-    console.log(`── ${id}  ${chLabel}  [${stamp}]${sentTag}`);
+    console.log(`-- ${id}  ${chLabel}  [${stamp}]${sentTag}`);
     for (const line of resolved.split("\n")) console.log(`   ${line}`);
   }
 }
@@ -450,7 +528,8 @@ function requireCode(provided: string | undefined, expected: string, contextLine
 }
 
 /** Split a target ref that may embed a message ts.
- *  Accepts: `#chan:ts`, `@user:ts`, Slack permalink URL, or plain ref. */
+ *  Accepts: `#chan:1700000000.000100`, `#chan:2026-05-11T06:01:04.000100`, Slack permalink URL, or plain ref.
+ *  Throws if an ISO-format ts is present but missing the required 6-digit fractional part. */
 function splitRefTs(s: string): { ref: string; ts?: string } {
   const url = parseSlackPermalink(s);
   if (url) return url.ts ? { ref: url.channel, ts: url.ts } : { ref: url.channel };
@@ -461,6 +540,9 @@ function splitRefTs(s: string): { ref: string; ts?: string } {
       if (/^\d{10}\.\d{6}$/.test(maybeTs)) {
         return { ref: s.slice(0, colon), ts: maybeTs };
       }
+      if (/^\d{4}-\d{2}-\d{2}T/.test(maybeTs)) {
+        return { ref: s.slice(0, colon), ts: isoToSlackTs(maybeTs) };
+      }
     }
   }
   return { ref: s };
@@ -476,7 +558,7 @@ interface EditArgs {
 async function cmdEdit(token: string, args: EditArgs): Promise<void> {
   const { ref, ts } = splitRefTs(args.target);
   if (!ts) {
-    console.error("Error: target must embed a message ts (e.g. #chan:1700000000.000100 or a Slack permalink URL)");
+    console.error("Error: target must embed a message ts (e.g. #chan:2026-05-11T06:01:04.000100 or a Slack permalink URL)");
     process.exit(2);
   }
 
@@ -497,11 +579,11 @@ async function cmdEdit(token: string, args: EditArgs): Promise<void> {
   const code = safetyCode(originalText, args.newText);
   if (args.code !== code) {
     requireCode(args.code, code, [
-      `─── Original message ─────────────────────────`,
+      `--- Original message -------------------------`,
       ...originalText.split("\n").map((l) => `  ${l}`),
-      `─── Replacing with ───────────────────────────`,
+      `--- Replacing with ---------------------------`,
       ...args.newText.split("\n").map((l) => `  ${l}`),
-      `─────────────────────────────────────────────`,
+      `--------------------------------────────────`,
     ]);
   }
 
@@ -541,22 +623,109 @@ async function cmdSend(token: string, args: SendArgs): Promise<void> {
 
   if (args.code !== code) {
     requireCode(args.code, code, [
-      `─── Last message in channel ──────────────────`,
+      `--- Last message in channel ------------------`,
       `  ${lastUser}: ${lastText.split("\n")[0]?.slice(0, 100) ?? "(empty)"}`,
-      `─── Sending ──────────────────────────────────`,
+      `--- Sending ----------------------------------`,
       `  To:      ${args.target}${args.thread ? ` (thread ${args.thread})` : ""}`,
       `  Message: ${args.message}`,
-      `─────────────────────────────────────────────`,
+      `--------------------------------────────────`,
     ]);
   }
   const ts = await slackSend(token, channelId, args.message, args.thread);
   console.log(`✓ Sent (ts: ${ts})`);
 }
 
+// --- schedule ---
+function parsePostAt(at: string): number {
+  if (/^\d{10,}$/.test(at)) return parseInt(at, 10);
+  const d = new Date(at.replace(" ", "T"));
+  if (isNaN(d.getTime())) throw new Error(`Cannot parse time: ${at}`);
+  return Math.floor(d.getTime() / 1000);
+}
+
+interface ScheduleSendArgs {
+  target: string;
+  message: string;
+  at: string;
+  thread?: string;
+  code?: string;
+  channelId?: string;
+  userId?: string;
+}
+async function cmdScheduleSend(token: string, args: ScheduleSendArgs): Promise<void> {
+  let channelId: string;
+  if (args.channelId) channelId = args.channelId;
+  else if (args.userId) channelId = await openDm(token, args.userId);
+  else if (args.target.startsWith("#") || args.target.startsWith("@")) {
+    channelId = await resolveChannel(token, args.target);
+  } else {
+    console.error(`Error: target must be #channel-name or @username (got: ${args.target})`);
+    process.exit(1);
+  }
+
+  const postAt = parsePostAt(args.at);
+  const postAtDate = new Date(postAt * 1000).toISOString();
+  const code = safetyCode(channelId, args.message, String(postAt));
+
+  if (args.code !== code) {
+    requireCode(args.code, code, [
+      `--- Scheduling message -----------------------`,
+      `  To:      ${args.target}${args.thread ? ` (thread ${args.thread})` : ""}`,
+      `  At:      ${postAtDate} (Unix: ${postAt})`,
+      `  Message: ${args.message}`,
+      `---------------------------------------------`,
+    ]);
+  }
+  const id = await scheduleMessage(token, channelId, args.message, postAt, args.thread);
+  console.log(`✓ Scheduled (id: ${id}, at: ${postAtDate})`);
+}
+
+async function cmdScheduleList(token: string, target?: string, channelId?: string): Promise<void> {
+  let channel: string | undefined;
+  if (channelId) {
+    channel = channelId;
+  } else if (target) {
+    channel = await resolveChannel(token, target);
+  }
+  const resp = (await listScheduledMessages(token, channel)) as {
+    scheduled_messages?: { id: string; channel_id: string; post_at: number; text: string }[];
+  };
+  const msgs = resp.scheduled_messages ?? [];
+  if (msgs.length === 0) { console.log("(no scheduled messages)"); return; }
+  for (const m of msgs) {
+    const at = new Date(m.post_at * 1000).toISOString();
+    console.log(`${m.id}  ${at}  [${m.channel_id}]  ${m.text.split("\n")[0]?.slice(0, 80) ?? ""}`);
+  }
+}
+
+interface ScheduleRmArgs {
+  target: string;
+  id: string;
+  code?: string;
+  channelId?: string;
+}
+async function cmdScheduleRm(token: string, args: ScheduleRmArgs): Promise<void> {
+  let channelId: string;
+  if (args.channelId) channelId = args.channelId;
+  else channelId = await resolveChannel(token, args.target);
+
+  const code = safetyCode(channelId, args.id);
+  if (args.code !== code) {
+    requireCode(args.code, code, [
+      `--- Deleting scheduled message ---------------`,
+      `  Channel: ${args.target}`,
+      `  ID:      ${args.id}`,
+      `---------------------------------------------`,
+    ]);
+  }
+  await deleteScheduledMessage(token, channelId, args.id);
+  console.log(`✓ Deleted scheduled message ${args.id}`);
+}
+
 // --- upload ---
 interface UploadArgs {
   target: string;
-  filePath: string;
+  filePaths: string[];
   title?: string;
   thread?: string;
   comment?: string;
@@ -568,11 +737,12 @@ async function cmdUpload(token: string, args: UploadArgs): Promise<void> {
   const { statSync, existsSync } = await import("node:fs");
   const { basename } = await import("node:path");
 
-  if (!existsSync(args.filePath)) {
-    console.error(`Error: file not found: ${args.filePath}`);
-    process.exit(1);
+  for (const fp of args.filePaths) {
+    if (!existsSync(fp)) {
+      console.error(`Error: file not found: ${fp}`);
+      process.exit(1);
+    }
   }
-  const stat = statSync(args.filePath);
 
   let channelId: string;
   if (args.channelId) channelId = args.channelId;
@@ -584,427 +754,561 @@ async function cmdUpload(token: string, args: UploadArgs): Promise<void> {
     process.exit(1);
   }
 
-  const filename = basename(args.filePath);
-  const title = args.title ?? filename;
-  const sizeFmt = stat.size < 1024
-    ? `${stat.size} B`
-    : stat.size < 1048576
-    ? `${(stat.size / 1024).toFixed(1)} KB`
-    : `${(stat.size / 1048576).toFixed(1)} MB`;
+  function fmtSize(n: number): string {
+    return n < 1024 ? `${n} B` : n < 1048576 ? `${(n / 1024).toFixed(1)} KB` : `${(n / 1048576).toFixed(1)} MB`;
+  }
+
+  const isBatch = args.filePaths.length > 1;
+  const files = args.filePaths.map((fp) => {
+    const filename = basename(fp);
+    const title = isBatch ? filename : (args.title ?? filename);
+    return { fp, filename, title, sizeFmt: fmtSize(statSync(fp).size) };
+  });
 
-  const code = safetyCode(channelId, args.filePath, title);
+  // Safety code covers the full batch — single-file code is identical to the old formula.
+  const code = safetyCode(channelId, ...files.flatMap((f) => [f.fp, f.title]));
   if (args.code !== code) {
-    requireCode(args.code, code, [
-      `─── Uploading file ───────────────────────────`,
-      `  To:    ${args.target}${args.thread ? ` (thread ${args.thread})` : ""}`,
-      `  File:  ${args.filePath}`,
-      `  Title: ${title}`,
-      `  Size:  ${sizeFmt}`,
-      `─────────────────────────────────────────────`,
-    ]);
+    const destLine = `  To:    ${args.target}${args.thread ? ` (thread ${args.thread})` : ""}`;
+    const lines = isBatch
+      ? [
+          `--- Uploading ${files.length} files ------------------------`,
+          destLine,
+          ...files.map((f) => `    ${f.filename}  (${f.sizeFmt})`),
+          `--------------------------------────────────`,
+        ]
+      : [
+          `--- Uploading file ---------------------------`,
+          destLine,
+          `  File:  ${files[0]!.fp}`,
+          `  Title: ${files[0]!.title}`,
+          `  Size:  ${files[0]!.sizeFmt}`,
+          `--------------------------------────────────`,
+        ];
+    requireCode(args.code, code, lines);
   }
 
-  const uploadOpts: { title?: string; threadTs?: string; initialComment?: string } = { title };
-  if (args.thread !== undefined) uploadOpts.threadTs = args.thread;
-  if (args.comment !== undefined) uploadOpts.initialComment = args.comment;
-  const { fileId, permalink } = await uploadFile(token, channelId, args.filePath, uploadOpts);
-  console.log(`✓ Uploaded (file_id: ${fileId}${permalink ? `, url: ${permalink}` : ""})`);
+  const total = files.length;
+  for (let i = 0; i < total; i++) {
+    const f = files[i]!;
+    const uploadOpts: { title?: string; threadTs?: string; initialComment?: string } = { title: f.title };
+    if (args.thread !== undefined) uploadOpts.threadTs = args.thread;
+    if (args.comment !== undefined && i === 0) uploadOpts.initialComment = args.comment;
+    const { fileId, permalink } = await uploadFile(token, channelId, f.fp, uploadOpts);
+    const prefix = total > 1 ? `[${i + 1}/${total}] ` : "";
+    console.log(`${prefix}✓ Uploaded (file_id: ${fileId}${permalink ? `, url: ${permalink}` : ""})`);
+  }
 }
 
 // --- dispatch ---
-function usage(): never {
-  console.error(
-    [
-      "Usage: slack [--workspace=<name>] <command> [args]",
-      "Commands:",
-      "  msgs [<#channel|@user|url>] [-n|--limit N]",
-      "  thread <#channel|@user|url> <ts> [-n|--limit N]",
-      "  channels [-n|--limit N] [--filter STR] [--all]",
-      "  news [-l|--limit N]",
-      "  search <query> [-n|--count N]",
-      "  drafts [--all]                  list pending drafts (--all includes sent)",
-      "  drafts new <#channel|@user> <text>",
-      "  drafts get <draft-id>",
-      "  drafts edit <draft-id> [--code=XXXX] <new-text>",
-      "  drafts delete <draft-id> [--code=XXXX]",
-      "  send <target> <message> [--thread TS] [--code XXXX] [--channel-id ID] [--user-id ID]",
-      "  edit <#chan:ts|@user:ts|url> <new-text> [--code XXXX] [--channel-id ID]",
-      "  upload <target> <file> [--title TEXT] [--thread TS] [--comment TEXT] [--code XXXX] [--channel-id ID] [--user-id ID]",
-      "  dump [-d|--days N] [-l|--limit N] [-f|--filter STR]",
-      "  workspace ls|list",
-      "  workspace import          (auto-import from Slack desktop app)",
-      "  workspace add <name> <token>",
-      "  workspace set-token <name> <token>",
-      "  workspace set-cookie <name> <xoxd>  (store xoxd cookie for draft API)",
-      "  workspace use <name>",
-      "  workspace remove <name>",
-      "  workspace current",
-    ].join("\n"),
-  );
-  process.exit(2);
-}
-
-async function cmdWorkspace(sub: string, args: string[]): Promise<void> {
-  switch (sub) {
-    case "list":
-    case "ls": {
-      const profiles = listProfiles();
-      if (profiles.length === 0) {
-        console.log("No workspaces configured.");
-        console.log("Import from the Slack desktop app:  slack workspace import");
-        console.log("Or add manually:                    slack workspace add <name> <token>");
-        return;
-      }
-      for (const { name, profile, current } of profiles) {
-        console.log(`${current ? "* " : "  "}${name}  ${profile.team}  (${profile.user})  ${profile.url ?? ""}`);
-      }
-      return;
-    }
-    case "import": {
-      console.error("Scanning Slack desktop app...");
-      const sessions = await extractSessions();
-      if (sessions.length === 0) {
-        console.error("No sessions found. Make sure Slack is installed and you have logged in.");
-        return;
-      }
-      for (const s of sessions) {
-        const teamLabel = s.teamName ?? s.teamId;
-        console.error(`  Found: ${teamLabel} ${s.url ?? ""}`);
-        const name = teamLabel.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-        const profile: Parameters<typeof addProfile>[1] = {
-          token: s.token,
-          team: s.teamName ?? s.teamId,
-          teamId: s.teamId,
-          url: s.url ?? "",
-          user: "",
-        };
-        if (s.cookie) profile.cookie = s.cookie;
-        addProfile(name, profile);
-        const cookieNote = s.cookie ? " + xoxd cookie" : "";
-        console.log(`Added workspace "${name}": ${teamLabel}${cookieNote}`);
-      }
-      console.log(`\nNote: desktop app tokens (xoxc-) are internal Slack tokens.`);
-      console.log(`If API calls fail, replace with an xoxp- token:`);
-      console.log(`  slack workspace set-token <name> <xoxp-token>`);
-      console.log(`\nDone. Run: slack workspace ls`);
-      return;
-    }
-    case "add": {
-      const [name, token] = args;
-      if (!name || !token) {
-        console.error("Usage: slack workspace add <name> <token>");
-        process.exit(2);
-      }
-      console.error(`Verifying token...`);
-      const info = await authTest(token);
-      addProfile(name, { token, ...info });
-      console.log(`Added workspace "${name}": ${info.team} (${info.user})`);
-      return;
-    }
-    case "set-token": {
-      const [name, token] = args;
-      if (!name || !token) {
-        console.error("Usage: slack workspace set-token <name> <token>");
-        console.error("  Updates the token for an existing workspace profile.");
-        process.exit(2);
-      }
-      console.error(`Verifying token...`);
-      const info = await authTest(token);
-      addProfile(name, { token, ...info });
-      console.log(`Updated workspace "${name}": ${info.team} (${info.user})`);
-      return;
-    }
-    case "set-cookie": {
-      const [name, xoxd] = args;
-      if (!name || !xoxd) {
-        console.error("Usage: slack workspace set-cookie <name> <xoxd-value>");
-        console.error("  Stores the xoxd session cookie for draft API access.");
-        console.error("  Get it from: DevTools → Application → Cookies → slack.com → d");
-        process.exit(2);
-      }
-      const cookieVal = xoxd.startsWith("d=") ? xoxd.slice(2) : xoxd;
-      setCookie(name, cookieVal);
-      console.log(`Cookie set for workspace "${name}". Run: slack drafts`);
-      return;
-    }
-    case "use": {
-      const globalFlag = args.includes("-g");
-      const name = args.find((a) => a !== "-g");
-      if (!name) {
-        console.error("Usage: slack workspace use [-g] <name>");
-        console.error("  -g   write to ~/.slack-cli/workspace (global)");
-        console.error("       default: write to .slack-cli/workspace (local cwd)");
-        process.exit(2);
-      }
-      if (!globalFlag) ensureSlackCliDir(join(process.cwd(), ".slack-cli"));
-      useProfile(name, globalFlag);
-      const scope = globalFlag ? "globally (~/.slack-cli/workspace)" : "locally (.slack-cli/workspace)";
-      console.log(`Switched to workspace "${name}" ${scope}`);
-      if (!globalFlag) console.log(`Tip: add .slack-cli/ to your .gitignore`);
-      return;
-    }
-    case "remove": {
-      const [name] = args;
-      if (!name) { console.error("Usage: slack workspace remove <name>"); process.exit(2); }
-      removeProfile(name);
-      console.log(`Removed workspace "${name}"`);
-      return;
-    }
-    case "current": {
-      const profiles = listProfiles();
-      const cur = profiles.find((p) => p.current);
-      if (!cur) { console.log("No workspace selected"); return; }
-      console.log(`${cur.name}  ${cur.profile.team}  (${cur.profile.user})`);
-      return;
-    }
-    default:
-      usage();
-  }
-}
 
 async function main(): Promise<void> {
   loadDotenvFiles();
 
-  // Strip global --workspace=<name> flag before subcommand dispatch.
-  const rawArgs = process.argv.slice(2);
-  let workspaceFlag: string | undefined;
-  const filteredArgs: string[] = [];
-  for (const arg of rawArgs) {
-    const m = arg.match(/^--workspace=(.+)$/);
-    if (m) { workspaceFlag = m[1]; }
-    else filteredArgs.push(arg);
-  }
-  const [cmd, ...rest] = filteredArgs;
-  // workspace subcommand needs no token
-  if (cmd === "workspace") {
-    await cmdWorkspace(rest[0] ?? "", rest.slice(1));
-    return;
-  }
-
-  const token = resolveToken(workspaceFlag);
-  const cookie = resolveCookie(workspaceFlag);
+  type W = { workspace?: string };
+  const tok = (a: W) => resolveToken(a.workspace);
+  const ck = (a: W) => resolveCookie(a.workspace);
 
-  switch (cmd) {
-    case "msgs": {
-      const { values, positionals } = parseArgs({
-        args: rest,
-        allowPositionals: true,
-        options: { limit: { type: "string", short: "n", default: "20" } },
-        strict: true,
-      });
-      if (positionals[0]) {
-        await cmdMsgsTarget(token, positionals[0], Number(values.limit));
-      } else {
-        await cmdMsgs(token);
-      }
-      return;
-    }
-    case "thread": {
-      const { values, positionals } = parseArgs({
-        args: rest,
-        allowPositionals: true,
-        options: { limit: { type: "string", short: "n", default: "100" } },
-        strict: true,
-      });
-      const target = positionals[0];
-      const ts = positionals[1];
-      if (!target || !ts) usage();
-      await cmdThread(token, target, ts, Number(values.limit));
-      return;
-    }
-    case "channels": {
-      const { values } = parseArgs({
-        args: rest,
-        options: {
-          limit: { type: "string", short: "n", default: "200" },
-          filter: { type: "string", short: "f" },
-          all: { type: "boolean" },
-        },
-        strict: true,
-      });
-      await cmdChannels(token, Number(values.limit), values.filter, values.all);
-      return;
-    }
-    case "news": {
-      const { values } = parseArgs({
-        args: rest,
-        options: { limit: { type: "string", short: "l", default: "20" } },
-        strict: true,
-      });
-      await cmdNews(token, Number(values.limit));
-      return;
-    }
-    case "drafts": {
-      const sub = rest[0];
-      if (sub === "new" || sub === "save") {
-        // drafts new <#channel|@user> <text...>
-        const args2 = rest.slice(1);
-        const target = args2[0];
-        const text = args2.slice(1).join(" ");
-        if (!target || !text) {
-          console.error("Usage: slack drafts new <#channel|@user> <text>");
-          process.exit(2);
-        }
-        const channelId = await resolveChannel(token, target, cookie);
-        const resp = (await createDraft(token, channelId, text, cookie)) as Record<string, Json>;
-        console.log(`✓ Draft created (id: ${asRecord(resp.draft).id ?? "?"})`);
-      } else if (sub === "get") {
-        const draftId = rest[1];
-        if (!draftId) { console.error("Usage: slack drafts get <draft-id>"); process.exit(2); }
-        await cmdDraftGet(token, cookie, draftId);
-      } else if (sub === "edit" || sub === "update") {
-        // drafts edit <draft-id> [--code=XXXX] <text...>
-        const draftId = rest[1];
-        const codeArg = rest.find((a) => a.startsWith("--code="))?.slice(7);
-        const textParts = rest.slice(2).filter((a) => !a.startsWith("--code="));
-        const text = textParts.join(" ");
-        if (!draftId || !text) {
-          console.error("Usage: slack drafts edit <draft-id> <new-text>");
-          process.exit(2);
-        }
-        const listResp = (await listDrafts(token, cookie)) as Record<string, Json>;
-        const d = asArray(listResp.drafts).map(asRecord).find((x) => String(x.id) === draftId);
-        if (!d) { console.error(`Draft not found: ${draftId}`); process.exit(1); }
-        const prevText = draftText(d);
-        const code = safetyCode(prevText, text);
-        if (codeArg !== code) {
-          requireCode(codeArg, code, [
-            `─── Current draft content ────────────────────`,
-            ...prevText.split("\n").map((l) => `  ${l}`),
-            `─── Replacing with ───────────────────────────`,
-            ...text.split("\n").map((l) => `  ${l}`),
-            `─────────────────────────────────────────────`,
-          ]);
+  await yargs(hideBin(process.argv))
+    .scriptName("slack")
+    .option("workspace", { alias: "w", type: "string", describe: "Workspace name" })
+    .middleware(async (argv) => {
+      const cmd = String((argv._ ?? [])[0] ?? "");
+      if (!cmd || cmd === "auth" || cmd === "login") return;
+      try {
+        resolveToken((argv as W).workspace);
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (msg.startsWith("No profiles configured")) {
+          console.log("No workspace configured. Let's set that up:\n");
+          await cmdAuthLogin();
+          process.exit(0);
         }
-        const channelId = draftChannelId(d);
-        const resp = (await updateDraft(token, draftId, channelId, text, cookie)) as Record<string, Json>;
-        console.log(`✓ Draft updated (id: ${asRecord(resp.draft).id ?? "?"})`);
-      } else if (sub === "delete" || sub === "rm") {
-        const draftId = rest[1];
-        const codeArg = rest.find((a) => a.startsWith("--code="))?.slice(7);
-        if (!draftId) { console.error("Usage: slack drafts delete <draft-id>"); process.exit(2); }
-        const listResp = (await listDrafts(token, cookie)) as Record<string, Json>;
-        const d = asArray(listResp.drafts).map(asRecord).find((x) => String(x.id) === draftId);
-        if (!d) { console.error(`Draft not found: ${draftId}`); process.exit(1); }
-        const prevText = draftText(d);
-        const code = safetyCode(draftId, prevText);
-        if (codeArg !== code) {
-          requireCode(codeArg, code, [
-            `─── Deleting draft ───────────────────────────`,
-            `  id: ${draftId}`,
-            ...prevText.split("\n").map((l) => `  ${l}`),
-            `─────────────────────────────────────────────`,
-          ]);
-        }
-        await deleteDraft(token, draftId, cookie);
-        console.log(`✓ Draft deleted (id: ${draftId})`);
-      } else {
-        const showAll = rest.includes("--all") || rest.includes("-a");
-        await cmdDrafts(token, cookie, showAll);
+        throw e;
       }
-      return;
-    }
-    case "search": {
-      const { values, positionals } = parseArgs({
-        args: rest,
-        allowPositionals: true,
-        options: { count: { type: "string", short: "n", default: "100" } },
-        strict: true,
-      });
-      const query = positionals[0];
-      if (!query) usage();
-      await cmdSearch(token, query, Number(values.count));
-      return;
-    }
-    case "send": {
-      const { values, positionals } = parseArgs({
-        args: rest,
-        allowPositionals: true,
-        options: {
-          thread: { type: "string" },
-          code: { type: "string" },
-          "channel-id": { type: "string" },
-          "user-id": { type: "string" },
-        },
-        strict: true,
+    }, true)
+    .command(
+      ["read [target]", "msgs [target]"],
+      "Browse messages",
+      (y) => y
+        .positional("target", { type: "string", describe: "#channel, @user, or URL" })
+        .option("limit", { alias: "n", type: "number", default: 20, describe: "Number of messages" }),
+      async (argv) => {
+        const token = tok(argv as W);
+        if (argv.target) await cmdMsgsTarget(token, argv.target, argv.limit);
+        else await cmdMsgs(token);
+      },
+    )
+    .command(
+      "thread <target> <ts>",
+      "Show thread messages",
+      (y) => y
+        .positional("target", { type: "string", demandOption: true })
+        .positional("ts", { type: "string", demandOption: true })
+        .option("limit", { alias: "n", type: "number", default: 100 }),
+      async (argv) => {
+        await cmdThread(tok(argv as W), argv.target!, argv.ts!, argv.limit);
+      },
+    )
+    .command(
+      ["channel", "channels", "ch"],
+      "Channel commands",
+      (y) => y
+        .command(
+          ["ls", "list"],
+          "List channels",
+          (y2) => y2
+            .option("limit", { alias: "n", type: "number", default: 200 })
+            .option("filter", { alias: "f", type: "string" })
+            .option("all", { type: "boolean", default: false })
+            .option("format", { type: "string", choices: ["text", "jsonl"] as const, default: "text" })
+            .option("json", { type: "boolean", default: false, describe: "Alias for --format=jsonl" }),
+          async (argv) => {
+            await cmdChannels(tok(argv as W), argv.limit, argv.filter, argv.all, argv.json ? "jsonl" : argv.format);
+          },
+        )
+        .command(
+          "get <channel>",
+          "Show channel details",
+          (y2) => y2.positional("channel", { type: "string", demandOption: true, describe: "#name or channel ID" }),
+          async (argv) => {
+            const token = tok(argv as W);
+            const ref = argv.channel!;
+            const channelRef = ref.startsWith("#") || ref.startsWith("@") || ref.startsWith("C") || ref.startsWith("G") || ref.startsWith("D") ? ref : `#${ref}`;
+            const channelId = await resolveChannel(token, channelRef);
+            const resp = asRecord((await conversationInfo(token, channelId)) as Json);
+            const ch = asRecord(resp.channel);
+            const name = typeof ch.name === "string" ? ch.name : channelId;
+            const isIm = ch.is_im === true;
+            const prefix = isIm ? "@" : "#";
+            const purpose = String(asRecord(ch.purpose).value ?? "");
+            const topic = String(asRecord(ch.topic).value ?? "");
+            const memberCount = ch.num_members ?? ch.member_count ?? "";
+            console.log(`${prefix}${name}  ${channelId}`);
+            if (topic) console.log(`topic:   ${topic}`);
+            if (purpose) console.log(`purpose: ${purpose}`);
+            if (memberCount) console.log(`members: ${memberCount}`);
+            console.log(`private: ${ch.is_private === true}`);
+          },
+        )
+        .demandCommand(1, "")
+        .showHelpOnFail(true),
+    )
+    .command(
+      ["user", "usr"],
+      "User commands",
+      (y) => y
+        .command(
+          ["ls", "list"],
+          "List workspace members",
+          (y2) => y2
+            .option("limit", { alias: "n", type: "number", default: 200 })
+            .option("filter", { alias: "f", type: "string" })
+            .option("format", { type: "string", choices: ["text", "jsonl", "yaml"] as const, default: "text" })
+            .option("json", { type: "boolean", default: false, describe: "Alias for --format=jsonl" }),
+          async (argv) => {
+            const format = argv.json ? "jsonl" : argv.format;
+            const resp = (await listUsers(tok(argv as W))) as Record<string, Json>;
+            const filter = argv.filter?.toLowerCase();
+            const members = asArray(resp.members)
+              .map(asRecord)
+              .filter((u) => u.deleted !== true && u.is_bot !== true && String(u.id) !== "USLACKBOT")
+              .filter((u) => {
+                if (!filter) return true;
+                const name = String(u.name ?? "").toLowerCase();
+                const real = String(asRecord(u.profile).real_name ?? "").toLowerCase();
+                const email = String(asRecord(u.profile).email ?? "").toLowerCase();
+                return name.includes(filter) || real.includes(filter) || email.includes(filter);
+              })
+              .slice(0, argv.limit);
+            if (format === "jsonl") {
+              for (const u of members) console.log(JSON.stringify(u));
+              return;
+            }
+            if (format === "yaml") {
+              for (const u of members) {
+                console.log("---");
+                function yamlVal(v: Json, indent = ""): string {
+                  if (v === null) return "null";
+                  if (typeof v === "string") return v.includes("\n") ? `|\n  ${v.split("\n").join("\n  ")}` : v;
+                  if (typeof v !== "object") return String(v);
+                  if (Array.isArray(v)) return v.map((i) => `\n${indent}  - ${yamlVal(i, indent + "  ")}`).join("");
+                  return Object.entries(v as Record<string, Json>).map(([k, val]) =>
+                    `\n${indent}  ${k}: ${yamlVal(val, indent + "  ")}`).join("");
+                }
+                for (const [k, v] of Object.entries(u)) console.log(`${k}: ${yamlVal(v)}`);
+              }
+              return;
+            }
+            const localTz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+            for (const u of members) {
+              const profile = asRecord(u.profile);
+              const handle = String(u.name ?? u.id);
+              const id = String(u.id ?? "");
+              const display = String(profile.display_name || "");
+              const real = String(profile.real_name || "");
+              const email = String(profile.email || "");
+              const tz = String(u.tz ?? "");
+              const names = [...new Set([display, real].filter((s) => s && s !== handle))];
+              const parts = names.join(" / ");
+              const tzPart = tz && tz !== localTz ? tz : "";
+              const meta = [email, tzPart].filter(Boolean).join("  ");
+              console.log(`@${handle}  ${id}  ${parts}${meta ? "  " + meta : ""}`);
+            }
+          },
+        )
+        .command(
+          "get <user>",
+          "Show user details",
+          (y2) => y2.positional("user", { type: "string", demandOption: true, describe: "@handle or user ID" }),
+          async (argv) => {
+            const token = tok(argv as W);
+            const ref = argv.user!.startsWith("@") ? argv.user!.slice(1) : argv.user!;
+            // If not a Slack user ID (U + alphanumeric), resolve from users list by handle
+            let userId = ref;
+            if (!/^U[A-Z0-9]+$/.test(ref)) {
+              const listResp = (await listUsers(token)) as Record<string, Json>;
+              const match = asArray(listResp.members).map(asRecord)
+                .find((u) => String(u.name ?? "") === ref);
+              if (!match) { console.error(`User not found: @${ref}`); process.exit(1); }
+              userId = String(match.id);
+            }
+            const resp = asRecord((await userInfo(token, userId)) as Json);
+            const u = asRecord(resp.user);
+            const profile = asRecord(u.profile);
+            const localTz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+            const handle = String(u.name ?? userId);
+            const id = String(u.id ?? userId);
+            const display = String(profile.display_name || "");
+            const real = String(profile.real_name || "");
+            const email = String(profile.email || "");
+            const tz = String(u.tz ?? "");
+            const phone = String(profile.phone || "");
+            const title = String(profile.title || "");
+            console.log(`@${handle}  ${id}`);
+            const names = [...new Set([display, real].filter((s) => s && s !== handle))];
+            if (names.length) console.log(`name:  ${names.join(" / ")}`);
+            if (email) console.log(`email: ${email}`);
+            if (phone) console.log(`phone: ${phone}`);
+            if (title) console.log(`title: ${title}`);
+            if (tz && tz !== localTz) console.log(`tz:    ${tz}`);
+          },
+        )
+        .demandCommand(1, "")
+        .showHelpOnFail(true),
+    )
+    .command(
+      "news",
+      "Activity feed (mentions to you)",
+      (y) => y.option("limit", { alias: "l", type: "number", default: 20 }),
+      async (argv) => {
+        await cmdNews(tok(argv as W), argv.limit);
+      },
+    )
+    .command(
+      "search <query>",
+      "Full-text search",
+      (y) => y
+        .positional("query", { type: "string", demandOption: true })
+        .option("count", { alias: "n", type: "number", default: 100 })
+        .option("json", { type: "boolean", default: false, describe: "Output raw JSON" }),
+      async (argv) => {
+        await cmdSearch(tok(argv as W), argv.query!, argv.count, argv.json);
+      },
+    )
+    .command(
+      "send <target> <message>",
+      "Send a message (confirm-hash safety gate)",
+      (y) => y
+        .positional("target", { type: "string", demandOption: true })
+        .positional("message", { type: "string", demandOption: true })
+        .option("thread", { type: "string", describe: "Thread timestamp" })
+        .option("code", { type: "string", describe: "Safety hash to confirm send" })
+        .option("channel-id", { type: "string", describe: "Raw channel ID" })
+        .option("user-id", { type: "string", describe: "Raw user ID (opens DM)" }),
+      async (argv) => {
+        const args: SendArgs = { target: argv.target!, message: argv.message! };
+        if (argv.thread) args.thread = argv.thread;
+        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"];
+        await cmdSend(tok(argv as W), args);
+      },
+    )
+    .command(
+      "schedule",
+      "Manage scheduled messages",
+      (y) => y
+        .command(
+          "send <target> <message>",
+          "Schedule a message for later delivery",
+          (y2) => y2
+            .positional("target", { type: "string", demandOption: true })
+            .positional("message", { type: "string", demandOption: true })
+            .option("at", { type: "string", demandOption: true, describe: "Delivery time (ISO datetime or Unix ts)" })
+            .option("thread", { type: "string", describe: "Thread timestamp" })
+            .option("code", { type: "string", describe: "Safety hash to confirm" })
+            .option("channel-id", { type: "string", describe: "Raw channel ID" })
+            .option("user-id", { type: "string", describe: "Raw user ID (opens DM)" }),
+          async (argv) => {
+            const args: ScheduleSendArgs = { target: argv.target!, message: argv.message!, at: argv.at! };
+            if (argv.thread) args.thread = argv.thread;
+            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"];
+            await cmdScheduleSend(tok(argv as W), args);
+          },
+        )
+        .command(
+          ["ls", "list"],
+          "List pending scheduled messages",
+          (y2) => y2
+            .positional("target", { type: "string", describe: "#channel to filter by" })
+            .option("channel-id", { type: "string", describe: "Raw channel ID" }),
+          async (argv) => {
+            await cmdScheduleList(tok(argv as W), argv.target as string | undefined, argv["channel-id"]);
+          },
+        )
+        .command(
+          "rm <target> <id>",
+          "Delete a scheduled message",
+          (y2) => y2
+            .positional("target", { type: "string", demandOption: true, describe: "#channel or @user" })
+            .positional("id", { type: "string", demandOption: true, describe: "Scheduled message ID" })
+            .option("code", { type: "string", describe: "Safety hash to confirm" })
+            .option("channel-id", { type: "string", describe: "Raw channel ID" }),
+          async (argv) => {
+            const args: ScheduleRmArgs = { target: argv.target!, id: argv.id! };
+            if (argv.code) args.code = argv.code;
+            if (argv["channel-id"]) args.channelId = argv["channel-id"];
+            await cmdScheduleRm(tok(argv as W), args);
+          },
+        )
+        .demandCommand(1, "")
+        .showHelpOnFail(true),
+      () => {},
+    )
+    .command(
+      "edit <target> <newText>",
+      "Edit a sent message",
+      (y) => y
+        .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("channel-id", { type: "string", describe: "Raw channel ID" }),
+      async (argv) => {
+        const args: EditArgs = { target: argv.target!, newText: argv.newText! };
+        if (argv.code) args.code = argv.code;
+        if (argv["channel-id"]) args.channelId = argv["channel-id"];
+        await cmdEdit(tok(argv as W), args);
+      },
+    )
+    .command(
+      "upload <target> <file..>",
+      "Upload one or more files to a channel or DM",
+      (y) => y
+        .positional("target", { type: "string", demandOption: true })
+        .positional("file", { type: "string", array: true, demandOption: true, describe: "Path(s) to file(s)" })
+        .option("title", { type: "string", describe: "Title (single file only)" })
+        .option("thread", { type: "string", describe: "Thread timestamp" })
+        .option("comment", { type: "string", describe: "Initial comment (first file)" })
+        .option("code", { type: "string", describe: "4-hex safety code to confirm upload" })
+        .option("channel-id", { type: "string" })
+        .option("user-id", { type: "string" }),
+      async (argv) => {
+        const args: UploadArgs = { target: argv.target!, filePaths: argv.file as string[] };
+        if (argv.title) args.title = argv.title;
+        if (argv.thread) args.thread = argv.thread;
+        if (argv.comment) args.comment = argv.comment;
+        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"];
+        await cmdUpload(tok(argv as W), args);
+      },
+    )
+    .command(
+      "dump",
+      "Bulk export channel history as markdown",
+      (y) => y
+        .option("days", { alias: "d", type: "number", default: 7, describe: "Days of history" })
+        .option("limit", { alias: "l", type: "number", default: 200 })
+        .option("filter", { alias: "f", type: "string", describe: "Filter channel names" }),
+      async (argv) => {
+        await cmdDump(tok(argv as W), argv.days, argv.limit, argv.filter);
+      },
+    )
+    .command(
+      "drafts",
+      "Manage message drafts (requires xoxc desktop token)",
+      (y) => y
+        .command(
+          ["$0", "ls", "list"],
+          "List pending drafts",
+          (y2) => y2.option("all", { alias: "a", type: "boolean", default: false, describe: "Include sent drafts" }),
+          async (argv) => {
+            await cmdDrafts(tok(argv as W), ck(argv as W), argv.all);
+          },
+        )
+        .command(
+          ["new <channel> [text..]", "save <channel> [text..]"],
+          "Create a draft",
+          (y2) => y2
+            .positional("channel", { type: "string", demandOption: true })
+            .positional("text", { type: "string", array: true, default: [] }),
+          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); }
+            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 ?? "?"})`);
+          },
+        )
+        .command(
+          "get <id>",
+          "Show a draft",
+          (y2) => y2.positional("id", { type: "string", demandOption: true }),
+          async (argv) => {
+            await cmdDraftGet(tok(argv as W), ck(argv as W), argv.id!);
+          },
+        )
+        .command(
+          ["edit <id> [text..]", "update <id> [text..]"],
+          "Edit a draft",
+          (y2) => y2
+            .positional("id", { type: "string", demandOption: true })
+            .positional("text", { type: "string", array: true, default: [] })
+            .option("code", { type: "string" }),
+          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); }
+            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); }
+            const prevText = draftText(d);
+            const code = safetyCode(prevText, text);
+            if (argv.code !== code) requireCode(argv.code, code, [
+              `--- Current draft ----------------------------`,
+              ...prevText.split("\n").map((l) => `  ${l}`),
+              `--- Replacing with ---------------------------`,
+              ...text.split("\n").map((l) => `  ${l}`),
+              `--------------------------------────────────`,
+            ]);
+            const resp = (await updateDraft(token, argv.id!, draftChannelId(d), text, cookie)) as Record<string, Json>;
+            console.log(`✓ Draft updated (id: ${asRecord(resp.draft).id ?? "?"})`);
+          },
+        )
+        .command(
+          ["delete <id>", "rm <id>"],
+          "Delete a draft",
+          (y2) => y2
+            .positional("id", { type: "string", demandOption: true })
+            .option("code", { type: "string" }),
+          async (argv) => {
+            const token = tok(argv as W); const cookie = ck(argv as W);
+            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); }
+            const prevText = draftText(d);
+            const code = safetyCode(argv.id!, prevText);
+            if (argv.code !== code) requireCode(argv.code, code, [
+              `─-- Deleting draft ───────────────────────────`,
+              `  id: ${argv.id}`,
+              ...prevText.split("\n").map((l) => `  ${l}`),
+              `--------------------------------────────────`,
+            ]);
+            await deleteDraft(token, argv.id!, cookie);
+            console.log(`✓ Draft deleted (id: ${argv.id})`);
+          },
+        ),
+    )
+    .command(
+      "auth",
+      "Authentication and workspace management",
+      (y) => y
+        .command(
+          "login",
+          "Add a workspace (interactive or --token for non-interactive)",
+          (y2) => y2
+            .option("token", { type: "string", describe: "Token to save directly (non-interactive)" })
+            .option("name", { type: "string", describe: "Workspace name (used with --token)" }),
+          async (argv) => {
+            await cmdAuthLogin({
+              ...(argv.token !== undefined ? { token: argv.token } : {}),
+              ...(argv.name !== undefined ? { name: argv.name } : {}),
+            });
+          },
+        )
+        .command(["ls", "status"], "Show auth status", () => {}, () => {
+          const profiles = listProfiles();
+          if (profiles.length === 0) { console.log("No workspaces configured. Run: slack auth login"); return; }
+          for (const { name, profile, current } of profiles)
+            console.log(`${current ? "* " : "  "}${name}  ${profile.team}  (${profile.user})  ${profile.url ?? ""}`);
+        })
+        .command(
+          "use <name>",
+          "Switch active workspace",
+          (y2) => y2
+            .positional("name", { type: "string", demandOption: true })
+            .option("g", { type: "boolean", default: false, describe: "Write global lockfile (~/.slack-cli/workspace)" }),
+          (argv) => {
+            if (!argv.g) ensureSlackCliDir(join(process.cwd(), ".slack-cli"));
+            useProfile(argv.name!, argv.g);
+            console.log(`Switched to workspace "${argv.name}" ${argv.g ? "globally" : "locally"}`);
+          },
+        )
+        .command(
+          ["rm <name>", "remove <name>"],
+          "Remove a workspace",
+          (y2) => y2.positional("name", { type: "string", demandOption: true }),
+          (argv) => {
+            removeProfile(argv.name!);
+            console.log(`Removed workspace "${argv.name}"`);
+          },
+        )
+        .command("$0", false as unknown as string, () => {}, () => { y.showHelp(); process.exit(0); }),
+    )
+    .command(
+      "tail [target]",
+      "Stream new messages in real time (like tail -f)",
+      (y) => y
+        .positional("target", { type: "string", describe: "#channel or @user to follow" })
+        .option("since", { type: "string", describe: "Backfill from N ago (e.g. 10m, 2h, 1d)" })
+        .option("thread", { type: "string", describe: "Follow a single thread by timestamp" })
+        .option("me", { type: "boolean", default: false, describe: "Filter to messages that mention you" })
+        .option("interval", { type: "number", default: 60000, describe: "Poll interval in ms (default 60s; use --interval=3000 for near-real-time)" })
+        .option("rtm", { type: "boolean", default: true, describe: "Use RTM WebSocket when available (xoxc + cookie); pass --no-rtm to force polling" }),
+      async (argv) => {
+        const token = tok(argv as W);
+        const cookie = ck(argv as W);
+        const signal = new AbortController();
+        process.on("SIGINT", () => { signal.abort(); process.exit(0); });
+        await cmdTail(token, argv.target, {
+          ...(argv.since !== undefined ? { since: argv.since } : {}),
+          ...(argv.thread !== undefined ? { thread: argv.thread } : {}),
+          me: argv.me,
+          interval: argv.interval,
+          ...(cookie !== undefined ? { cookie } : {}),
+          ...(argv.rtm === false ? { noRtm: true } : {}),
+        }, signal.signal);
+      },
+    )
+    .command("login", false as unknown as string, (y2) => y2
+      .option("token", { type: "string" })
+      .option("name", { type: "string" }), async (argv) => {
+      await cmdAuthLogin({
+        ...(argv.token !== undefined ? { token: argv.token } : {}),
+        ...(argv.name !== undefined ? { name: argv.name } : {}),
       });
-      const target = positionals[0];
-      const message = positionals[1];
-      if (!target || !message) usage();
-      const sendArgs: SendArgs = { target, message };
-      if (values.thread !== undefined) sendArgs.thread = values.thread;
-      if (values.code !== undefined) sendArgs.code = values.code;
-      if (values["channel-id"] !== undefined) sendArgs.channelId = values["channel-id"];
-      if (values["user-id"] !== undefined) sendArgs.userId = values["user-id"];
-      await cmdSend(token, sendArgs);
-      return;
-    }
-    case "edit": {
-      const { values, positionals } = parseArgs({
-        args: rest,
-        allowPositionals: true,
-        options: {
-          code: { type: "string" },
-          "channel-id": { type: "string" },
-        },
-        strict: true,
-      });
-      const target = positionals[0];
-      const newText = positionals[1];
-      if (!target || !newText) usage();
-      const editArgs: EditArgs = { target, newText };
-      if (values.code !== undefined) editArgs.code = values.code;
-      if (values["channel-id"] !== undefined) editArgs.channelId = values["channel-id"];
-      await cmdEdit(token, editArgs);
-      return;
-    }
-    case "upload": {
-      const { values, positionals } = parseArgs({
-        args: rest,
-        allowPositionals: true,
-        options: {
-          title: { type: "string" },
-          thread: { type: "string" },
-          comment: { type: "string" },
-          code: { type: "string" },
-          "channel-id": { type: "string" },
-          "user-id": { type: "string" },
-        },
-        strict: true,
-      });
-      const target = positionals[0];
-      const filePath = positionals[1];
-      if (!target || !filePath) usage();
-      const uploadArgs: UploadArgs = { target, filePath };
-      if (values.title !== undefined) uploadArgs.title = values.title;
-      if (values.thread !== undefined) uploadArgs.thread = values.thread;
-      if (values.comment !== undefined) uploadArgs.comment = values.comment;
-      if (values.code !== undefined) uploadArgs.code = values.code;
-      if (values["channel-id"] !== undefined) uploadArgs.channelId = values["channel-id"];
-      if (values["user-id"] !== undefined) uploadArgs.userId = values["user-id"];
-      await cmdUpload(token, uploadArgs);
-      return;
-    }
-    case "dump": {
-      const { values } = parseArgs({
-        args: rest,
-        options: {
-          days: { type: "string", short: "d", default: "7" },
-          limit: { type: "string", short: "l", default: "200" },
-          filter: { type: "string", short: "f" },
-        },
-        strict: true,
-      });
-      await cmdDump(token, Number(values.days), Number(values.limit), values.filter);
-      return;
-    }
-    default:
-      usage();
-  }
+    })
+    .demandCommand(1, "Specify a command. Run with --help for usage.")
+    .strict()
+    .help()
+    .alias("help", "h")
+    .parseAsync();
 }
 
 main().catch((e: unknown) => {
-  const msg = e instanceof Error ? e.message : String(e);
-  console.error(`Error: ${msg}`);
+  console.error(e instanceof Error ? e.message : String(e));
   process.exit(1);
 });