@delexec/ops 0.1.0

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

@@ -0,0 +1,295 @@
+import {
+  buildEmailSubject,
+  buildRspHeaders,
+  isRspEmailSubject,
+  normalizeEnvelope,
+  RSP_EMAIL_SUBJECT_PREFIX
+} from "@delexec/transport-email";
+
+function base64UrlEncode(buffer) {
+  return Buffer.from(buffer)
+    .toString("base64")
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=+$/g, "");
+}
+
+function base64UrlDecode(value) {
+  const normalized = String(value || "").replace(/-/g, "+").replace(/_/g, "/");
+  const pad = normalized.length % 4 === 0 ? "" : "=".repeat(4 - (normalized.length % 4));
+  return Buffer.from(normalized + pad, "base64");
+}
+
+async function request(url, { method = "GET", headers = {}, body } = {}) {
+  const response = await fetch(url, {
+    method,
+    headers,
+    body
+  });
+  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 refreshAccessToken({ tokenUrl, clientId, clientSecret, refreshToken }) {
+  const response = await request(tokenUrl, {
+    method: "POST",
+    headers: {
+      "content-type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      client_id: clientId,
+      client_secret: clientSecret,
+      refresh_token: refreshToken,
+      grant_type: "refresh_token"
+    })
+  });
+  if (response.status !== 200 || !response.body?.access_token) {
+    throw new Error(`gmail_token_refresh_failed:${response.status}`);
+  }
+  return response.body.access_token;
+}
+
+function buildMimeMessage(envelope) {
+  const normalized = normalizeEnvelope(envelope);
+  const headers = buildRspHeaders(normalized);
+  const headerLines = [
+    `From: ${normalized.from}`,
+    `To: ${normalized.to}`,
+    `Subject: ${buildEmailSubject(normalized)}`,
+    "MIME-Version: 1.0"
+  ];
+  for (const [key, value] of Object.entries(headers)) {
+    headerLines.push(`${key}: ${value}`);
+  }
+
+  if (normalized.attachments.length === 0) {
+    return `${headerLines.join("\r\n")}\r\nContent-Type: text/plain; charset=utf-8\r\n\r\n${normalized.body_text}`;
+  }
+
+  const boundary = `rsp-${normalized.message_id}`;
+  const parts = [
+    `--${boundary}\r\nContent-Type: text/plain; charset=utf-8\r\n\r\n${normalized.body_text}\r\n`
+  ];
+  for (const attachment of normalized.attachments) {
+    parts.push(
+      `--${boundary}\r\nContent-Type: ${attachment.media_type}\r\nContent-Disposition: attachment; filename="${attachment.name}"\r\nContent-Transfer-Encoding: base64\r\n\r\n${attachment.content_base64}\r\n`
+    );
+  }
+  parts.push(`--${boundary}--`);
+  return `${headerLines.join("\r\n")}\r\nContent-Type: multipart/mixed; boundary="${boundary}"\r\n\r\n${parts.join("")}`;
+}
+
+function findHeader(headers = [], name) {
+  const match = headers.find((header) => String(header.name || "").toLowerCase() === String(name).toLowerCase());
+  return match?.value || null;
+}
+
+function walkParts(part, visitor) {
+  if (!part) {
+    return;
+  }
+  visitor(part);
+  for (const child of part.parts || []) {
+    walkParts(child, visitor);
+  }
+}
+
+function extractPlainText(payload) {
+  if (!payload) {
+    return "";
+  }
+  let text = "";
+  walkParts(payload, (part) => {
+    if (text) {
+      return;
+    }
+    if (part.mimeType === "text/plain" && part.body?.data) {
+      text = base64UrlDecode(part.body.data).toString("utf8");
+    }
+  });
+  if (!text && payload.body?.data) {
+    text = base64UrlDecode(payload.body.data).toString("utf8");
+  }
+  return text;
+}
+
+async function extractAttachments(apiBaseUrl, user, accessToken, messageId, payload) {
+  const attachments = [];
+  const parts = [];
+  walkParts(payload, (part) => {
+    if (part.filename && (part.body?.attachmentId || part.body?.data)) {
+      parts.push(part);
+    }
+  });
+  for (const part of parts) {
+    let content;
+    if (part.body?.data) {
+      content = base64UrlDecode(part.body.data);
+    } else {
+      const response = await request(
+        `${apiBaseUrl}/users/${encodeURIComponent(user)}/messages/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(part.body.attachmentId)}`,
+        {
+          headers: authHeaders(accessToken)
+        }
+      );
+      if (response.status !== 200) {
+        throw new Error(`gmail_attachment_fetch_failed:${response.status}`);
+      }
+      content = base64UrlDecode(response.body?.data || "");
+    }
+    attachments.push({
+      attachment_id: part.body?.attachmentId || null,
+      name: part.filename,
+      media_type: part.mimeType || "application/octet-stream",
+      content_base64: content.toString("base64"),
+      byte_size: content.length
+    });
+  }
+  return attachments;
+}
+
+async function loadMessage(apiBaseUrl, user, accessToken, message) {
+  const response = await request(`${apiBaseUrl}/users/${encodeURIComponent(user)}/messages/${encodeURIComponent(message.id)}?format=full`, {
+    headers: authHeaders(accessToken)
+  });
+  if (response.status !== 200) {
+    throw new Error(`gmail_message_fetch_failed:${response.status}`);
+  }
+  const payload = response.body?.payload || {};
+  const headers = payload.headers || [];
+  const attachments = await extractAttachments(apiBaseUrl, user, accessToken, message.id, payload);
+  const textBody = extractPlainText(payload);
+  let parsedPayload = null;
+  try {
+    parsedPayload = textBody ? JSON.parse(textBody) : null;
+  } catch {
+    parsedPayload = null;
+  }
+  return normalizeEnvelope({
+    message_id: response.body?.id || message.id,
+    thread_id: response.body?.threadId || message.threadId || null,
+    thread_hint: response.body?.threadId || message.threadId || null,
+    request_id: findHeader(headers, "X-RSP-Request-Id") || parsedPayload?.request_id,
+    from: findHeader(headers, "From"),
+    to: findHeader(headers, "To"),
+    subject: findHeader(headers, "Subject"),
+    type: findHeader(headers, "X-RSP-Type") || parsedPayload?.type || "email.message",
+    body_text: textBody,
+    payload: parsedPayload,
+    attachments
+  });
+}
+
+export function createGmailTransportAdapter({
+  clientId,
+  clientSecret,
+  refreshToken,
+  user,
+  receiver = user,
+  sender = user,
+  apiBaseUrl = "https://gmail.googleapis.com/gmail/v1",
+  tokenUrl = "https://oauth2.googleapis.com/token"
+}) {
+  if (!clientId) {
+    throw new Error("gmail_client_id_required");
+  }
+  if (!clientSecret) {
+    throw new Error("gmail_client_secret_required");
+  }
+  if (!refreshToken) {
+    throw new Error("gmail_refresh_token_required");
+  }
+  if (!user) {
+    throw new Error("gmail_user_required");
+  }
+
+  return {
+    async send(envelope) {
+      const normalized = normalizeEnvelope({
+        ...envelope,
+        from: envelope.from || sender,
+        to: envelope.to || receiver
+      });
+      const accessToken = await refreshAccessToken({ tokenUrl, clientId, clientSecret, refreshToken });
+      const raw = base64UrlEncode(Buffer.from(buildMimeMessage(normalized), "utf8"));
+      const response = await request(`${apiBaseUrl}/users/${encodeURIComponent(user)}/messages/send`, {
+        method: "POST",
+        headers: authHeaders(accessToken, {
+          "content-type": "application/json; charset=utf-8"
+        }),
+        body: JSON.stringify({ raw })
+      });
+      if (response.status !== 200) {
+        throw new Error(`gmail_send_failed:${response.status}`);
+      }
+      return normalized;
+    },
+
+    async poll({ limit = 10 } = {}) {
+      const accessToken = await refreshAccessToken({ tokenUrl, clientId, clientSecret, refreshToken });
+      const query = new URLSearchParams({
+        q: `in:inbox is:unread subject:"${RSP_EMAIL_SUBJECT_PREFIX}"`,
+        maxResults: String(limit)
+      });
+      const response = await request(`${apiBaseUrl}/users/${encodeURIComponent(user)}/messages?${query.toString()}`, {
+        headers: authHeaders(accessToken)
+      });
+      if (response.status !== 200) {
+        throw new Error(`gmail_poll_failed:${response.status}`);
+      }
+      const items = [];
+      for (const message of response.body?.messages || []) {
+        const loaded = await loadMessage(apiBaseUrl, user, accessToken, message);
+        if (!isRspEmailSubject(loaded.subject || "")) {
+          continue;
+        }
+        items.push(loaded);
+      }
+      return { items };
+    },
+
+    async ack(messageId) {
+      const accessToken = await refreshAccessToken({ tokenUrl, clientId, clientSecret, refreshToken });
+      const response = await request(`${apiBaseUrl}/users/${encodeURIComponent(user)}/messages/${encodeURIComponent(messageId)}/modify`, {
+        method: "POST",
+        headers: authHeaders(accessToken, {
+          "content-type": "application/json; charset=utf-8"
+        }),
+        body: JSON.stringify({
+          removeLabelIds: ["UNREAD"]
+        })
+      });
+      if (response.status !== 200) {
+        throw new Error(`gmail_ack_failed:${response.status}`);
+      }
+      return { acked: true };
+    },
+
+    async health() {
+      const accessToken = await refreshAccessToken({ tokenUrl, clientId, clientSecret, refreshToken });
+      const response = await request(`${apiBaseUrl}/users/${encodeURIComponent(user)}/profile`, {
+        headers: authHeaders(accessToken)
+      });
+      if (response.status !== 200) {
+        throw new Error(`gmail_health_failed:${response.status}`);
+      }
+      return {
+        ok: true,
+        provider: "gmail",
+        version: "gmail/v1",
+        user
+      };
+    }
+  };
+}

package/node_modules/@delexec/transport-relay-http/README.md

@@ -0,0 +1,3 @@
+# @delexec/transport-relay-http
+
+HTTP relay transport adapter for delegated execution services.

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

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

package/node_modules/@delexec/transport-relay-http/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@delexec/transport-relay-http",
+  "version": "0.1.0",
+  "description": "HTTP relay 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",
+    "relay"
+  ]
+}

package/node_modules/@delexec/transport-relay-http/src/index.js

@@ -0,0 +1,124 @@
+import crypto from "node:crypto";
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function resolveReceiver(target) {
+  if (!target || typeof target !== "string" || !target.startsWith("local://")) {
+    return target;
+  }
+
+  try {
+    const parsed = new URL(target);
+    const segments = parsed.pathname.split("/").filter(Boolean);
+    if (parsed.hostname === "relay" && segments[0]) {
+      return segments[0];
+    }
+    if (segments[0]) {
+      return segments[0];
+    }
+    if (parsed.hostname) {
+      return parsed.hostname;
+    }
+  } catch {
+    return target;
+  }
+
+  return target;
+}
+
+async function requestJson(baseUrl, pathname, { method = "GET", body } = {}) {
+  const response = await fetch(new URL(pathname, baseUrl), {
+    method,
+    headers: body === undefined ? undefined : { "content-type": "application/json; charset=utf-8" },
+    body: body === undefined ? undefined : JSON.stringify(body)
+  });
+  const text = await response.text();
+  return {
+    status: response.status,
+    body: text ? JSON.parse(text) : null
+  };
+}
+
+export function createRelayHttpTransportAdapter({ baseUrl, receiver }) {
+  if (!baseUrl) {
+    throw new Error("relay_http_base_url_required");
+  }
+  if (!receiver) {
+    throw new Error("relay_http_receiver_required");
+  }
+
+  return {
+    async send(envelope) {
+      const target = resolveReceiver(envelope.to || envelope.responder_id || receiver);
+      const message = {
+        ...envelope,
+        to: envelope.to || target,
+        message_id: envelope.message_id || `msg_${crypto.randomUUID()}`,
+        queued_at: envelope.queued_at || nowIso()
+      };
+      const response = await requestJson(baseUrl, "/v1/messages/send", {
+        method: "POST",
+        body: {
+          receiver: target,
+          envelope: message
+        }
+      });
+      if (response.status !== 201) {
+        throw new Error(`relay_http_send_failed:${response.status}`);
+      }
+      return response.body;
+    },
+
+    async poll({ limit = 10, receiver: overrideReceiver } = {}) {
+      const response = await requestJson(baseUrl, "/v1/messages/poll", {
+        method: "POST",
+        body: {
+          receiver: overrideReceiver || receiver,
+          limit
+        }
+      });
+      if (response.status !== 200) {
+        throw new Error(`relay_http_poll_failed:${response.status}`);
+      }
+      return response.body;
+    },
+
+    async ack(messageId, { receiver: overrideReceiver } = {}) {
+      const response = await requestJson(baseUrl, "/v1/messages/ack", {
+        method: "POST",
+        body: {
+          receiver: overrideReceiver || receiver,
+          message_id: messageId
+        }
+      });
+      if (response.status !== 200) {
+        throw new Error(`relay_http_ack_failed:${response.status}`);
+      }
+      return response.body;
+    },
+
+    async peek({ thread_id, receiver: overrideReceiver } = {}) {
+      const params = new URLSearchParams({
+        receiver: overrideReceiver || receiver
+      });
+      if (thread_id) {
+        params.set("thread_id", thread_id);
+      }
+      const response = await requestJson(baseUrl, `/v1/messages/peek?${params.toString()}`);
+      if (response.status !== 200) {
+        throw new Error(`relay_http_peek_failed:${response.status}`);
+      }
+      return response.body;
+    },
+
+    async health() {
+      const response = await requestJson(baseUrl, `/v1/receivers/${encodeURIComponent(receiver)}/health`);
+      if (response.status !== 200) {
+        throw new Error(`relay_http_health_failed:${response.status}`);
+      }
+      return response.body;
+    }
+  };
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@delexec/ops",
+  "version": "0.1.0",
+  "description": "Unified operator CLI for delegated execution clients",
+  "type": "module",
+  "bin": {
+    "delexec-ops": "src/cli.js",
+    "croc-ops": "src/cli.js"
+  },
+  "bundleDependencies": [
+    "@delexec/caller-controller",
+    "@delexec/caller-controller-core",
+    "@delexec/caller-skill-mcp-adapter",
+    "@delexec/caller-skill-adapter",
+    "@delexec/runtime-utils",
+    "@delexec/responder-controller",
+    "@delexec/responder-runtime-core",
+    "@delexec/sqlite-store",
+    "@delexec/transport-email",
+    "@delexec/transport-emailengine",
+    "@delexec/transport-gmail",
+    "@delexec/transport-relay-http"
+  ],
+  "main": "src/cli.js",
+  "exports": {
+    ".": "./src/cli.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "prepack": "node ../../scripts/bundle-workspace-deps.mjs stage apps/ops",
+    "postpack": "node ../../scripts/bundle-workspace-deps.mjs cleanup apps/ops",
+    "start": "node src/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "delegated-execution",
+    "ops",
+    "cli"
+  ],
+  "dependencies": {
+    "@delexec/caller-controller": "0.1.0",
+    "@delexec/caller-controller-core": "0.1.0",
+    "@delexec/caller-skill-mcp-adapter": "0.1.0",
+    "@delexec/caller-skill-adapter": "0.1.0",
+    "@delexec/contracts": "^0.1.0",
+    "@delexec/runtime-utils": "0.1.0",
+    "@delexec/responder-controller": "0.1.0",
+    "@delexec/responder-runtime-core": "0.1.0",
+    "@delexec/sqlite-store": "0.1.0",
+    "@delexec/transport-email": "0.1.0",
+    "@delexec/transport-emailengine": "0.1.0",
+    "@delexec/transport-gmail": "0.1.0",
+    "@delexec/transport-relay-http": "0.1.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "better-sqlite3": "^12.6.2",
+    "zod": "^4.1.12"
+  }
+}