slack-term 1.32.1 → 1.32.3

package/package.json

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

package/ts/ask.ts

@@ -305,3 +305,109 @@ export function askParseMessage(text: string): AskParsed {
 
   return { kind: "open", question, reactable, overflow, threadOnly };
 }
+
+/** Did a free-text reply actually PICK one of the offered choices?
+ *
+ *  Reported from real use 2026-09-04: three options were offered, the answerer
+ *  replied 「没懂，能给我讲前因后果吗」 ("I don't follow — can you explain the
+ *  background?"), and `--waitFor` exited 0 with that stored AS the decision. Any
+ *  reply from an addressed person counted, because nothing compared the reply to
+ *  the candidates. A lane harvesting that unparks the work and proceeds with
+ *  nothing behind it, and the recorded answer reads as though he had chosen.
+ *
+ *  Deliberately NARROW. Every loosening here re-creates the same defect one step
+ *  further out, and the two error directions are not symmetric: calling a
+ *  non-answer an answer makes an automated flow act on a decision nobody took,
+ *  while calling an answer a non-answer parks it in front of a human who can
+ *  settle it with one reaction. So: an exact choice, a bare number, a keycap, or
+ *  a number introducing its own choice text. Nothing fuzzy, nothing partial —
+ *  "the second one" and "option B" are NOT matches, on purpose.
+ *
+ *  `choices` is the full candidate list, reactable and overflow together, in
+ *  presentation order. The overflow ones (11+) can only ever be answered as
+ *  text, so a matcher that ignored them would call every legitimate answer to a
+ *  long question "not chosen" — the failure the caller cannot see. */
+export type AskChoiceMatch =
+  | { kind: "chosen"; index: number }        // 1-based, matching the printed numbering
+  | { kind: "none" }
+  | { kind: "ambiguous"; indexes: number[] };
+
+/** Lowercase, NFKC-fold (full-width ７ and ７．become 7), strip decoration and
+ *  one trailing sentence mark, collapse runs of space. NFKC is what lets a reply
+ *  typed on a Japanese IME match a choice typed on an ASCII keyboard. */
+function askNormalizeChoice(s: string): string {
+  return s
+    .normalize("NFKC")
+    .replace(/[*_`~]/g, "")
+    .trim()
+    // Brackets and sentence marks are stripped in ONE class at each end rather
+    // than in two passes: 「中止」。 puts the full stop OUTSIDE the quote, so
+    // stripping quotes and then punctuation leaves the closing 」 behind and the
+    // reply stops matching a choice it plainly names.
+    .replace(/^[\s"'`「『（(\[]+/, "")
+    .replace(/[\s"'`」』）)\]。．.!！?？、,]+$/, "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .toLowerCase();
+}
+
+export function askMatchChoice(reply: string, choices: string[]): AskChoiceMatch {
+  const norm = askNormalizeChoice(reply);
+  if (!norm) return { kind: "none" };
+  const normChoices = choices.map(askNormalizeChoice);
+
+  const hits = new Set<number>();
+
+  // 1. The reply IS the choice text.
+  normChoices.forEach((c, i) => { if (c && c === norm) hits.add(i + 1); });
+
+  // 2. A keycap glyph, which is what someone copies out of the message when they
+  //    cannot react (a thread on mobile, or a choice past the tenth).
+  ASK_KEYCAPS.forEach((k, i) => {
+    if (i < choices.length && reply.trim() === k.glyph) hits.add(i + 1);
+  });
+
+  // 3. A number: bare, or introducing the choice it names. `1` and `1. foo` are
+  //    the same act. A number followed by DIFFERENT text is not a match — that
+  //    is someone writing prose that happens to start with a digit.
+  //
+  //    The separator is REQUIRED once text follows, and matched as its own
+  //    alternative rather than as an optional group. With it optional, `100`
+  //    parsed as choice 10 followed by "0" — so a ten-option question whose
+  //    tenth choice is "0" matched a reply nobody meant as a choice. That is the
+  //    expensive direction of the error, invented while fixing the same one.
+  //    (cross-vendor review, 2026-09-05)
+  let n = 0;
+  let rest = "";
+  let m = norm.match(/^(\d{1,2})$/);
+  if (m) {
+    n = Number(m[1]);
+  } else if ((m = norm.match(/^(\d{1,2})(?:\s*[.):：、。\-\]]\s*|\s+)(.*)$/))) {
+    n = Number(m[1]);
+    // Normalised AGAIN, not merely trimmed: `1. (Release)` reaches here as
+    // `(release` — the number kept the opening bracket from being stripped at
+    // the head of the string while the closing one went at the tail, leaving an
+    // unbalanced remainder that matched nothing. Re-running the same normaliser
+    // on the remainder is what makes a bracketed choice answerable by number.
+    rest = askNormalizeChoice(m[2]!);
+    // A separator with NOTHING after it is not a choice: `1 -` is someone who
+    // started typing and stopped, and selecting option 1 for them is the
+    // expensive error. `1.` and `1)` still work — their punctuation is stripped
+    // at the tail, so they arrive at the bare-number branch above.
+    if (!rest) return { kind: "none" };
+    // An all-digit remainder is a range or a score (`1-2`), not a numbered
+    // choice. Without this, a question whose options are themselves numbers
+    // matched `1-2` as "option 1, whose text is 2". Rejecting it fails to the
+    // CHEAP side: a genuine `1. 2` re-asks, a false selection does not.
+    if (/^\d+$/.test(rest)) return { kind: "none" };
+  }
+  if (n >= 1 && n <= choices.length && (rest === "" || rest === normChoices[n - 1])) hits.add(n);
+
+  const indexes = [...hits].sort((a, b) => a - b);
+  if (!indexes.length) return { kind: "none" };
+  // Two distinct choices matched — the same refusal-to-guess the poller already
+  // applies when someone presses two pills. Identical choice TEXT is the usual
+  // cause, and picking the lower index would answer with a coin flip.
+  if (indexes.length > 1) return { kind: "ambiguous", indexes };
+  return { kind: "chosen", index: indexes[0]! };
+}

package/ts/cli.ts

@@ -23,6 +23,7 @@ import {
   askParseMessage,
   askExplainReject,
   askFlatten,
+  askMatchChoice,
   applyInvalidNotice,
   readInvalidNotice,
   type AskFound,
@@ -1167,7 +1168,62 @@ interface EditArgs {
   // Session cookie (xoxd) for `token` — required for an xoxc- desktop session
   // token to be accepted by the public Slack API at all.
   cookie?: string;
+  asBot?: boolean;
+  /** The USER token, kept for mention resolution when the edit itself runs as
+   *  the bot. A bot token has no users:read, and an unresolved @handle degrades
+   *  to plain text SILENTLY — which is the precise failure `edit` exists to
+   *  correct, so re-introducing it here would be circular. Same split as
+   *  `send --as-bot`. */
+  mentionToken?: string;
+  mentionCookie?: string;
 }
+/** The bot token, plus the bot↔user DM when the target names an `@handle`.
+ *
+ *  Both halves are load-bearing. A bot token has no `users:read`, so resolving
+ *  `@bob` with it does not merely pick the wrong channel — it fails outright with
+ *  `missing_scope`, before the confirm gate is ever printed. And even where it
+ *  could resolve, a BOT-authored DM lives in the bot's conversation with that
+ *  person, not in the user's: looking the handle up as the user and opening the
+ *  DM as the bot is the only combination that names the message being corrected.
+ *  Same split `send --as-bot` makes.
+ *
+ *  Found by the cross-vendor review of this change, which also named why the
+ *  first round of tests missed it: they all targeted a permalink, and
+ *  `resolveChannel` parses those locally without touching the API. */
+async function asBotTarget(
+  target: string,
+  userToken: string,
+  userCookie: string | undefined,
+  /** Already known from `--channel-id`. Passed in so the DM lookup is SKIPPED
+   *  rather than performed and discarded: `conversations.open` is a side effect,
+   *  and opening a DM the caller did not ask for is not undone by ignoring the
+   *  result. */
+  knownChannelId?: string,
+): Promise<{ botToken: string; channelId?: string }> {
+  const botToken = resolveBotToken();
+  if (!botToken) {
+    console.error(
+      "Error: --as-bot needs a bot token, but no xoxb- token was found.\n" +
+      "  Set SLACK_BOT_TOKEN=xoxb-... in ~/.config/slack-cli/.env (or your shell).",
+    );
+    process.exit(1);
+  }
+  if (knownChannelId) return { botToken };
+  const { ref } = splitRefTs(target);
+  if (!ref.startsWith("@")) return { botToken };
+  try {
+    const userId = await resolveUserId(userToken, ref, userCookie);
+    return { botToken, channelId: await openDm(botToken, userId) };
+  } catch (e: unknown) {
+    console.error(
+      `Error: could not resolve ${stripTerminalControls(ref)} to the bot's DM.\n` +
+      `  ${e instanceof Error ? e.message : String(e)}\n` +
+      `  Tip: pass the message permalink, or --channel-id <D…>, to skip the lookup.`,
+    );
+    process.exit(1);
+  }
+}
+
 async function cmdEdit(token: string, args: EditArgs): Promise<void> {
   const getSelf = selfLookup(token, args.cookie);
   const { ref, ts } = splitRefTs(args.target);
@@ -1191,8 +1247,9 @@ async function cmdEdit(token: string, args: EditArgs): Promise<void> {
   const originalText = typeof original.text === "string" ? original.text : "";
 
   // Convert @handle → <@USERID> before hashing/editing (unresolved stay as text).
+  const mentionCookie = args.mentionCookie ?? args.cookie;
   const newText = args.mentions
-    ? await encodeMentions(token, args.newText, channelId, args.cookie ? { cookie: args.cookie } : {})
+    ? await encodeMentions(args.mentionToken ?? token, args.newText, channelId, mentionCookie ? { cookie: mentionCookie } : {})
     : args.newText;
 
   // Identity is part of the hash for the same reason it is on `send`: a code
@@ -1204,7 +1261,7 @@ async function cmdEdit(token: string, args: EditArgs): Promise<void> {
   if (args.code !== code) {
     requireCode(args.code, code, [
       `--- Editing as -------------------------------`,
-      fromLine(self),
+      fromLine(self, { asBot: args.asBot }),
       `--- Original message -------------------------`,
       ...originalText.split("\n").map((l) => `  ${l}`),
       `--- Replacing with ---------------------------`,
@@ -1223,6 +1280,7 @@ interface DeleteArgs {
   code?: string;
   channelId?: string;
   cookie?: string;
+  asBot?: boolean;
 }
 async function cmdDelete(token: string, args: DeleteArgs): Promise<void> {
   const getSelf = selfLookup(token, args.cookie);
@@ -1254,7 +1312,7 @@ async function cmdDelete(token: string, args: DeleteArgs): Promise<void> {
     const dest = await destLabel(token, channelId, ref, args.cookie);
     requireCode(args.code, code, [
       `--- Deleting message -------------------------`,
-      fromLine(self),
+      fromLine(self, { asBot: args.asBot }),
       `  → ${dest} at ${slackTsToIso(ts)}`,
       ...originalText.split("\n").map((l) => `  ${l}`),
       `---------------------------------------------`,
@@ -1642,12 +1700,18 @@ async function cmdSend(token: string, args: SendArgs): Promise<void> {
 // Exit codes are the contract for `--wait`, and a non-zero one must never be
 // mistakable for "an answer arrived":
 //   0  answered   (the answer text is on stdout, and nothing else is)
-//   2  timed out
+//   2  timed out   (nobody replied)
 //   3  transport/config failure
+//   4  replied, but chose none of the offered choices — stdout stays EMPTY
 // Everything human-facing goes to stderr, so `ANS=$(slack ask ... --wait)` is safe.
 
 const ASK_EXIT_TIMEOUT = 2;
 const ASK_EXIT_ERROR = 3;
+/** Somebody replied, and what they wrote picks none of the offered choices.
+ *  A THIRD state, distinct from both 0 and 2 on purpose: exit 0 would have an
+ *  automated caller act on a decision nobody took, and exit 2 ("nobody
+ *  answered") would hide that a human is standing there waiting for something. */
+const ASK_EXIT_UNCHOSEN = 4;
 
 const ASK_PHI = 1.618033988749895;
 const ASK_POLL_MIN_MS = 1000;
@@ -1730,6 +1794,11 @@ interface AskWaitCtx {
   threadParentTs?: string;
   question: string;
   reactable: string[];
+  /** Choices past the tenth. They carry NO reaction — text is the only way to
+   *  answer them — so they must be in the candidate list the reply is matched
+   *  against, or every legitimate answer to a long question reads as "chose
+   *  nothing". */
+  overflow: string[];
   threadOnly: boolean;
   /** Who may answer. Empty + broadcast=false would accept nobody, which is why
    *  posting an unaddressed question is refused up front. */
@@ -1763,6 +1832,12 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
   const isAnswerer = (user: unknown): user is string =>
     typeof user === "string" && !!user && user !== askerUserId && (broadcast || audience.has(user));
 
+  /** The earliest reply from an answerer that picked none of the choices. Kept
+   *  across polls so the timeout can report it, and so the operator is told once
+   *  rather than on every tick. */
+  let unchosen: { text: string; who: string; ts: string; ambiguous: boolean } | undefined;
+  let unchosenReported = "";
+
   /** Every seed an answerer is on — not just the first. Changing your mind
    *  leaves BOTH reactions in place (Slack only drops one when you actively
    *  un-react), so taking the lowest index would answer with the abandoned
@@ -1822,6 +1897,10 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
     return null;
   }
 
+  /** The full candidate list — reactable pills AND the text-only overflow —
+   *  empty when the question was asked free-text. */
+  const candidates = [...reactable, ...ctx.overflow];
+
   function answerFromMessages(messages: Record<string, Json>[], before = Infinity): AskFound | null {
     // Oldest first: if someone wrote twice, the first reply is the answer.
     const ordered = [...messages].sort((a, b) => Number(a.ts) - Number(b.ts));
@@ -1833,12 +1912,35 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
       if (typeof m.subtype === "string" && !ASK_ANSWERABLE_SUBTYPES.has(m.subtype)) continue;
       if (Number(m.ts) >= before) break;
       const t = typeof m.text === "string" ? m.text.trim() : "";
-      if (t) return { answer: t, how: "返信", who: m.user };
+      if (!t) continue;
+      // A question asked WITHOUT choices is answered by whatever comes back —
+      // there is nothing to match against, and every reply is the answer.
+      if (!candidates.length) return { answer: t, how: "返信", who: m.user };
+      const match = askMatchChoice(t, candidates);
+      if (match.kind === "chosen") {
+        // Answer with the CHOICE, not with the reply that selected it: "2" and
+        // "2. 中止" have to reach the caller as the same decision a pill would
+        // have produced, or the same answer arrives in three spellings.
+        return { answer: candidates[match.index - 1]!, how: `返信 (${match.index})`, who: m.user };
+      }
+      // Replied, but picked nothing. Recorded rather than returned: a later
+      // reply may still choose, and the first one is what the operator needs to
+      // see — it is usually a question back.
+      if (!unchosen || Number(m.ts) < Number(unchosen.ts)) {
+        unchosen = { text: t, who: typeof m.user === "string" ? m.user : "", ts: String(m.ts), ambiguous: match.kind === "ambiguous" };
+      }
     }
     return null;
   }
 
   async function poll(): Promise<AskFound | null> {
+    // Recomputed every pass rather than accumulated. A reply that has since been
+    // DELETED must stop counting: carrying it forward would let the timeout
+    // report "somebody replied and chose nothing" about a message that is no
+    // longer there, and exit 4 where exit 2 is the truth. `unchosenReported`
+    // persists on purpose — it is what keeps the operator from being told the
+    // same thing on every tick.
+    unchosen = undefined;
     // A question that is itself a thread reply is invisible to
     // `conversations.history`, so the entire poll — reactions included — has to
     // come from the thread.
@@ -1955,6 +2057,25 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
       console.log(found.answer);
       process.exit(0);
     }
+    // Said as soon as it is seen, not only at the timeout: the reply is usually
+    // a question BACK, and the person who can unblock it is the one watching
+    // this command. Once per reply — a poller that repeated itself every tick
+    // would be noise nobody reads.
+    if (unchosen && unchosen.ts !== unchosenReported) {
+      unchosenReported = unchosen.ts;
+      let who = unchosen.who;
+      try {
+        if (who) who = await userName(token, who, cookie);
+      } catch {
+        // the id is still a usable answer to "who"
+      }
+      console.error(
+        unchosen.ambiguous
+          ? `  (${stripTerminalControls(who)} の返信は複数の選択肢に一致します。1 つに絞ってもらうまで待ちます)`
+          : `  (${stripTerminalControls(who)} が返信しましたが、選択肢のどれでもありません。待機を続けます)`,
+      );
+      console.error(`    「${stripTerminalControls(unchosen.text)}」`);
+    }
     // Checked after the first poll, never before it: `--timeout 0` means one
     // look, and one look must still be a real look.
     if (Date.now() >= deadline) break;
@@ -1966,6 +2087,23 @@ async function askWaitForAnswer(token: string, ctx: AskWaitCtx): Promise<never>
   // question is still standing, and they have just decided not to block on it.
   // Printing only the permalink here leaves them where `ask` used to: holding a
   // link with nothing that reads a pressed pill back.
+  // Three states, not two. "Nobody replied" and "somebody replied and chose
+  // nothing" need different reactions from whoever reads this — the first waits,
+  // the second answers a person — and collapsing them into exit 2 hides a human
+  // standing there. stdout stays empty in both: the caller must not be handed
+  // something to act on.
+  if (unchosen) {
+    console.error(
+      unchosen.ambiguous
+        ? `Error: 返信はありましたが、複数の選択肢に一致するため確定できません (メッセージはそのまま残っています)`
+        : `Error: 返信はありましたが、選択肢のどれも選ばれていません (メッセージはそのまま残っています)`,
+    );
+    console.error(`  返信: 「${stripTerminalControls(unchosen.text)}」`);
+    console.error(`  選択肢: ${candidates.map((c, i) => `${i + 1}. ${stripTerminalControls(askFlatten(c))}`).join("  ")}`);
+    console.error(`  ${shown}`);
+    console.error(`  返答してから回収する:  ${askResumeCommand(shown, ctx.asBot)}`);
+    process.exit(ASK_EXIT_UNCHOSEN);
+  }
   if (timeout === 0) {
     console.error(`まだ回答がありません: ${shown}`);
   } else {
@@ -2190,6 +2328,7 @@ async function cmdAsk(token: string, args: AskArgs): Promise<void> {
     ts,
     question,
     reactable,
+    overflow,
     threadOnly,
     audience,
     broadcast,
@@ -2304,6 +2443,7 @@ async function cmdAskWaitFor(token: string, args: { link: string; timeout: numbe
     ts,
     question: parsed.question,
     reactable: parsed.reactable,
+    overflow: parsed.overflow,
     threadOnly: parsed.threadOnly,
     audience,
     broadcast,
@@ -3560,7 +3700,7 @@ async function main(): Promise<void> {
         .positional("choices", { type: "string", array: true, describe: "Up to 10 choices, seeded as 1️⃣..🔟 reactions. Beyond 10 they are listed but answerable only by text. With none, the question asks for a free-text reply." })
         .option("code", { type: "string", describe: "Safety hash to confirm the ask" })
         .option("body", { type: "string", describe: "Extra context shown under the question" })
-        .option("wait", { type: "boolean", default: false, describe: "Block until answered; print ONLY the answer on stdout. Exit 0 = answered, 2 = timed out, 3 = transport failure." })
+        .option("wait", { type: "boolean", default: false, describe: "Block until answered; print ONLY the answer on stdout. Exit 0 = answered, 2 = nobody replied, 3 = transport failure, 4 = somebody replied but picked none of the choices (stdout empty — do not act on it)." })
         .option("waitFor", { type: "string", describe: "Collect the answer to a question already posted: pass its permalink. Nothing is posted. Same stdout/exit contract as --wait; --timeout 0 checks once and exits 2 if still open." })
         .option("timeout", { type: "number", default: 3600, describe: "Overall limit for --wait / --waitFor, in seconds (0 with --waitFor = check once)" })
         .option("channel-id", { type: "string", describe: "Raw channel ID" })
@@ -3938,15 +4078,39 @@ async function main(): Promise<void> {
         .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" })
-        .option("mentions", { type: "boolean", default: true, describe: "Convert @handle tokens in the new text to real <@USERID> mentions (on by default). Unresolved handles stay as plain text. Disable with --no-mentions for literal @text." }),
+        .option("mentions", { type: "boolean", default: true, describe: "Convert @handle tokens in the new text to real <@USERID> mentions (on by default). Unresolved handles stay as plain text. Disable with --no-mentions for literal @text." })
+        .option("as-bot", { type: "boolean", default: false, describe: "Edit as the bot (xoxb / SLACK_BOT_TOKEN). REQUIRED to correct a message the bot posted: Slack only lets a token edit its OWN messages, so a bot-authored message is uneditable by the user token and chat.update returns cant_update_message. Address it by permalink or --channel-id; an @user target resolves against the BOT's DM list, which is where a bot-authored DM actually lives." }),
       async (argv) => {
         const args: EditArgs = { target: argv.target!, newText: argv.newText! };
         if (argv.code) args.code = argv.code;
         if (argv["channel-id"]) args.channelId = argv["channel-id"];
         if (argv.mentions !== false) args.mentions = true;
-        const cookie = ck(argv as W);
-        if (cookie) args.cookie = cookie;
-        await cmdEdit(tok(argv as W), args);
+        let editToken: string;
+        if (argv["as-bot"]) {
+          // --as-bot is not a switch on chat.update. It selects a DIFFERENT
+          // resolved token, and until now `edit` never wired one — so every
+          // message the bot posted was uncorrectable, and the workaround people
+          // reached for was RESENDING, which this repo's own etiquette forbids.
+          // Bot identity is what makes a DM notify at all, so "uncorrectable"
+          // applied to exactly the messages that matter most.
+          const resolved = await asBotTarget(args.target, tok(argv as W), ck(argv as W), args.channelId);
+          editToken = resolved.botToken;
+          if (resolved.channelId && !args.channelId) args.channelId = resolved.channelId;
+          args.asBot = true;
+          // Mentions still resolve on the USER token: the bot has no users:read,
+          // and a silently unresolved @handle in a CORRECTION is the same defect
+          // twice.
+          args.mentionToken = tok(argv as W);
+          const mc = ck(argv as W);
+          if (mc) args.mentionCookie = mc;
+        } else {
+          editToken = tok(argv as W);
+          // Not set under --as-bot: a bot token needs no session cookie, and
+          // attaching one is how a working call starts failing.
+          const cookie = ck(argv as W);
+          if (cookie) args.cookie = cookie;
+        }
+        await cmdEdit(editToken, args);
       },
     )
     .command(
@@ -3955,14 +4119,28 @@ async function main(): Promise<void> {
       (y) => y
         .positional("target", { type: "string", demandOption: true, describe: "#chan:ts, @user:ts, or permalink" })
         .option("code", { type: "string", describe: "Safety hash to confirm delete" })
-        .option("channel-id", { type: "string", describe: "Raw channel ID" }),
+        .option("channel-id", { type: "string", describe: "Raw channel ID" })
+        .option("as-bot", { type: "boolean", default: false, describe: "Delete as the bot (xoxb / SLACK_BOT_TOKEN). REQUIRED for a message the bot posted: chat.delete refuses another token's message exactly as chat.update does." }),
       async (argv) => {
         const args: DeleteArgs = { target: argv.target! };
         if (argv.code) args.code = argv.code;
         if (argv["channel-id"]) args.channelId = argv["channel-id"];
-        const cookie = ck(argv as W);
-        if (cookie) args.cookie = cookie;
-        await cmdDelete(tok(argv as W), args);
+        let deleteToken: string;
+        if (argv["as-bot"]) {
+          // The SECOND call site of one defect, not a second defect: `delete`
+          // had the identical unconditional `tok(argv)`, and chat.delete refuses
+          // another token's message exactly as chat.update does. Fixing one and
+          // leaving the other is how the next person finds it the hard way.
+          const resolved = await asBotTarget(args.target, tok(argv as W), ck(argv as W), args.channelId);
+          deleteToken = resolved.botToken;
+          if (resolved.channelId && !args.channelId) args.channelId = resolved.channelId;
+          args.asBot = true;
+        } else {
+          deleteToken = tok(argv as W);
+          const cookie = ck(argv as W);
+          if (cookie) args.cookie = cookie;
+        }
+        await cmdDelete(deleteToken, args);
       },
     )
     .command(