slack-term 1.47.0 → 1.49.0

package/ts/slack.ts

@@ -41,7 +41,41 @@ function base(): string {
   return (process.env.SLACK_API_BASE ?? "https://slack.com/api").replace(/\/$/, "");
 }
 
-async function call(token: string, method: string, init: RequestInit, cookie?: string): Promise<Json> {
+/** How long one call may spend waiting out 429s before it throws
+ *  RateLimitError (seconds, summed over its retries). A 429 means Slack
+ *  rejected the request unprocessed, so retrying it — even a write — cannot
+ *  duplicate anything. One-shot commands wait (`pinlog`, `read`, `send`…);
+ *  `slack stream` sets 0 because it schedules around Retry-After itself.
+ *  SLACK_RATELIMIT_WAIT_SEC overrides the default. */
+let rateLimitWaitSec = ((): number => {
+  const v = Number(process.env.SLACK_RATELIMIT_WAIT_SEC);
+  return Number.isFinite(v) && v >= 0 ? v : 120;
+})();
+export function setRateLimitWait(sec: number): void {
+  rateLimitWaitSec = sec;
+}
+
+/** Run `once`; while it throws RateLimitError and the budget allows, wait out
+ *  its Retry-After (one stderr line each, method and seconds only) and retry. */
+export async function withRateLimitWait<T>(once: () => Promise<T>, sleep = (ms: number) => new Promise((r) => setTimeout(r, ms))): Promise<T> {
+  let waited = 0;
+  for (;;) {
+    try {
+      return await once();
+    } catch (e) {
+      if (!(e instanceof RateLimitError) || waited + e.retryAfter > rateLimitWaitSec) throw e;
+      waited += e.retryAfter;
+      console.error(`slack: ${e.message} — waiting`);
+      await sleep(e.retryAfter * 1000);
+    }
+  }
+}
+
+function call(token: string, method: string, init: RequestInit, cookie?: string): Promise<Json> {
+  return withRateLimitWait(() => callOnce(token, method, init, cookie));
+}
+
+async function callOnce(token: string, method: string, init: RequestInit, cookie?: string): Promise<Json> {
   cookie = token.startsWith("xoxc-") ? (cookie ?? resolveCookie()) : undefined;
   const extraHeaders: Record<string, string> = {};
   if (cookie) extraHeaders["Cookie"] = `d=${cookie}`;
@@ -95,7 +129,11 @@ async function call(token: string, method: string, init: RequestInit, cookie?: s
 // Internal Slack API caller — does NOT reject xoxc tokens.
 // Used for hidden endpoints (drafts, etc.) only accessible via session tokens.
 // cookie: raw xoxd value (without "d=" prefix); injected as Cookie header when present.
-async function callSession(token: string, method: string, init: RequestInit, cookie?: string): Promise<Json> {
+function callSession(token: string, method: string, init: RequestInit, cookie?: string): Promise<Json> {
+  return withRateLimitWait(() => callSessionOnce(token, method, init, cookie));
+}
+
+async function callSessionOnce(token: string, method: string, init: RequestInit, cookie?: string): Promise<Json> {
   const extraHeaders: Record<string, string> = {};
   if (cookie) extraHeaders["Cookie"] = `d=${cookie}`;
   const res = await fetch(`${base()}/${method}`, {

package/ts/stream.ts

@@ -136,6 +136,8 @@ export type StreamOpts = {
   selfUsers: Set<string>;
   selfBots: Set<string>;
   json: boolean;
+  /** Also called with every emitted match and its attachment count (`slack stream --inbox`). */
+  onMatch?: (rec: StreamMatch, files: number) => void;
   once: boolean;
   /** Seconds back to (re)start every channel from, overriding the saved cursor. */
   sinceSec?: number;
@@ -371,6 +373,7 @@ async function consider(
     match,
   };
   ctx.opts.json ? _internals.out(JSON.stringify(rec)) : _internals.out(humanLine(rec));
+  ctx.opts.onMatch?.(rec, Array.isArray(m.files) ? m.files.length : 0);
   ctx.matches++;
   return true;
 }
@@ -643,7 +646,7 @@ export async function runStream(client: StreamClient, opts: StreamOpts): Promise
       `slack stream: WARNING: polling mode (${opts.pollReason ?? "no relay configured"}) — this is the fallback, ` +
       `not the intended setup: matches arrive up to ${Math.round(opts.intervalMs / 1000)}s late (replies under older ` +
       `parents up to ${Math.round(Math.max(opts.threadScanSec ?? 180, opts.intervalMs / 1000))}s) and every cycle spends ` +
-      `Slack API calls. For real time, deploy the relay and set SLACK_RELAY_URL + SLACK_RELAY_TOKEN: ${RELAY_DOCS}`,
+      `Slack API calls. For real time, set up the relay (slack relay init) and set SLACK_RELAY_URL + SLACK_RELAY_TOKEN: ${RELAY_DOCS}`,
     );
   }
   client = paced(client, opts.callsPerMin ?? 40, opts.signal);

package/ts/tick.ts

@@ -0,0 +1,47 @@
+// `slack tick`: turn a "⬜ <n>." item of a posted checklist into "✅ <n>.",
+// changing nothing else (10-30: when an announced ⬜ criterion is done,
+// edit the original to ✅ rather than only posting a new "done" reply).
+// Slack may store the box as the shortcode, so both spellings are handled and
+// the tick keeps the spelling it found.
+
+const BOX = /(⬜️?|:white_large_square:)(\s*)(\d+)\./g;
+const DONE = /(✅|:white_check_mark:)\s*(\d+)\./g;
+
+export type TickResult =
+  | { kind: "ticked"; text: string; n: number }
+  | { kind: "already"; n: number }
+  | { kind: "none" }
+  | { kind: "ambiguous"; open: number[] }
+  | { kind: "missing"; n: number };
+
+/** Tick item `n`, or — without `n` — the one open item there is. */
+export function tickText(text: string, n?: number): TickResult {
+  const open = [...text.matchAll(BOX)].map((m) => Number(m[3]));
+  const done = [...text.matchAll(DONE)].map((m) => Number(m[2]));
+  if (n === undefined) {
+    if (open.length === 0) return done.length ? { kind: "already", n: done[0]! } : { kind: "none" };
+    if (open.length > 1) return { kind: "ambiguous", open };
+    n = open[0]!;
+  }
+  if (!open.includes(n)) return done.includes(n) ? { kind: "already", n } : { kind: "missing", n };
+  let hit = false;
+  const out = text.replace(BOX, (all, box: string, sp: string, num: string) => {
+    if (hit || Number(num) !== n) return all;
+    hit = true;
+    return `${box.startsWith(":") ? ":white_check_mark:" : "✅"}${sp}${num}.`;
+  });
+  return { kind: "ticked", text: out, n };
+}
+
+/** An edit keeps the lane tag the message was posted with (`[lane] ` or
+ *  `[lane@host] `), so a rewrite cannot drop or change who said it. Only when
+ *  `lanePrefix` (the scope's prefix) is the tag the original starts with. */
+export function keepLanePrefix(original: string, next: string, lanePrefix: string | undefined): string {
+  const m = /^\[([^\]@\s]+)\]$/.exec(lanePrefix?.trim() ?? "");
+  if (!m) return next;
+  const lane = m[1]!.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const tag = new RegExp(`^\\[${lane}(?:@[a-z0-9-]{1,16})?\\][ \\t]*`);
+  const had = tag.exec(original);
+  if (!had) return next;
+  return had[0] + next.replace(tag, "");
+}

package/ts/vendor/gitleaks.LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Zachary Rice
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.