sparkecoder 0.1.141 → 0.1.143

package/dist/index.js

@@ -9475,9 +9475,9 @@ function slackEventToInboundResult(event, opts = {}) {
   if (event.type === "message" && event.subtype && IGNORED_MESSAGE_SUBTYPES.has(event.subtype)) {
     return { event: null, dropReason: "ignored_subtype" };
   }
-  const isDm = event.type === "message" && event.channel_type === "im";
+  const isDm = event.type === "message" && (event.channel_type === "im" || event.channel_type === "mpim");
   const isThreadReply = event.type === "message" && !isDm && typeof event.thread_ts === "string" && event.thread_ts !== event.ts;
-  const isNonThreadChannelMsg = event.type === "message" && !isDm && !isThreadReply && (event.channel_type === "channel" || event.channel_type === "group" || event.channel_type === "mpim" || // Some payload shapes omit channel_type for channel messages.
+  const isNonThreadChannelMsg = event.type === "message" && !isDm && !isThreadReply && (event.channel_type === "channel" || event.channel_type === "group" || // Some payload shapes omit channel_type for channel messages.
   typeof event.channel === "string");
   if (event.type !== "app_mention" && !isDm && !isThreadReply) {
     if (isNonThreadChannelMsg) {
@@ -9783,8 +9783,31 @@ function formatBytes(n) {
   if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
   return `${(n / 1024 / 1024).toFixed(2)} MB`;
 }
-function sleep(ms) {
-  return new Promise((resolve13) => setTimeout(resolve13, ms));
+function abortError() {
+  const err = new Error("aborted");
+  err.name = "AbortError";
+  return err;
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw abortError();
+}
+function isAbortLike(err) {
+  return err?.name === "AbortError" || String(err?.message || err).toLowerCase().includes("aborted");
+}
+function sleep(ms, signal) {
+  throwIfAborted(signal);
+  return new Promise((resolve13, reject) => {
+    const t = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve13();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(t);
+      signal?.removeEventListener("abort", onAbort);
+      reject(abortError());
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
 }
 function imageMagic(bytes) {
   if (bytes.length < 12) return null;
@@ -9804,19 +9827,21 @@ function validateDownloadedBytes(bytes, declaredContentType) {
   if (!actual) return "invalid_image_bytes";
   return null;
 }
-async function fetchSlackPrivateFile(sourceUrl, botToken) {
+async function fetchSlackPrivateFile(sourceUrl, botToken, signal) {
   let lastError = "unknown";
   for (let attempt = 0; attempt < 3; attempt++) {
     try {
+      throwIfAborted(signal);
       const res = await fetch(sourceUrl, {
-        headers: { Authorization: `Bearer ${botToken}` }
+        headers: { Authorization: `Bearer ${botToken}` },
+        signal
       });
       if (res.status === 429 || res.status >= 500) {
         lastError = `slack_fetch_${res.status}`;
         const retryAfter = Number(res.headers.get("retry-after"));
         const waitMs = Number.isFinite(retryAfter) && retryAfter > 0 ? Math.min(retryAfter * 1e3, 2e3) : 250 * (attempt + 1);
         if (attempt < 2) {
-          await sleep(waitMs);
+          await sleep(waitMs, signal);
           continue;
         }
       }
@@ -9827,25 +9852,58 @@ async function fetchSlackPrivateFile(sourceUrl, botToken) {
       if (Number.isFinite(contentLength) && contentLength > MAX_BYTES) {
         return { ok: false, error: "size_exceeded" };
       }
-      const ab = await res.arrayBuffer();
-      if (ab.byteLength > MAX_BYTES) {
-        return { ok: false, error: "size_exceeded" };
-      }
-      return { ok: true, bytes: Buffer.from(ab) };
+      return await readResponseBodyWithCap(res, signal);
     } catch (err) {
+      if (isAbortLike(err) || signal?.aborted) {
+        return { ok: false, error: "aborted" };
+      }
       lastError = `slack_fetch_error:${err?.message || "unknown"}`;
       if (attempt < 2) {
-        await sleep(250 * (attempt + 1));
+        await sleep(250 * (attempt + 1), signal);
         continue;
       }
     }
   }
   return { ok: false, error: lastError };
 }
-function withTimeout(p, ms, label) {
+async function readResponseBodyWithCap(res, signal) {
+  const body = res.body;
+  if (!body) {
+    const ab = await res.arrayBuffer();
+    if (ab.byteLength > MAX_BYTES) return { ok: false, error: "size_exceeded" };
+    return { ok: true, bytes: Buffer.from(ab) };
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      throwIfAborted(signal);
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      total += value.byteLength;
+      if (total > MAX_BYTES) {
+        await reader.cancel().catch(() => void 0);
+        return { ok: false, error: "size_exceeded" };
+      }
+      chunks.push(Buffer.from(value));
+    }
+  } catch (err) {
+    await reader.cancel().catch(() => void 0);
+    if (isAbortLike(err) || signal?.aborted) return { ok: false, error: "aborted" };
+    throw err;
+  }
+  return { ok: true, bytes: Buffer.concat(chunks, total) };
+}
+function withAbortTimeout(run, ms, label) {
   return new Promise((resolve13, reject) => {
-    const t = setTimeout(() => reject(new Error(`${label}_timeout`)), ms);
-    p.then(
+    const controller = new AbortController();
+    const t = setTimeout(() => {
+      controller.abort();
+      reject(new Error(`${label}_timeout`));
+    }, ms);
+    run(controller.signal).then(
       (v) => {
         clearTimeout(t);
         resolve13(v);
@@ -9857,7 +9915,8 @@ function withTimeout(p, ms, label) {
     );
   });
 }
-async function ingestOne(file, sessionId, botToken) {
+async function ingestOne(file, sessionId, botToken, signal) {
+  throwIfAborted(signal);
   const fileName = inferFileName(file);
   const contentType = inferContentType(file);
   const declaredSize = typeof file.size === "number" ? file.size : 0;
@@ -9875,7 +9934,8 @@ async function ingestOne(file, sessionId, botToken) {
     return { ...base, shortUrl: null, error: "size_exceeded" };
   }
   let bytes;
-  const fetched = await fetchSlackPrivateFile(sourceUrl, botToken);
+  const fetched = await fetchSlackPrivateFile(sourceUrl, botToken, signal);
+  throwIfAborted(signal);
   if (!fetched.ok) {
     return { ...base, shortUrl: null, error: fetched.error };
   }
@@ -9888,18 +9948,27 @@ async function ingestOne(file, sessionId, botToken) {
     return { ...base, sizeBytes: bytes.length, shortUrl: null, error: byteError };
   }
   const { storageQueries: storageQueries2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
-  let upload;
+  let upload = null;
   try {
+    throwIfAborted(signal);
     upload = await storageQueries2.getUploadUrl(sessionId, fileName, contentType, "slack");
+    throwIfAborted(signal);
   } catch (err) {
+    if (isAbortLike(err) || signal.aborted) {
+      if (upload?.fileId) await cleanupAbortedUpload(storageQueries2, upload.fileId);
+      throw err;
+    }
     return { ...base, sizeBytes: bytes.length, shortUrl: null, error: `presign_failed:${err?.message || "unknown"}` };
   }
   try {
+    throwIfAborted(signal);
     const putRes = await fetch(upload.uploadUrl, {
       method: "PUT",
       headers: { "Content-Type": contentType },
-      body: bytes
+      body: bytes,
+      signal
     });
+    throwIfAborted(signal);
     if (!putRes.ok) {
       return {
         ...base,
@@ -9909,6 +9978,10 @@ async function ingestOne(file, sessionId, botToken) {
       };
     }
   } catch (err) {
+    if (isAbortLike(err) || signal.aborted) {
+      await cleanupAbortedUpload(storageQueries2, upload.fileId);
+      throw err;
+    }
     return {
       ...base,
       sizeBytes: bytes.length,
@@ -9917,8 +9990,13 @@ async function ingestOne(file, sessionId, botToken) {
     };
   }
   try {
+    throwIfAborted(signal);
     await storageQueries2.updateFile(upload.fileId, { sizeBytes: bytes.length });
   } catch (err) {
+    if (isAbortLike(err) || signal.aborted) {
+      await cleanupAbortedUpload(storageQueries2, upload.fileId);
+      throw err;
+    }
     console.warn(`[slack-files] sizeBytes patch failed for ${upload.fileId}:`, err?.message || err);
   }
   const shortUrl = upload.shortUrl || // Defensive fallback: build it from the upload URL's origin if the
@@ -9930,6 +10008,14 @@ async function ingestOne(file, sessionId, botToken) {
     shortUrl
   };
 }
+async function cleanupAbortedUpload(storageQueries2, fileId) {
+  if (typeof storageQueries2?.deleteFile !== "function") return;
+  try {
+    await storageQueries2.deleteFile(fileId);
+  } catch (err) {
+    console.warn(`[slack-files] cleanup after aborted upload failed for ${fileId}:`, err?.message || err);
+  }
+}
 function inferShortUrlFromUploadUrl(uploadUrl, fileId) {
   try {
     const u = new URL(uploadUrl);
@@ -9969,7 +10055,7 @@ async function ingestSlackFiles(files, sessionId, options = {}) {
   const startedAt = Date.now();
   const pipeline = Promise.allSettled(
     files.map(
-      (f) => withTimeout(ingestOne(f, sessionId, botToken), timeoutMs, `ingest:${f.id}`).catch((err) => {
+      (f) => withAbortTimeout((signal) => ingestOne(f, sessionId, botToken, signal), timeoutMs, `ingest:${f.id}`).catch((err) => {
         if (String(err?.message || err).includes("_timeout")) {
           return {
             slackFileId: f.id,
@@ -16449,7 +16535,7 @@ slack.post("/events", async (c) => {
     const self = await ensureSlackSelfIdentity();
     const { event: inbound, dropReason } = slackEventToInboundResult(ev, { self });
     if (inbound) {
-      const isThreadReply = ev.type === "message" && ev.channel_type !== "im" && typeof ev.thread_ts === "string" && ev.thread_ts !== ev.ts;
+      const isThreadReply = ev.type === "message" && ev.channel_type !== "im" && ev.channel_type !== "mpim" && typeof ev.thread_ts === "string" && ev.thread_ts !== ev.ts;
       if (isThreadReply) {
         const ours = isThreadOwned(ev.channel, ev.thread_ts) || await botParticipatedInThread(ev.channel, ev.thread_ts);
         if (!ours) {
@@ -16462,7 +16548,7 @@ slack.post("/events", async (c) => {
       if (ev.type === "app_mention" && ev.channel && (ev.thread_ts || ev.ts)) {
         markThreadOwned(ev.channel, ev.thread_ts || ev.ts);
       }
-      if (ev.type === "message" && ev.channel_type === "im" && ev.channel && (ev.thread_ts || ev.ts)) {
+      if (ev.type === "message" && (ev.channel_type === "im" || ev.channel_type === "mpim") && ev.channel && (ev.thread_ts || ev.ts)) {
         markThreadOwned(ev.channel, ev.thread_ts || ev.ts);
       }
       if (wasHandled(ev.channel, ev.ts)) {