slack-term 1.13.0 → 1.14.0

package/package.json

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

package/ts/cli.ts

@@ -175,12 +175,21 @@ async function formatMsgLine(
 
 // --- 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));
+    }
   }
 }
 
@@ -1267,9 +1276,11 @@ async function main(): Promise<void> {
         .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("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, {
@@ -1277,6 +1288,8 @@ async function main(): Promise<void> {
           ...(argv.thread !== undefined ? { thread: argv.thread } : {}),
           me: argv.me,
           interval: argv.interval,
+          ...(cookie !== undefined ? { cookie } : {}),
+          ...(argv.rtm === false ? { noRtm: true } : {}),
         }, signal.signal);
       },
     )

package/ts/rtm.ts

@@ -0,0 +1,180 @@
+import { type Json, userInfoPair, clientBoot as clientBootImpl } from "./slack.ts";
+import { resolveDateMarkup, resolveMentions } from "./format.ts";
+
+export type RtmPollOpts = {
+  thread?: string;
+  me?: boolean;
+  myUserId?: string;
+};
+
+// Minimal WebSocket interface — avoids requiring DOM lib in tsconfig
+interface WsLike {
+  addEventListener(type: string, handler: (event: unknown) => void): void;
+  send(data: string): void;
+  close(): void;
+}
+interface WsConstructor {
+  new(url: string): WsLike;
+}
+
+function slackTsToIso(tsRaw: string): string {
+  const [secStr, fracStr = "000000"] = tsRaw.split(".");
+  const d = new Date(Number(secStr) * 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}`;
+}
+
+async function formatRtmLine(
+  token: string,
+  m: Record<string, Json>,
+  cache: Map<string, string>,
+): Promise<string> {
+  const rawTs = typeof m.ts === "string" ? m.ts : "0.000000";
+  const stamp = slackTsToIso(rawTs);
+  let handle = "?";
+  if (typeof m.user === "string") {
+    const uid = m.user;
+    const handleKey = "@" + uid;
+    if (!cache.has(handleKey)) {
+      const [, h] = await userInfoPair(token, uid);
+      cache.set(handleKey, h);
+    }
+    handle = cache.get(handleKey) ?? uid;
+  } else if (typeof m.username === "string") {
+    handle = m.username;
+  }
+  const raw = typeof m.text === "string" ? m.text : "";
+  const resolved = resolveDateMarkup(await resolveMentions(token, raw, cache));
+  const lines = resolved.split("\n");
+  const body = lines[0] + (lines.length > 1 ? "\n" + lines.slice(1).map((l) => `  ${l}`).join("\n") : "");
+  return `${stamp}  @${handle}:  ${body}`;
+}
+
+async function connectAndStream(
+  WS: WsConstructor,
+  token: string,
+  wsUrl: string,
+  channelId: string,
+  opts: RtmPollOpts,
+  seen: Set<string>,
+  cache: Map<string, string>,
+  signal?: AbortSignal,
+): Promise<void> {
+  // If already aborted before we even create the WS, resolve immediately.
+  if (signal?.aborted) return;
+  return new Promise<void>((resolve) => {
+    const ws = new WS(wsUrl);
+
+    signal?.addEventListener("abort", () => {
+      ws.close();
+      resolve();
+    }, { once: true } as AddEventListenerOptions);
+
+    ws.addEventListener("open", () => {
+      process.stderr.write("Connected via RTM (experimental).\n");
+    });
+
+    ws.addEventListener("close", () => resolve());
+
+    ws.addEventListener("error", () => resolve());
+
+    ws.addEventListener("message", (event: unknown) => {
+      void (async () => {
+        try {
+          let data: Record<string, Json>;
+          try {
+            data = JSON.parse(String((event as { data?: unknown }).data)) as Record<string, Json>;
+          } catch {
+            return;
+          }
+
+          const type = typeof data.type === "string" ? data.type : "";
+
+          if (type === "ping") {
+            ws.send(JSON.stringify({ type: "pong", reply_to: data.id ?? 0 }));
+            return;
+          }
+
+          if (type !== "message") return;
+
+          const msgChannel = typeof data.channel === "string" ? data.channel : "";
+          if (msgChannel !== channelId) return;
+
+          const ts = typeof data.ts === "string" ? data.ts : "";
+          if (!ts || seen.has(ts)) return;
+
+          const subtype = typeof data.subtype === "string" ? data.subtype : "";
+          if (subtype === "message_changed" || subtype === "message_deleted") return;
+
+          if (opts.thread) {
+            const parentTs = typeof data.thread_ts === "string" ? data.thread_ts : ts;
+            if (parentTs !== opts.thread && ts !== opts.thread) return;
+          }
+
+          if (opts.me && opts.myUserId) {
+            const text = typeof data.text === "string" ? data.text : "";
+            if (!text.includes(`<@${opts.myUserId}>`)) return;
+          }
+
+          seen.add(ts);
+          if (seen.size > 1000) {
+            const oldest = seen.values().next().value;
+            if (oldest !== undefined) seen.delete(oldest);
+          }
+
+          const line = await formatRtmLine(token, data, cache);
+          process.stdout.write(line + "\n");
+        } catch (e: unknown) {
+          process.stderr.write(`RTM message error: ${e instanceof Error ? e.message : String(e)}\n`);
+        }
+      })();
+    });
+  });
+}
+
+const MAX_RETRIES = 3;
+const RETRY_DELAY_MS = 2000;
+
+export const _internals = {
+  sleep: (ms: number): Promise<void> => new Promise((res) => setTimeout(res, ms)),
+  clientBoot: clientBootImpl,
+  getWebSocket: (): WsConstructor | undefined => {
+    const ws = (globalThis as Record<string, unknown>).WebSocket;
+    return typeof ws === "function" ? ws as WsConstructor : undefined;
+  },
+};
+
+export async function tailRTMImpl(
+  token: string,
+  cookie: string,
+  channelId: string,
+  opts: RtmPollOpts,
+  seen: Set<string>,
+  cache: Map<string, string>,
+  signal?: AbortSignal,
+): Promise<void> {
+  const WS = _internals.getWebSocket();
+  if (!WS) return;
+
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+    if (signal?.aborted) return;
+
+    try {
+      const { wsUrl } = await _internals.clientBoot(token, cookie);
+      await connectAndStream(WS, token, wsUrl, channelId, opts, seen, cache, signal);
+    } catch {
+      // boot or connection error — retry
+    }
+
+    if (signal?.aborted) return;
+    if (attempt < MAX_RETRIES - 1) {
+      await _internals.sleep(RETRY_DELAY_MS);
+    }
+  }
+}

package/ts/slack.ts

@@ -285,19 +285,27 @@ function normName(s: string): string {
   return s.toLowerCase().replace(/[-_\s]/g, "");
 }
 
-/** Parse a Slack permalink, returning channel ID and (optional) message ts.
+/** Parse a Slack permalink, returning channel ID, optional message ts, and optional thread_ts.
  *  Supports both forms:
  *    https://app.slack.com/client/T.../C...[/p1700000000000100]
- *    https://<ws>.slack.com/archives/C...[/p1700000000000100][?thread_ts=...]
+ *    https://<ws>.slack.com/archives/C...[/p1700000000000100][?thread_ts=...][&cid=C...]
  */
-export function parseSlackPermalink(s: string): { channel: string; ts?: string } | undefined {
+export function parseSlackPermalink(s: string): { channel: string; ts?: string; threadTs?: string } | undefined {
   const m = s.match(
     /(?:app\.slack\.com\/client\/T[A-Za-z0-9]+|[A-Za-z0-9-]+\.slack\.com\/archives)\/([A-Za-z0-9]+)(?:\/p(\d{10})(\d{6}))?/,
   );
   if (!m) return undefined;
   const channel = m[1]!;
   const ts = m[2] && m[3] ? `${m[2]}.${m[3]}` : undefined;
-  return ts ? { channel, ts } : { channel };
+  const qsStart = s.indexOf("?");
+  const qs = qsStart >= 0 ? new URLSearchParams(s.slice(qsStart)) : undefined;
+  const threadTs = qs?.get("thread_ts") ?? undefined;
+  const cidFromQs = qs?.get("cid") ?? undefined;
+  const resolvedChannel = cidFromQs ?? channel;
+  const result: { channel: string; ts?: string; threadTs?: string } = { channel: resolvedChannel };
+  if (ts) result.ts = ts;
+  if (threadTs) result.threadTs = threadTs;
+  return result;
 }
 
 function parseSlackUrl(s: string): string | undefined {
@@ -562,6 +570,20 @@ export async function uploadFile(
   return result;
 }
 
+// client.boot — internal endpoint that returns a WebSocket URL for RTM
+export async function clientBoot(token: string, cookie: string): Promise<{ wsUrl: string; selfId: string }> {
+  const resp = (await postSession(token, "client.boot", {}, cookie)) as Record<string, Json>;
+  const wsUrl = typeof resp.url === "string" ? resp.url : undefined;
+  if (!wsUrl) {
+    const keys = Object.keys(resp).join(", ");
+    throw new Error(`client.boot did not return a WebSocket URL. Keys: ${keys}`);
+  }
+  const self_ = resp.self && typeof resp.self === "object" && !Array.isArray(resp.self)
+    ? resp.self as Record<string, Json>
+    : {};
+  return { wsUrl, selfId: typeof self_.id === "string" ? self_.id : "" };
+}
+
 // Safe nested access
 export function getPath(obj: Json, path: readonly (string | number)[]): Json | undefined {
   let cur: Json | undefined = obj;

package/ts/tail.ts

@@ -1,5 +1,6 @@
 import { history, resolveChannel, userInfoPair, authTest, conversationInfo, RateLimitError, type Json } from "./slack.ts";
 import { resolveDateMarkup, resolveMentions } from "./format.ts";
+import { tailRTMImpl } from "./rtm.ts";
 
 export function parseSince(s: string): number {
   const m = s.match(/^(\d+(?:\.\d+)?)(s|m|h|d)$/);
@@ -17,6 +18,7 @@ export function parseSince(s: string): number {
 export const _internals = {
   sleep: (ms: number): Promise<void> => new Promise((res) => setTimeout(res, ms)),
   now: (): number => Date.now(),
+  tailRTM: tailRTMImpl,
 };
 
 function asRecord(v: Json | undefined): Record<string, Json> {
@@ -137,6 +139,8 @@ export type TailOpts = {
   thread?: string;
   me?: boolean;
   interval?: number;
+  cookie?: string;
+  noRtm?: boolean;
 };
 
 export async function cmdTail(
@@ -217,6 +221,13 @@ export async function cmdTail(
     ...(myUserId !== undefined ? { myUserId } : {}),
   };
 
+  // RTM path: xoxc token + cookie + no backfill requested
+  if (token.startsWith("xoxc-") && opts.cookie !== undefined && opts.noRtm !== true && opts.since === undefined) {
+    await _internals.tailRTM(token, opts.cookie, channelId, pollOpts, seen, cache, signal);
+    if (signal?.aborted) return;
+    console.error("RTM unavailable — switching to polling.");
+  }
+
   let isFirstPoll = true;
   let lastPollEndTime = _internals.now();