slack-term 1.7.0 → 1.14.0

package/ts/profiles.ts

@@ -29,8 +29,12 @@ type ProfileStore = {
   profiles: Record<string, Profile>;
 };
 
+function home(): string {
+  return process.env.HOME || homedir();
+}
+
 function profilesPath(): string {
-  return join(homedir(), ".config", "slack-cli", "profiles.json");
+  return join(home(), ".config", "slack-cli", "profiles.json");
 }
 
 function localLockfilePath(): string {
@@ -38,7 +42,7 @@ function localLockfilePath(): string {
 }
 
 function globalLockfilePath(): string {
-  return join(homedir(), ".slack-cli", "workspace");
+  return join(home(), ".slack-cli", "workspace");
 }
 
 function load(): ProfileStore {
@@ -115,18 +119,19 @@ export function resolveToken(workspaceFlag?: string): string {
   const names = Object.keys(profiles);
   const envToken = process.env.SLACK_MCP_XOXP_TOKEN;
 
-  // Conflict: env token and profiles are mutually exclusive
+  // Conflict: env token and profiles are mutually exclusive — prefer profiles
   if (envToken && names.length > 0) {
-    throw new Error(
-      "Both SLACK_MCP_XOXP_TOKEN and workspace profiles are configured — keep only one.\n" +
-      "  • Unset SLACK_MCP_XOXP_TOKEN to use profiles\n" +
-      "  • Or remove all profiles: slack workspace remove <name>",
-    );
+    if (!(globalThis as Record<string, unknown>).__slackEnvWarnShown) {
+      (globalThis as Record<string, unknown>).__slackEnvWarnShown = true;
+      console.error(
+        "Warning: SLACK_MCP_XOXP_TOKEN is set but workspace profiles exist - using profiles.\n" +
+        "  Run: unset SLACK_MCP_XOXP_TOKEN  (and remove from ~/.zshrc or ~/.bashrc)",
+      );
+    }
+  } else if (envToken) {
+    return envToken;
   }
 
-  // Env token only (no profiles) — highest priority when unambiguous
-  if (envToken) return envToken;
-
   // Explicit per-command selection
   const selected = workspaceFlag ?? process.env.SLACK_WORKSPACE;
   if (selected) {
@@ -157,7 +162,7 @@ export function resolveToken(workspaceFlag?: string): string {
 
   // No profiles and no env token
   if (names.length === 0) {
-    throw new Error("No profiles configured. Run: slack workspace add <name> <token>  — or set SLACK_MCP_XOXP_TOKEN");
+    throw new Error("No profiles configured. Run: slack auth login");
   }
 
   // Profiles exist but none selected — never silently pick one

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

@@ -1,5 +1,14 @@
 // Slack Web API client (user token, Authorization: Bearer)
 
+export class RateLimitError extends Error {
+  retryAfter: number;
+  constructor(retryAfter: number) {
+    super(`Slack rate limited — retry after ${retryAfter}s`);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+}
+
 export type Json =
   | string
   | number
@@ -23,9 +32,14 @@ async function call(token: string, method: string, init: RequestInit, cookie?: s
       ...extraHeaders,
     },
   });
+  if (res.status === 429) {
+    const retryAfter = parseInt(res.headers.get("retry-after") ?? "60", 10);
+    throw new RateLimitError(isNaN(retryAfter) ? 60 : retryAfter);
+  }
   const body = (await res.json()) as { ok?: boolean; error?: string } & Record<string, Json>;
   if (body.ok !== true) {
     const err = body.error ?? "unknown";
+    if (err === "ratelimited") throw new RateLimitError(60);
     if (err === "invalid_auth" && token.startsWith("xoxc-") && !cookie) {
       throw new Error(
         `Desktop app token (xoxc-) is not accepted by the public Slack API.\n` +
@@ -52,9 +66,14 @@ async function callSession(token: string, method: string, init: RequestInit, coo
       ...extraHeaders,
     },
   });
+  if (res.status === 429) {
+    const retryAfter = parseInt(res.headers.get("retry-after") ?? "60", 10);
+    throw new RateLimitError(isNaN(retryAfter) ? 60 : retryAfter);
+  }
   const body = (await res.json()) as { ok?: boolean; error?: string } & Record<string, Json>;
   if (body.ok !== true) {
     const err = body.error ?? "unknown";
+    if (err === "ratelimited") throw new RateLimitError(60);
     if ((err === "invalid_auth" || err === "not_authed") && !token.startsWith("xoxc-")) {
       throw new Error(
         `The draft API requires a desktop app session token (xoxc-).\n` +
@@ -96,20 +115,24 @@ function post(token: string, method: string, body: Record<string, Json>): Promis
   });
 }
 
-export async function authTest(token: string): Promise<{ team: string; teamId: string; url: string; user: string }> {
+export async function authTest(token: string): Promise<{ team: string; teamId: string; url: string; user: string; userId: string }> {
   const resp = (await get(token, "auth.test", {})) as {
-    team?: string; team_id?: string; url?: string; user?: string;
+    team?: string; team_id?: string; url?: string; user?: string; user_id?: string;
   };
   return {
     team: resp.team ?? "",
     teamId: resp.team_id ?? "",
     url: resp.url ?? "",
     user: resp.user ?? "",
+    userId: resp.user_id ?? "",
   };
 }
 
-export async function history(token: string, channel: string, limit = 20): Promise<Json> {
-  return get(token, "conversations.history", { channel, limit: String(limit) });
+export async function history(token: string, channel: string, limit = 20, oldest?: string, cursor?: string): Promise<Json> {
+  const params: Record<string, string> = { channel, limit: String(limit) };
+  if (oldest !== undefined) params.oldest = oldest;
+  if (cursor !== undefined) params.cursor = cursor;
+  return get(token, "conversations.history", params);
 }
 
 export async function replies(
@@ -177,6 +200,44 @@ export async function send(
   return resp.ts ?? "";
 }
 
+export async function scheduleMessage(
+  token: string,
+  channel: string,
+  text: string,
+  postAt: number,
+  threadTs?: string,
+): Promise<string> {
+  const body: Record<string, Json> = {
+    channel,
+    text,
+    post_at: postAt,
+    blocks: [{ type: "markdown", text }],
+  };
+  if (threadTs !== undefined) body.thread_ts = threadTs;
+  const resp = (await post(token, "chat.scheduleMessage", body)) as { scheduled_message_id?: string };
+  return resp.scheduled_message_id ?? "";
+}
+
+export async function listScheduledMessages(
+  token: string,
+  channel?: string,
+): Promise<Json> {
+  const params: Record<string, string> = {};
+  if (channel) params.channel = channel;
+  return get(token, "chat.scheduledMessages.list", params);
+}
+
+export async function deleteScheduledMessage(
+  token: string,
+  channel: string,
+  scheduledMessageId: string,
+): Promise<void> {
+  await post(token, "chat.deleteScheduledMessage", {
+    channel,
+    scheduled_message_id: scheduledMessageId,
+  });
+}
+
 export async function editMessage(
   token: string,
   channel: string,
@@ -224,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 {
@@ -360,6 +429,23 @@ export async function userName(token: string, userId: string): Promise<string> {
   }
 }
 
+export async function listUsers(token: string): Promise<Json> {
+  const allMembers: Json[] = [];
+  let cursor = "";
+  while (true) {
+    const params: Record<string, string> = { limit: "200" };
+    if (cursor) params.cursor = cursor;
+    const resp = (await get(token, "users.list", params)) as {
+      members?: Json[];
+      response_metadata?: { next_cursor?: string };
+    };
+    allMembers.push(...(resp.members ?? []));
+    cursor = resp.response_metadata?.next_cursor ?? "";
+    if (!cursor) break;
+  }
+  return { members: allMembers };
+}
+
 // Draft API (internal — requires xoxc session token + xoxd cookie)
 export async function listDrafts(token: string, cookie?: string): Promise<Json> {
   return postSession(token, "drafts.list", {}, cookie);
@@ -412,6 +498,14 @@ export async function conversationInfoSession(token: string, channelId: string,
   return postSession(token, "conversations.info", { channel: channelId }, cookie);
 }
 
+export async function userInfo(token: string, userId: string): Promise<Json> {
+  return get(token, "users.info", { user: userId });
+}
+
+export async function conversationInfo(token: string, channelId: string): Promise<Json> {
+  return get(token, "conversations.info", { channel: channelId });
+}
+
 export async function deleteDraft(token: string, draftId: string, cookie?: string): Promise<Json> {
   const nowTs = (Date.now() / 1000).toFixed(6);
   return postSession(token, "drafts.delete", { draft_id: draftId, client_last_updated_ts: nowTs }, cookie);
@@ -476,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;