@delexec/ops 0.1.0

package/node_modules/@delexec/transport-email/src/index.js

@@ -0,0 +1,185 @@
+import crypto from "node:crypto";
+
+export const RSP_EMAIL_SUBJECT_PREFIX = "[RSP]";
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function randomInt(maxInclusive) {
+  if (maxInclusive <= 0) {
+    return 0;
+  }
+  return Math.floor(Math.random() * (maxInclusive + 1));
+}
+
+function deepClone(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}
+
+export function normalizeAttachments(attachments = []) {
+  return (Array.isArray(attachments) ? attachments : []).map((attachment, index) => {
+    const contentBase64 = Buffer.isBuffer(attachment?.content)
+      ? attachment.content.toString("base64")
+      : attachment?.content_base64 || Buffer.from(String(attachment?.content || ""), "utf8").toString("base64");
+    const byteSize = Buffer.from(contentBase64 || "", "base64").length;
+    return {
+      attachment_id: attachment?.attachment_id || `att_${index}_${crypto.randomUUID()}`,
+      name: attachment?.name || `attachment-${index + 1}.bin`,
+      media_type: attachment?.media_type || "application/octet-stream",
+      content_base64: contentBase64,
+      byte_size: Number.isFinite(Number(attachment?.byte_size)) ? Number(attachment.byte_size) : byteSize
+    };
+  });
+}
+
+export function normalizeEnvelope(envelope = {}) {
+  const base = deepClone(envelope);
+  const bodyText =
+    typeof envelope.body_text === "string"
+      ? envelope.body_text
+      : typeof envelope.result_package === "object"
+        ? JSON.stringify(envelope.result_package)
+        : typeof envelope.payload === "string"
+          ? envelope.payload
+          : envelope.payload?.body_text || "";
+
+  const to =
+    envelope.to ||
+    envelope.address ||
+    envelope.receiver ||
+    (envelope.direction === "responder_to_caller" ? "caller-controller" : "responder-controller");
+  const from =
+    envelope.from ||
+    envelope.sender ||
+    (envelope.direction === "responder_to_caller" ? "responder-controller" : "caller-controller");
+
+  const payload =
+    envelope.payload && typeof envelope.payload === "object" && !Array.isArray(envelope.payload)
+      ? deepClone(envelope.payload)
+      : envelope.payload;
+
+  return {
+    ...base,
+    message_id: envelope.message_id || `mail_${crypto.randomUUID()}`,
+    request_id: envelope.request_id || payload?.request_id || envelope.result_package?.request_id || null,
+    thread_id: envelope.thread_id || envelope.thread_hint || envelope.request_id || `thread_${crypto.randomUUID()}`,
+    thread_hint: envelope.thread_hint || envelope.thread_id || envelope.request_id || null,
+    from,
+    to,
+    type: envelope.type || payload?.type || "email.message",
+    direction: envelope.direction || null,
+    body_text: bodyText,
+    payload,
+    result_package: envelope.result_package ? deepClone(envelope.result_package) : null,
+    attachments: normalizeAttachments(envelope.attachments || payload?.attachments || []),
+    sent_at: nowIso()
+  };
+}
+
+export function buildEmailSubject(envelope = {}) {
+  const normalized = normalizeEnvelope(envelope);
+  const type = normalized.type || "message";
+  const requestId = normalized.request_id || normalized.thread_id || normalized.message_id;
+  return `${RSP_EMAIL_SUBJECT_PREFIX} ${type} ${requestId}`;
+}
+
+export function isRspEmailSubject(subject) {
+  return typeof subject === "string" && subject.startsWith(`${RSP_EMAIL_SUBJECT_PREFIX} `);
+}
+
+export function buildRspHeaders(envelope = {}) {
+  const normalized = normalizeEnvelope(envelope);
+  return {
+    "X-RSP-Transport": "1",
+    "X-RSP-Request-Id": normalized.request_id || "",
+    "X-RSP-Thread-Id": normalized.thread_id || "",
+    "X-RSP-Message-Id": normalized.message_id || "",
+    "X-RSP-Type": normalized.type || "",
+    "X-RSP-From": normalized.from || "",
+    "X-RSP-To": normalized.to || ""
+  };
+}
+
+export class InMemoryEmailTransport {
+  constructor(options = {}) {
+    this.messages = [];
+    this.options = {
+      duplicateRate: Number(options.duplicateRate || 0),
+      outOfOrderRate: Number(options.outOfOrderRate || 0),
+      minDelayMs: Number(options.minDelayMs || 0),
+      maxDelayMs: Number(options.maxDelayMs || 0)
+    };
+  }
+
+  async send(envelope) {
+    const delayRange = Math.max(this.options.maxDelayMs - this.options.minDelayMs, 0);
+    const delayMs = this.options.minDelayMs + randomInt(delayRange);
+    if (delayMs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+
+    const record = normalizeEnvelope(envelope);
+    this.messages.push(record);
+
+    if (Math.random() < this.options.duplicateRate) {
+      this.messages.push({ ...deepClone(record), message_id: `dup_${crypto.randomUUID()}` });
+    }
+
+    if (Math.random() < this.options.outOfOrderRate && this.messages.length >= 2) {
+      const last = this.messages.length - 1;
+      const swapWith = randomInt(last - 1);
+      const temp = this.messages[last];
+      this.messages[last] = this.messages[swapWith];
+      this.messages[swapWith] = temp;
+    }
+
+    return deepClone(record);
+  }
+
+  async poll({ receiver, limit = 50 } = {}) {
+    const items = this.messages
+      .filter((item) => !receiver || item.to === receiver)
+      .slice(0, limit)
+      .map((item) => deepClone(item));
+    return { items };
+  }
+
+  async ack(messageId, { receiver } = {}) {
+    const index = this.messages.findIndex((item) => item.message_id === messageId && (!receiver || item.to === receiver));
+    if (index === -1) {
+      return { acked: false };
+    }
+    this.messages.splice(index, 1);
+    return { acked: true };
+  }
+
+  async sendTaskEmail(message) {
+    return this.send(message);
+  }
+
+  async pollThreadReplies({ request_id, direction = "responder_to_caller", limit = 50 } = {}) {
+    return this.messages
+      .filter((item) => (!request_id || item.request_id === request_id) && item.direction === direction)
+      .slice(0, limit)
+      .map((item) => deepClone(item));
+  }
+
+  clear() {
+    this.messages.length = 0;
+  }
+}
+
+export async function sendTaskEmail(transport, message) {
+  if (!transport || typeof transport.sendTaskEmail !== "function") {
+    throw new Error("TRANSPORT_SEND_NOT_AVAILABLE");
+  }
+  return transport.sendTaskEmail(message);
+}
+
+export async function pollThreadReplies(transport, query) {
+  if (!transport || typeof transport.pollThreadReplies !== "function") {
+    throw new Error("TRANSPORT_POLL_NOT_AVAILABLE");
+  }
+  return transport.pollThreadReplies(query);
+}

package/node_modules/@delexec/transport-emailengine/README.md

@@ -0,0 +1,3 @@
+# @delexec/transport-emailengine
+
+EmailEngine transport adapter for delegated execution.

package/node_modules/@delexec/transport-emailengine/README.zh-CN.md

@@ -0,0 +1,6 @@
+# @delexec/transport-emailengine
+
+> 英文版：README.md
+> 说明：中文文档为准。
+
+用于委托执行的 EmailEngine 传输适配器。

package/node_modules/@delexec/transport-emailengine/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@delexec/transport-emailengine",
+  "version": "0.1.0",
+  "description": "EmailEngine transport adapter for delegated execution",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "delegated-execution",
+    "transport",
+    "emailengine"
+  ],
+  "dependencies": {
+    "@delexec/transport-email": "0.1.0"
+  }
+}

package/node_modules/@delexec/transport-emailengine/src/index.js

@@ -0,0 +1,210 @@
+import {
+  buildEmailSubject,
+  buildRspHeaders,
+  isRspEmailSubject,
+  normalizeEnvelope
+} from "@delexec/transport-email";
+
+function base64ToUtf8(value) {
+  return Buffer.from(value || "", "base64").toString("utf8");
+}
+
+async function request(baseUrl, pathname, { method = "GET", headers = {}, body, parse = "json" } = {}) {
+  const response = await fetch(new URL(pathname, baseUrl), {
+    method,
+    headers,
+    body
+  });
+  if (parse === "buffer") {
+    return {
+      status: response.status,
+      headers: response.headers,
+      body: Buffer.from(await response.arrayBuffer())
+    };
+  }
+  const text = await response.text();
+  return {
+    status: response.status,
+    headers: response.headers,
+    body: text ? JSON.parse(text) : null
+  };
+}
+
+function authHeaders(accessToken, extra = {}) {
+  return {
+    Authorization: `Bearer ${accessToken}`,
+    ...extra
+  };
+}
+
+async function fetchMessageAttachments(baseUrl, account, accessToken, attachments = []) {
+  const results = [];
+  for (const attachment of attachments) {
+    const response = await request(baseUrl, `/v1/account/${encodeURIComponent(account)}/attachment/${encodeURIComponent(attachment.id)}`, {
+      headers: authHeaders(accessToken),
+      parse: "buffer"
+    });
+    if (response.status !== 200) {
+      throw new Error(`emailengine_attachment_fetch_failed:${response.status}`);
+    }
+    const content = response.body;
+    results.push({
+      attachment_id: attachment.id,
+      name: attachment.filename || attachment.name || `attachment-${results.length + 1}.bin`,
+      media_type: attachment.contentType || attachment.mimeType || "application/octet-stream",
+      content_base64: content.toString("base64"),
+      byte_size: content.length
+    });
+  }
+  return results;
+}
+
+async function loadMessage(baseUrl, account, accessToken, message) {
+  const response = await request(baseUrl, `/v1/account/${encodeURIComponent(account)}/message/${encodeURIComponent(message.id)}?textType=*`, {
+    headers: authHeaders(accessToken)
+  });
+  if (response.status !== 200) {
+    throw new Error(`emailengine_message_fetch_failed:${response.status}`);
+  }
+  const body = response.body || {};
+  const attachments = await fetchMessageAttachments(baseUrl, account, accessToken, body.attachments || []);
+  const textBody = Array.isArray(body.text?.plain)
+    ? body.text.plain.join("\n")
+    : typeof body.text?.plain === "string"
+      ? body.text.plain
+      : "";
+  let payload = null;
+  try {
+    payload = textBody ? JSON.parse(textBody) : null;
+  } catch {
+    payload = null;
+  }
+  return normalizeEnvelope({
+    message_id: body.messageId || message.messageId || message.id || null,
+    thread_id: body.threadId || message.threadId || null,
+    thread_hint: body.threadId || message.threadId || null,
+    request_id: body.headers?.["x-rsp-request-id"] || body.headers?.["X-RSP-Request-Id"] || payload?.request_id || null,
+    from: body.from?.address || body.from?.[0]?.address || null,
+    to: body.to?.[0]?.address || body.to?.address || null,
+    type: body.headers?.["x-rsp-type"] || body.headers?.["X-RSP-Type"] || payload?.type || "email.message",
+    body_text: textBody,
+    payload,
+    attachments
+  });
+}
+
+export function createEmailEngineTransportAdapter({
+  baseUrl,
+  account,
+  accessToken,
+  receiver = account,
+  sender = account,
+  pageSize = 20
+}) {
+  if (!baseUrl) {
+    throw new Error("emailengine_base_url_required");
+  }
+  if (!account) {
+    throw new Error("emailengine_account_required");
+  }
+  if (!accessToken) {
+    throw new Error("emailengine_access_token_required");
+  }
+
+  return {
+    async send(envelope) {
+      const normalized = normalizeEnvelope({
+        ...envelope,
+        from: envelope.from || sender,
+        to: envelope.to || receiver
+      });
+      const response = await request(baseUrl, `/v1/account/${encodeURIComponent(account)}/submit`, {
+        method: "POST",
+        headers: authHeaders(accessToken, {
+          "content-type": "application/json; charset=utf-8"
+        }),
+        body: JSON.stringify({
+          from: normalized.from,
+          to: [normalized.to],
+          subject: buildEmailSubject(normalized),
+          text: normalized.body_text,
+          headers: buildRspHeaders(normalized),
+          attachments: normalized.attachments.map((attachment) => ({
+            filename: attachment.name,
+            contentType: attachment.media_type,
+            content: attachment.content_base64,
+            encoding: "base64"
+          }))
+        })
+      });
+      if (response.status !== 200 && response.status !== 202) {
+        throw new Error(`emailengine_send_failed:${response.status}`);
+      }
+      return normalized;
+    },
+
+    async poll({ limit = 10 } = {}) {
+      const response = await request(baseUrl, `/v1/account/${encodeURIComponent(account)}/search?path=INBOX`, {
+        method: "POST",
+        headers: authHeaders(accessToken, {
+          "content-type": "application/json; charset=utf-8"
+        }),
+        body: JSON.stringify({
+          page: 0,
+          pageSize: Math.max(limit, pageSize),
+          search: {
+            unseen: true
+          }
+        })
+      });
+      if (response.status !== 200) {
+        throw new Error(`emailengine_poll_failed:${response.status}`);
+      }
+      const messages = Array.isArray(response.body?.messages) ? response.body.messages : [];
+      const items = [];
+      for (const message of messages) {
+        if (!isRspEmailSubject(message.subject || "")) {
+          continue;
+        }
+        items.push(await loadMessage(baseUrl, account, accessToken, message));
+        if (items.length >= limit) {
+          break;
+        }
+      }
+      return { items };
+    },
+
+    async ack(messageId) {
+      const response = await request(baseUrl, `/v1/account/${encodeURIComponent(account)}/message/${encodeURIComponent(messageId)}`, {
+        method: "PUT",
+        headers: authHeaders(accessToken, {
+          "content-type": "application/json; charset=utf-8"
+        }),
+        body: JSON.stringify({
+          flags: {
+            add: ["\\Seen"]
+          }
+        })
+      });
+      if (response.status !== 200) {
+        throw new Error(`emailengine_ack_failed:${response.status}`);
+      }
+      return { acked: true };
+    },
+
+    async health() {
+      const response = await request(baseUrl, `/v1/account/${encodeURIComponent(account)}`, {
+        headers: authHeaders(accessToken)
+      });
+      if (response.status !== 200) {
+        throw new Error(`emailengine_health_failed:${response.status}`);
+      }
+      return {
+        ok: true,
+        provider: "emailengine",
+        version: "API v1",
+        account
+      };
+    }
+  };
+}

package/node_modules/@delexec/transport-gmail/README.md

@@ -0,0 +1,3 @@
+# @delexec/transport-gmail
+
+Gmail transport adapter for delegated execution.

package/node_modules/@delexec/transport-gmail/README.zh-CN.md

@@ -0,0 +1,6 @@
+# @delexec/transport-gmail
+
+> 英文版：README.md
+> 说明：中文文档为准。
+
+用于委托执行的 Gmail 传输适配器。

package/node_modules/@delexec/transport-gmail/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@delexec/transport-gmail",
+  "version": "0.1.0",
+  "description": "Gmail transport adapter for delegated execution",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "delegated-execution",
+    "transport",
+    "gmail"
+  ],
+  "dependencies": {
+    "@delexec/transport-email": "0.1.0"
+  }
+}