@contractspec/integration.runtime 2.9.0 → 3.0.0

package/dist/node/channel/dispatcher.js

@@ -0,0 +1,129 @@
+// src/channel/dispatcher.ts
+class ChannelOutboxDispatcher {
+  store;
+  batchSize;
+  maxRetries;
+  baseBackoffMs;
+  jitter;
+  now;
+  telemetry;
+  constructor(store, options = {}) {
+    this.store = store;
+    this.batchSize = Math.max(1, options.batchSize ?? 20);
+    this.maxRetries = Math.max(1, options.maxRetries ?? 3);
+    this.baseBackoffMs = Math.max(100, options.baseBackoffMs ?? 1000);
+    this.jitter = options.jitter ?? true;
+    this.now = options.now ?? (() => new Date);
+    this.telemetry = options.telemetry;
+  }
+  async dispatchBatch(resolveSender, limit) {
+    const actions = await this.store.claimPendingOutboxActions(Math.max(1, limit ?? this.batchSize), this.now());
+    const summary = {
+      claimed: actions.length,
+      sent: 0,
+      retried: 0,
+      deadLettered: 0
+    };
+    for (const action of actions) {
+      const startedAtMs = Date.now();
+      try {
+        const sender = await resolveSender(action.providerKey);
+        if (!sender) {
+          throw Object.assign(new Error("No sender configured for provider"), {
+            code: "SENDER_NOT_CONFIGURED"
+          });
+        }
+        const sendResult = await sender.send(action);
+        const latencyMs = Date.now() - startedAtMs;
+        await this.store.recordDeliveryAttempt({
+          actionId: action.id,
+          attempt: action.attemptCount,
+          responseStatus: sendResult.responseStatus,
+          responseBody: sendResult.responseBody,
+          latencyMs
+        });
+        await this.store.markOutboxSent(action.id, sendResult.providerMessageId);
+        summary.sent += 1;
+        this.telemetry?.record({
+          stage: "dispatch",
+          status: "sent",
+          workspaceId: action.workspaceId,
+          providerKey: action.providerKey,
+          actionId: action.id,
+          attempt: action.attemptCount,
+          latencyMs
+        });
+      } catch (error) {
+        const latencyMs = Date.now() - startedAtMs;
+        const errorCode = getErrorCode(error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        await this.store.recordDeliveryAttempt({
+          actionId: action.id,
+          attempt: action.attemptCount,
+          responseBody: errorMessage,
+          latencyMs
+        });
+        if (action.attemptCount >= this.maxRetries) {
+          await this.store.markOutboxDeadLetter({
+            actionId: action.id,
+            lastErrorCode: errorCode,
+            lastErrorMessage: errorMessage
+          });
+          summary.deadLettered += 1;
+          this.telemetry?.record({
+            stage: "dispatch",
+            status: "dead_letter",
+            workspaceId: action.workspaceId,
+            providerKey: action.providerKey,
+            actionId: action.id,
+            attempt: action.attemptCount,
+            latencyMs,
+            metadata: {
+              errorCode
+            }
+          });
+        } else {
+          const nextAttemptAt = new Date(this.now().getTime() + this.calculateBackoffMs(action.attemptCount));
+          await this.store.markOutboxRetry({
+            actionId: action.id,
+            nextAttemptAt,
+            lastErrorCode: errorCode,
+            lastErrorMessage: errorMessage
+          });
+          summary.retried += 1;
+          this.telemetry?.record({
+            stage: "dispatch",
+            status: "retry",
+            workspaceId: action.workspaceId,
+            providerKey: action.providerKey,
+            actionId: action.id,
+            attempt: action.attemptCount,
+            latencyMs,
+            metadata: {
+              errorCode
+            }
+          });
+        }
+      }
+    }
+    return summary;
+  }
+  calculateBackoffMs(attempt) {
+    const exponent = Math.max(0, attempt - 1);
+    const base = this.baseBackoffMs * Math.pow(2, exponent);
+    if (!this.jitter) {
+      return Math.round(base);
+    }
+    const jitterFactor = 0.8 + Math.random() * 0.4;
+    return Math.round(base * jitterFactor);
+  }
+}
+function getErrorCode(error) {
+  if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string") {
+    return error.code;
+  }
+  return "DISPATCH_FAILED";
+}
+export {
+  ChannelOutboxDispatcher
+};

package/dist/node/channel/github.js

@@ -0,0 +1,57 @@
+// src/channel/github.ts
+import { createHmac, timingSafeEqual } from "node:crypto";
+function verifyGithubSignature(input) {
+  if (!input.signatureHeader) {
+    return { valid: false, reason: "missing_signature" };
+  }
+  const expected = `sha256=${createHmac("sha256", input.webhookSecret).update(input.rawBody).digest("hex")}`;
+  const expectedBuffer = Buffer.from(expected, "utf8");
+  const providedBuffer = Buffer.from(input.signatureHeader, "utf8");
+  if (expectedBuffer.length !== providedBuffer.length) {
+    return { valid: false, reason: "signature_length_mismatch" };
+  }
+  return timingSafeEqual(expectedBuffer, providedBuffer) ? { valid: true } : { valid: false, reason: "signature_mismatch" };
+}
+function parseGithubWebhookPayload(rawBody) {
+  return JSON.parse(rawBody);
+}
+function normalizeGithubInboundEvent(input) {
+  const owner = input.payload.repository?.owner?.login;
+  const repo = input.payload.repository?.name;
+  const issueNumber = input.payload.issue?.number ?? input.payload.pull_request?.number;
+  const messageText = input.payload.comment?.body ?? input.payload.issue?.body ?? input.payload.pull_request?.body;
+  if (!owner || !repo || !issueNumber || !messageText) {
+    return null;
+  }
+  return {
+    workspaceId: input.workspaceId,
+    providerKey: "messaging.github",
+    externalEventId: input.deliveryId,
+    eventType: `github.${input.eventName}.${input.payload.action ?? "unknown"}`,
+    occurredAt: new Date,
+    signatureValid: input.signatureValid,
+    traceId: input.traceId,
+    rawPayload: input.rawBody,
+    thread: {
+      externalThreadId: `${owner}/${repo}#${issueNumber}`,
+      externalChannelId: `${owner}/${repo}`,
+      externalUserId: input.payload.sender?.login
+    },
+    message: {
+      text: messageText,
+      externalMessageId: input.payload.comment?.id != null ? String(input.payload.comment.id) : undefined
+    },
+    metadata: {
+      owner,
+      repo,
+      issueNumber: String(issueNumber),
+      action: input.payload.action ?? "unknown",
+      githubEvent: input.eventName
+    }
+  };
+}
+export {
+  verifyGithubSignature,
+  parseGithubWebhookPayload,
+  normalizeGithubInboundEvent
+};