stitchkit 0.103.13 → 0.104.1

package/dist/entrypoints/telegram.js

@@ -5,10 +5,21 @@ import {
   TELEGRAM_SEND_FAILURE_REASONS2,
   classifyTelegramSendFailure2
 } from "../index-e05cjgtf.js";
+import {
+  attemptExclusiveLock
+} from "../index-za6j7nwy.js";
+import"../index-5csmzesf.js";
+import"../index-v5ee8ath.js";
 import {
   TELEGRAM_TEXT_LIMIT2,
   truncateTelegramHtml2
 } from "../index-nmaqxdx7.js";
+import {
+  writeFileAtomic2
+} from "../index-s4evrmp5.js";
+import {
+  raceAbort
+} from "../index-mbnnw3f2.js";
 import {
   isRecord,
   transportResult
@@ -80,24 +91,156 @@ async function callTelegramBotApi(call) {
     }
   });
 }
+// src/telegram/broadcast-delivery.ts
+import { z as z2 } from "zod";
+
+// src/telegram/broadcast-failure.ts
+import { z } from "zod";
+var reason = z.string().max(64).optional();
+var TelegramBroadcastFailureSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("retry-after"),
+    retryAfterMs: z.int().nonnegative().max(2147483647),
+    reason
+  }).strict(),
+  z.object({ kind: z.literal("transient"), reason }).strict(),
+  z.object({
+    kind: z.literal("permanent"),
+    recipientUnreachable: z.boolean().optional(),
+    stopBroadcast: z.boolean().optional(),
+    reason
+  }).strict(),
+  z.object({ kind: z.literal("ambiguous"), reason }).strict()
+]);
+function classifyBotBroadcastFailure(error) {
+  const failure = classifyTelegramSendFailure2(error);
+  if (failure.recipientUnreachable)
+    return { kind: "permanent", recipientUnreachable: true, reason: failure.reason };
+  if (failure.reason === "message-invalid")
+    return { kind: "permanent", stopBroadcast: true, reason: failure.reason };
+  if (failure.retryAfterSeconds !== undefined)
+    return {
+      kind: "retry-after",
+      retryAfterMs: failure.retryAfterSeconds * 1000,
+      reason: failure.reason
+    };
+  if (failure.retryable)
+    return { kind: "transient", reason: failure.reason };
+  if (failure.reason === "unknown" && failure.status === undefined)
+    return { kind: "ambiguous", reason: failure.reason };
+  return { kind: "permanent", reason: failure.reason };
+}
+
+// src/telegram/broadcast-delivery.ts
+function pause(milliseconds, signal) {
+  return new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    };
+    const timer = setTimeout(done, milliseconds);
+    signal?.addEventListener("abort", done, { once: true });
+    if (signal?.aborted)
+      done();
+  });
+}
+function broadcastLimits(config) {
+  const rate = z2.number().positive().min(1000 / 2147483647).parse(config.ratePerSecond ?? 25);
+  return {
+    intervalMs: 1000 / rate,
+    maxAttempts: z2.int().min(1).max(100).parse(config.maxAttempts ?? 5),
+    maxRetryDelayMs: z2.int().nonnegative().max(2147483647).parse(config.maxRetryDelayMs ?? 60000),
+    progressEveryMs: z2.int().nonnegative().max(2147483647).parse(config.progressEveryMs ?? 1e4)
+  };
+}
+function broadcastDelivery(config, limits, assertHeld) {
+  const sleep = config.sleep ?? pause;
+  const now = config.now ?? Date.now;
+  const classify = config.classify ?? classifyBotBroadcastFailure;
+  let lastSendAt = Number.NEGATIVE_INFINITY;
+  const wait = async (milliseconds) => {
+    if (config.signal?.aborted)
+      return false;
+    if (milliseconds > 0) {
+      try {
+        const pending = sleep(milliseconds, config.signal);
+        if (config.signal)
+          await raceAbort(pending, config.signal);
+        else
+          await pending;
+      } catch (error) {
+        if (config.signal?.aborted)
+          return false;
+        throw error;
+      }
+    }
+    return !config.signal?.aborted;
+  };
+  return async (recipient) => {
+    for (let attempt = 1;attempt <= limits.maxAttempts; attempt += 1) {
+      if (!await wait(lastSendAt + limits.intervalMs - now()))
+        return { kind: "stopped" };
+      await assertHeld();
+      if (config.signal?.aborted)
+        return { kind: "stopped" };
+      lastSendAt = now();
+      try {
+        await config.send({ recipient, attempt });
+        return { kind: "settled", outcome: "delivered" };
+      } catch (error) {
+        const failure = TelegramBroadcastFailureSchema.parse(classify(error));
+        if (failure.kind === "ambiguous")
+          return {
+            kind: "settled",
+            outcome: "uncertain",
+            ...failure.reason && { reason: failure.reason },
+            halt: failure
+          };
+        if (failure.kind === "permanent") {
+          if (failure.stopBroadcast)
+            return { kind: "halted", failure };
+          return {
+            kind: "settled",
+            outcome: failure.recipientUnreachable ? "unreachable" : "failed",
+            ...failure.reason && { reason: failure.reason }
+          };
+        }
+        const delay = failure.kind === "retry-after" ? failure.retryAfterMs : Math.min(60000, 1000 * 2 ** (attempt - 1));
+        if (delay > limits.maxRetryDelayMs)
+          return { kind: "halted", failure };
+        if (attempt >= limits.maxAttempts)
+          return {
+            kind: "settled",
+            outcome: "failed",
+            ...failure.reason && { reason: failure.reason }
+          };
+        if (!await wait(delay))
+          return { kind: "stopped" };
+      }
+    }
+    throw new Error("Broadcast retry budget produced no outcome");
+  };
+}
+
 // src/telegram/broadcast-state.ts
-import { appendFile, mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { mkdir, open, readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { z } from "zod";
-var TelegramBroadcastOutcomeSchema = z.enum([
+import { z as z3 } from "zod";
+var TelegramBroadcastOutcomeSchema = z3.enum([
   "delivered",
   "unreachable",
   "failed",
   "uncertain"
 ]);
-var ChatIdSchema = z.union([z.number().int(), z.string().min(1).max(64)]);
-var RecipientsSchema = z.array(ChatIdSchema);
-var JournalLineSchema = z.union([
-  z.object({ i: z.number().int().nonnegative(), s: z.enum(["sending", "released"]) }).strict(),
-  z.object({
-    i: z.number().int().nonnegative(),
+var ChatIdSchema = z3.union([z3.number().int(), z3.string().min(1).max(64)]);
+var RecipientsSchema = z3.array(ChatIdSchema);
+var JournalLineSchema = z3.union([
+  z3.object({ i: z3.number().int().nonnegative(), s: z3.enum(["sending", "released"]) }).strict(),
+  z3.object({
+    i: z3.number().int().nonnegative(),
     o: TelegramBroadcastOutcomeSchema,
-    r: z.string().max(64).optional()
+    r: z3.string().max(64).optional()
   }).strict()
 ]);
 var NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
@@ -123,10 +266,21 @@ async function readRecipients(files) {
     throw error;
   }
 }
-async function writeRecipients(files, recipients) {
-  const temporary = `${files.recipients}.${process.pid}.tmp`;
-  await writeFile(temporary, JSON.stringify(recipients));
-  await rename(temporary, files.recipients);
+async function writeRecipients(files, recipients, lock) {
+  await lock.assertHeld();
+  await writeFileAtomic2(files.recipients, JSON.stringify(recipients), {
+    replace: false,
+    durability: "directory"
+  });
+}
+async function prepareJournal(files, lock) {
+  await lock.assertHeld();
+  try {
+    await writeFileAtomic2(files.journal, "", { replace: false, durability: "directory" });
+  } catch (error) {
+    if (!(error instanceof Error && ("code" in error) && error.code === "EEXIST"))
+      throw error;
+  }
 }
 async function readProgress(files) {
   const progress = new Map;
@@ -157,43 +311,33 @@ async function readProgress(files) {
   }
   return progress;
 }
-function appendJournal(files, line) {
-  return appendFile(files.journal, `${JSON.stringify(line)}
-`);
-}
-function alive(pid) {
+async function appendJournal(files, line, lock) {
+  await lock.assertHeld();
+  const handle = await open(files.journal, "a", 384);
   try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error instanceof Error && "code" in error && error.code === "EPERM";
+    await lock.assertHeld();
+    await handle.writeFile(`${JSON.stringify(line)}
+`);
+    await handle.sync();
+  } finally {
+    await handle.close();
   }
 }
 async function lockBroadcast(directory, files) {
   await mkdir(directory, { recursive: true });
-  for (let attempt = 0;attempt < 2; attempt += 1) {
-    try {
-      const handle = await open(files.lock, "wx");
-      await handle.writeFile(String(process.pid));
-      await handle.close();
-      return () => rm(files.lock, { force: true });
-    } catch (error) {
-      if (!(error instanceof Error && ("code" in error) && error.code === "EEXIST"))
-        throw error;
-      const owner = Number.parseInt(await readFile(files.lock, "utf8").catch(() => ""), 10);
-      if (Number.isInteger(owner) && owner > 0 && alive(owner)) {
-        throw new Error("Telegram broadcast is already running in another process");
-      }
-      await rm(files.lock, { force: true });
-    }
-  }
-  throw new Error("Telegram broadcast lock could not be taken");
+  const attempt = await attemptExclusiveLock(files.lock, {
+    mode: 384,
+    reclaim: true,
+    ownerlessGraceMs: null
+  });
+  if ("held" in attempt)
+    return attempt.held;
+  throw new Error("Telegram broadcast is already running or its lock owner is unknown", {
+    cause: attempt.diagnosis?.cause ?? attempt.error
+  });
 }
 
 // src/telegram/broadcast.ts
-function pause(milliseconds) {
-  return new Promise((resolve) => setTimeout(resolve, milliseconds));
-}
 function tally(name, total, progress, outcome, halt) {
   const counts = { delivered: 0, unreachable: 0, failed: 0, uncertain: 0 };
   for (const state of progress.values())
@@ -223,9 +367,7 @@ async function audience(config) {
 async function runTelegramBroadcast(config) {
   assertBroadcastName(config.name);
   const files = broadcastFiles(config.directory, config.name);
-  const intervalMs = 1000 / (config.ratePerSecond ?? 25);
-  const maxAttempts = config.maxAttempts ?? 5;
-  const sleep = config.sleep ?? pause;
+  const limits = broadcastLimits(config);
   const now = config.now ?? Date.now;
   let recipients = [];
   let progress = new Map;
@@ -235,20 +377,22 @@ async function runTelegramBroadcast(config) {
     progress = await readProgress(files);
     return report("dry-run");
   }
-  const unlock = await lockBroadcast(config.directory, files);
+  const lock = await lockBroadcast(config.directory, files);
+  const deliver = broadcastDelivery(config, limits, () => lock.assertHeld());
   try {
     const snapshot = await readRecipients(files);
     if (snapshot)
       recipients = snapshot;
     else {
       recipients = await audience(config);
-      await writeRecipients(files, recipients);
+      await writeRecipients(files, recipients, lock);
     }
+    await prepareJournal(files, lock);
     progress = await readProgress(files);
     for (const [index, state] of progress) {
       if (state !== "sending")
         continue;
-      await appendJournal(files, { i: index, o: "uncertain" });
+      await appendJournal(files, { i: index, o: "uncertain" }, lock);
       progress.set(index, "uncertain");
     }
     const emit = (value) => {
@@ -259,37 +403,6 @@ async function runTelegramBroadcast(config) {
     };
     emit(report("running"));
     let lastProgressAt = now();
-    let lastSendAt = Number.NEGATIVE_INFINITY;
-    let halted;
-    const halt = (failure) => {
-      halted = failure;
-      return "halt";
-    };
-    const deliver = async (recipient) => {
-      for (let attempt = 1;; attempt += 1) {
-        const wait = lastSendAt + intervalMs - now();
-        if (wait > 0)
-          await sleep(wait);
-        lastSendAt = now();
-        try {
-          await config.send({ recipient, attempt });
-          return { outcome: "delivered" };
-        } catch (error) {
-          const failure = classifyTelegramSendFailure2(error);
-          if (failure.recipientUnreachable)
-            return { outcome: "unreachable", reason: failure.reason };
-          if (failure.reason === "message-invalid")
-            return halt(failure);
-          const transport = failure.reason === "unknown" && failure.status === undefined;
-          if (!failure.retryable && !transport)
-            return { outcome: "failed", reason: failure.reason };
-          if (attempt >= maxAttempts) {
-            return transport ? halt(failure) : { outcome: "failed", reason: failure.reason };
-          }
-          await sleep(failure.retryAfterSeconds !== undefined ? failure.retryAfterSeconds * 1000 : Math.min(60000, 1000 * 2 ** (attempt - 1)));
-        }
-      }
-    };
     for (let index = 0;index < recipients.length; index += 1) {
       if (progress.has(index))
         continue;
@@ -298,26 +411,28 @@ async function runTelegramBroadcast(config) {
       const recipient = recipients[index];
       if (recipient === undefined)
         continue;
-      await appendJournal(files, { i: index, s: "sending" });
+      await appendJournal(files, { i: index, s: "sending" }, lock);
       const result = await deliver(recipient);
-      if (result === "halt") {
-        await appendJournal(files, { i: index, s: "released" });
-        return emit(report("halted", halted));
+      if (result.kind !== "settled") {
+        await appendJournal(files, { i: index, s: "released" }, lock);
+        return emit(result.kind === "stopped" ? report("stopped") : report("halted", result.failure));
       }
       await appendJournal(files, {
         i: index,
         o: result.outcome,
         ...result.reason && { r: result.reason }
-      });
+      }, lock);
       progress.set(index, result.outcome);
-      if (now() - lastProgressAt >= (config.progressEveryMs ?? 1e4)) {
+      if (result.halt)
+        return emit(report("halted", result.halt));
+      if (now() - lastProgressAt >= limits.progressEveryMs) {
         lastProgressAt = now();
         emit(report("running"));
       }
     }
     return emit(report("finished"));
   } finally {
-    await unlock();
+    await lock.release();
   }
 }
 function telegramBroadcastSender(config) {
@@ -363,17 +478,17 @@ function digestsEqual(a, b) {
 }
 
 // src/telegram/user.ts
-import { z as z2 } from "zod";
-var TelegramUserSchema = z2.object({
-  id: z2.int(),
-  is_bot: z2.boolean().optional(),
-  first_name: z2.string(),
-  last_name: z2.string().optional(),
-  username: z2.string().optional(),
-  language_code: z2.string().optional(),
-  is_premium: z2.boolean().optional(),
-  allows_write_to_pm: z2.boolean().optional(),
-  photo_url: z2.string().optional()
+import { z as z4 } from "zod";
+var TelegramUserSchema = z4.object({
+  id: z4.int(),
+  is_bot: z4.boolean().optional(),
+  first_name: z4.string(),
+  last_name: z4.string().optional(),
+  username: z4.string().optional(),
+  language_code: z4.string().optional(),
+  is_premium: z4.boolean().optional(),
+  allows_write_to_pm: z4.boolean().optional(),
+  photo_url: z4.string().optional()
 }).transform((user) => ({
   id: user.id,
   firstName: user.first_name,
@@ -1423,6 +1538,7 @@ export {
   TELEGRAM_SEND_FAILURE_REASONS2 as TELEGRAM_SEND_FAILURE_REASONS,
   TELEGRAM_WEBHOOK_NONE,
   TelegramBotApiError,
+  TelegramBroadcastFailureSchema,
   TelegramLocalFileError,
   TelegramWebhookClaimError,
   callTelegramBotApi,

package/dist/entrypoints/testing.js

@@ -1,18 +1,18 @@
 import"../index-yex7eg1v.js";
-import"../index-ygkka6zn.js";
+import"../index-ywppsaby.js";
 import {
   joinRoutePath
 } from "../index-m38ej7e5.js";
-import"../index-r5c4fedv.js";
+import"../index-h2fhjqy7.js";
 import {
   createClient2,
   createClients2
-} from "../index-0c419yx7.js";
-import"../index-n53mswt3.js";
+} from "../index-kemm0ej5.js";
+import"../index-x928baz2.js";
 import"../index-q0th8q0z.js";
 import {
   createApplication2
-} from "../index-w575evhq.js";
+} from "../index-r4r70zmh.js";
 import"../index-w5s3xftz.js";
 import {
   RealtimeRequestTimeoutError2,
@@ -36,8 +36,8 @@ import {
   projectToolSurface,
   mcpProjectionCandidate,
   prepareProjectedMcpTools
-} from "../index-x87j7csh.js";
-import"../index-b2bz0kdm.js";
+} from "../index-77nxk6ay.js";
+import"../index-kb8styz3.js";
 import {
   compareCodeUnits,
   serializeCanonicalJson

package/dist/entrypoints/tools/connections.d.ts

@@ -12,8 +12,8 @@
  * explicit `allowHosts`), and credentials are resolved separately for each call.
  */
 export { defineMcpClientConnection, defineOpenApiConnection, } from '../../tools/connections/define.js';
-export { ConnectionAuthorizationRequiredError, ConnectionBudgetExceededError, ConnectionRequestError, ConnectionUrlError, } from '../../tools/connections/errors.js';
+export { ConnectionAuthorizationRequiredError, ConnectionBudgetExceededError, type ConnectionFailureContext, ConnectionRequestError, ConnectionResponseTooLargeError, ConnectionTimeoutError, ConnectionUrlError, } from '../../tools/connections/errors.js';
 export { mountConnections } from '../../tools/connections/mount.js';
 export type { ConnectionTokenProvider, ConnectionToolSkipReporter, SkippedConnectionTool, } from '../../tools/connections/runtime.js';
-export type { ConnectionBudget, ConnectionDefinition, ConnectionMountOptions, McpClientConnection, McpClientConnectionConfig, McpConnectionTransport, McpToolFilter, OpenApiConnection, OpenApiConnectionConfig, } from '../../tools/connections/types.js';
+export type { ConnectionBudget, ConnectionDefinition, ConnectionMountOptions, ConnectionOperation, ConnectionOperationLimits, ConnectionPhase, McpClientConnection, McpClientConnectionConfig, McpConnectionLimits, McpConnectionTransport, McpToolFilter, OpenApiConnection, OpenApiConnectionConfig, } from '../../tools/connections/types.js';
 //# sourceMappingURL=connections.d.ts.map

package/dist/entrypoints/tools/connections.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connections.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/tools/connections.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EACL,yBAAyB,EACzB,uBAAuB,GACxB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,oCAAoC,EACpC,6BAA6B,EAC7B,sBAAsB,EACtB,kBAAkB,GACnB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,YAAY,EACV,uBAAuB,EACvB,0BAA0B,EAC1B,qBAAqB,GACtB,MAAM,iCAAiC,CAAC;AACzC,YAAY,EACV,gBAAgB,EAChB,oBAAoB,EACpB,sBAAsB,EACtB,mBAAmB,EACnB,yBAAyB,EACzB,sBAAsB,EACtB,aAAa,EACb,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,+BAA+B,CAAC"}
+{"version":3,"file":"connections.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/tools/connections.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EACL,yBAAyB,EACzB,uBAAuB,GACxB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,oCAAoC,EACpC,6BAA6B,EAC7B,KAAK,wBAAwB,EAC7B,sBAAsB,EACtB,+BAA+B,EAC/B,sBAAsB,EACtB,kBAAkB,GACnB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,YAAY,EACV,uBAAuB,EACvB,0BAA0B,EAC1B,qBAAqB,GACtB,MAAM,iCAAiC,CAAC;AACzC,YAAY,EACV,gBAAgB,EAChB,oBAAoB,EACpB,sBAAsB,EACtB,mBAAmB,EACnB,yBAAyB,EACzB,eAAe,EACf,mBAAmB,EACnB,yBAAyB,EACzB,mBAAmB,EACnB,sBAAsB,EACtB,aAAa,EACb,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,+BAA+B,CAAC"}