slack-term 1.24.0 → 1.25.0

package/ts/format.ts

@@ -38,7 +38,7 @@ export type MentionEncodeResult = {
 
 /** Full normalized name-forms of a member — the WHOLE display_name / real_name /
  *  name, never split into parts. An explicit `@name` mention must match a full
- *  name (`@柏原大空`), never a bare surname fragment (`@柏原`), which would be
+ *  name (`@鈴木陽菜`), never a bare surname fragment (`@鈴木`), which would be
  *  ambiguous. Length ≥ 2. */
 function fullNameForms(u: Record<string, Json>): string[] {
   const profile = asRecord(u.profile);
@@ -55,7 +55,7 @@ function fullNameForms(u: Record<string, Json>): string[] {
 type CjkMatch = { userId: string; matchLen: number; display: string } | "ambiguous" | undefined;
 
 /** Directory match for a CJK `@名前` token. `run` is the raw token after `@`
- *  (e.g. "柏原大空さん"). A user resolves only when the token equals their full
+ *  (e.g. "鈴木陽菜さん"). A user resolves only when the token equals their full
  *  name exactly, or equals their full name followed by exactly one trailing
  *  honorific ("さん", "様", …) which is then left in the message text rather than
  *  swallowed into the tag. Deliberately NOT a partial-prefix match: it would
@@ -105,9 +105,9 @@ function matchCjkRun(run: string, dir: Record<string, Json>[]): CjkMatch {
  * Rewrite `@handle` / `@名前` tokens in `text` to `<@USERID>` so Slack renders
  * them as real mentions, returning a structured report of what did and did not
  * resolve. Two kinds of token are recognized:
- *   - ASCII handles (`@alice`, `@t.matsuda19790127`) — matched whole against
+ *   - ASCII handles (`@alice`, `@t.yamada19850101`) — matched whole against
  *     name / real_name / display_name / email.
- *   - CJK names (`@柏原大空`, `@柏原大空さん`) — matched against the directory by
+ *   - CJK names (`@鈴木陽菜`, `@鈴木陽菜さん`) — matched against the directory by
  *     exact full name, or full name + one trailing honorific (kept outside the
  *     tag). A display name written in kanji/kana (which the old ASCII-only regex
  *     could not even capture) resolves; anything only partially matching stays
@@ -129,8 +129,8 @@ export async function encodeMentionsDetailed(
   const NAME_RUN = `[${NAME_CHARS}ー]+`;
   // One mention token = runs of name characters (any script) joined by internal
   // `. _ -`, so a mixed-script / dotted handle is captured WHOLE: `@田中Taro`,
-  // `@佐藤.dev`, `@t.matsuda19790127`, `@Alice-A`. It never ends on a separator,
-  // so a trailing sentence dot ("@taku.") is left out. Capturing the FULL token —
+  // `@佐藤.dev`, `@t.yamada19850101`, `@Alice-A`. It never ends on a separator,
+  // so a trailing sentence dot ("@alice.") is left out. Capturing the FULL token —
   // never a script-boundary prefix — is what lets the fail-closed exact match
   // refuse to tag "田中" from "@田中Taro". Lookbehind guard skips emails (`a@b`),
   // already-encoded `<@U…>`, and doubled `@@`.
@@ -280,8 +280,8 @@ export async function encodeMentions(
 
 // --- untagged-mention lint (warn-only) -------------------------------------
 // Flags names written as plain text that map to a known workspace member but
-// carry no <@USERID> tag in the same message — the footgun where "松田さん"
-// reads fine to a human but never actually notifies 松田. Never blocks a send.
+// carry no <@USERID> tag in the same message — the footgun where "山田さん"
+// reads fine to a human but never actually notifies 山田. Never blocks a send.
 
 // Person-reference cues. Honorific *suffixes* follow a name (JP + ZH); greeting
 // *prefixes* precede one (EN, handled by regex below). Extend freely.
@@ -337,7 +337,7 @@ function matchMemberForm(ref: string, forms: string[]): string | undefined {
   const nr = normHandle(ref);
   if (nr.length < 2) return undefined;
   // Exact first so the surface rebuilds to the tightest name (e.g. an
-  // over-captured "ください松田" still reports "松田", not the whole run).
+  // over-captured "ください山田" still reports "山田", not the whole run).
   for (const f of forms) if (nr === f) return f;
   if (isCjk(ref)) {
     for (const f of forms) if (nr.includes(f) || f.includes(nr)) return f;
@@ -391,6 +391,9 @@ export async function resolveMentions(
   token: string,
   text: string,
   cache: Map<string, string>,
+  // Session cookie (xoxd) for `token` — an xoxc- desktop token is rejected by
+  // users.info without it, which would leave every mention unresolved.
+  cookie?: string,
 ): Promise<string> {
   let result = text;
   const ids: string[] = [];
@@ -406,7 +409,7 @@ export async function resolveMentions(
     searchOffset = pos + 1;
   }
   for (const uid of ids) {
-    if (!cache.has(uid)) cache.set(uid, await userName(token, uid));
+    if (!cache.has(uid)) cache.set(uid, await userName(token, uid, cookie));
     const display = cache.get(uid) ?? uid;
     result = result.replaceAll(`<@${uid}>`, `@${display}`);
     // Handle <@UID|label> form — drop label.

package/ts/slack.ts

@@ -150,7 +150,7 @@ export async function authTest(
 // scopes in the `X-OAuth-Scopes` response header on every Web API call, which is
 // the only way to learn what a token can do without probing each endpoint.
 export async function authScopes(token: string, cookie?: string): Promise<{
-  userId: string; botId: string; team: string; url: string; scopes: string[];
+  userId: string; user: string; botId: string; team: string; url: string; scopes: string[];
 }> {
   const headers: Record<string, string> = { Authorization: `Bearer ${token}` };
   if (cookie) headers["Cookie"] = `d=${cookie}`;
@@ -161,11 +161,14 @@ export async function authScopes(token: string, cookie?: string): Promise<{
   }
   const scopesHeader = res.headers.get("x-oauth-scopes") ?? "";
   const body = (await res.json()) as {
-    ok?: boolean; error?: string; user_id?: string; bot_id?: string; team?: string; url?: string;
+    ok?: boolean; error?: string; user_id?: string; user?: string; bot_id?: string; team?: string; url?: string;
   };
   if (body.ok !== true) throw new Error(`Slack error on auth.test: ${body.error ?? "unknown"}`);
   return {
     userId: body.user_id ?? "",
+    // The token owner's @handle (for a bot token, the bot user's name) — lets a
+    // caller name the sending identity without a second auth.test round-trip.
+    user: body.user ?? "",
     botId: body.bot_id ?? "",
     team: body.team ?? "",
     url: body.url ?? "",
@@ -234,6 +237,25 @@ export async function filesList(
   return get(token, "files.list", params, cookie);
 }
 
+// Slack Lists ("tasklist"). The public slackLists.* Web API rejects the CLI's
+// xoxc desktop token (not_allowed_token_type) and needs a bot token with
+// lists:read; the web client instead uses the internal lists.records.list, which
+// DOES accept an xoxc token + the d cookie — so this reuses the CLI's existing
+// session auth. `listId` is the list's file id (F…), taken from its URL; there
+// is no list-enumeration API, so the caller must supply the id. Paginated by
+// cursor via response_metadata.next_cursor.
+export async function listRecords(
+  token: string,
+  listId: string,
+  opts: { limit?: number; cursor?: string } = {},
+  cookie?: string,
+): Promise<Json> {
+  const params: Record<string, string> = { list_id: listId };
+  if (opts.limit) params.limit = String(opts.limit);
+  if (opts.cursor) params.cursor = opts.cursor;
+  return postSession(token, "lists.records.list", params, cookie);
+}
+
 export async function searchPage(
   token: string,
   query: string,
@@ -389,6 +411,24 @@ export async function reactionAdd(
   await post(token, "reactions.add", { channel, timestamp: ts, name }, cookie);
 }
 
+// Read the reactions currently on a message. Returns one entry per emoji with
+// the user IDs that reacted, so callers can tell "someone reacted" from "I
+// reacted". Never cached — reaction state is exactly what todo commands mutate.
+export async function reactionsGet(
+  token: string,
+  channel: string,
+  ts: string,
+  cookie?: string,
+): Promise<{ name: string; users: string[] }[]> {
+  const resp = (await get(token, "reactions.get", { channel, timestamp: ts, full: "true" }, cookie)) as {
+    message?: { reactions?: Array<{ name?: string; users?: string[] }> };
+  };
+  return (resp.message?.reactions ?? []).map((r) => ({
+    name: String(r.name ?? ""),
+    users: Array.isArray(r.users) ? r.users.map(String) : [],
+  }));
+}
+
 export async function reactionRemove(
   token: string,
   channel: string,

package/ts/tail.ts

@@ -62,6 +62,7 @@ async function formatTailLine(
   m: Record<string, Json>,
   cache: Map<string, string>,
   chLabel?: string,
+  cookie?: string,
 ): Promise<string> {
   const rawTs = typeof m.ts === "string" ? m.ts : "0.000000";
   const stamp = slackTsToIso(rawTs);
@@ -70,7 +71,7 @@ async function formatTailLine(
     const uid = m.user;
     const handleKey = "@" + uid;
     if (!cache.has(handleKey)) {
-      const [, h] = await userInfoPair(token, uid);
+      const [, h] = await userInfoPair(token, uid, cookie);
       cache.set(handleKey, h);
     }
     handle = cache.get(handleKey) ?? uid;
@@ -78,7 +79,7 @@ async function formatTailLine(
     handle = m.username;
   }
   const raw = typeof m.text === "string" ? m.text : "";
-  const resolved = resolveDateMarkup(await resolveMentions(token, raw, cache));
+  const resolved = resolveDateMarkup(await resolveMentions(token, raw, cache, cookie));
   const lines = resolved.split("\n");
   const body = lines[0] + (lines.length > 1 ? "\n" + lines.slice(1).map((l) => `  ${l}`).join("\n") : "");
   // Annotate thread replies so a merged channel+thread stream stays readable.
@@ -95,6 +96,7 @@ type PollOpts = {
   watchThread?: string;
   me?: boolean;
   myUserId?: string;
+  cookie?: string;
 };
 
 export async function pollCycle(
@@ -112,6 +114,7 @@ export async function pollCycle(
     20,
     pageCursor ? undefined : (cursor || undefined),
     pageCursor,
+    opts.cookie,
   )) as Json);
   // history returns newest-first; reverse to emit oldest-first
   const histMsgs = asArray(histResp.messages).map(asRecord).reverse();
@@ -128,7 +131,7 @@ export async function pollCycle(
   // history — drop it to avoid double-emit.
   let replyMsgs: Record<string, Json>[] = [];
   if (opts.watchThread && !pageCursor) {
-    const repResp = asRecord((await replies(token, channelId, opts.watchThread, 50)) as Json);
+    const repResp = asRecord((await replies(token, channelId, opts.watchThread, 50, opts.cookie)) as Json);
     replyMsgs = asArray(repResp.messages).map(asRecord)
       .filter((m) => (typeof m.ts === "string" ? m.ts : "") !== opts.watchThread);
   }
@@ -176,7 +179,7 @@ export async function pollCycle(
       if (oldest !== undefined) seen.delete(oldest);
     }
 
-    lines.push(await formatTailLine(token, m, cache));
+    lines.push(await formatTailLine(token, m, cache, undefined, opts.cookie));
     // Advance the history cursor only on top-level messages — thread replies
     // are never returned by history(), so their ts must not move `oldest`.
     if (fromHistory) newCursor = ts;
@@ -244,7 +247,7 @@ export async function cmdTail(
 
   // Preflight: verify channel access before entering the poll loop
   try {
-    const info = asRecord(await conversationInfo(token, channelId) as Json);
+    const info = asRecord(await conversationInfo(token, channelId, opts.cookie) as Json);
     const ch = asRecord(info.channel as Json);
     if (ch.is_archived === true) {
       console.error(`Warning: this channel is archived — no new messages will arrive.`);
@@ -273,7 +276,7 @@ export async function cmdTail(
     cursor = (_internals.now() / 1000 - secondsBack).toFixed(6);
   } else {
     // Seed with most recent message so we only emit new messages going forward
-    const histResp = asRecord((await history(token, channelId, 1)) as Json);
+    const histResp = asRecord((await history(token, channelId, 1, undefined, undefined, opts.cookie)) as Json);
     const msgs = asArray(histResp.messages).map(asRecord);
     if (msgs.length > 0 && typeof msgs[0]?.ts === "string") {
       cursor = msgs[0].ts;
@@ -285,7 +288,7 @@ export async function cmdTail(
 
   let myUserId: string | undefined;
   if (opts.me || opts.exitOnMessage) {
-    const info = await authTest(token);
+    const info = await authTest(token, opts.cookie);
     myUserId = info.userId || undefined;
   }
 
@@ -304,6 +307,7 @@ export async function cmdTail(
     ...(watchThreadTs !== undefined ? { watchThread: watchThreadTs } : {}),
     ...(opts.me !== undefined ? { me: opts.me } : {}),
     ...(myUserId !== undefined ? { myUserId } : {}),
+    ...(opts.cookie !== undefined ? { cookie: opts.cookie } : {}),
   };
 
   // RTM path: xoxc token + cookie + no backfill requested. Skipped when a