@chanlerdev/scorel 0.0.2 → 0.0.3

package/extensions/builtin/telegram/adapter.d.ts

@@ -30,7 +30,7 @@ export type TelegramAdapter = {
     };
   }): Promise<void>;
   stop(): Promise<void>;
-  sendMessage(target: TelegramTarget, message: { text: string }): Promise<void>;
+  sendMessage(target: TelegramTarget, message: { text?: string; attachments?: Array<Record<string, unknown>> }): Promise<void>;
   setTyping?(target: TelegramTarget, typing: boolean): Promise<void>;
 };
 

package/extensions/builtin/telegram/adapter.js

@@ -87,6 +87,7 @@ export const createTelegramAdapter = (options) => {
       }
     },
     async sendMessage(target, message) {
+      rejectUnsupportedAttachments("Telegram", message);
       const chatId = target?.data?.chatId;
       if (chatId === undefined || chatId === null) {
         throw new Error("telegram target is missing chatId");
@@ -249,4 +250,10 @@ const safeErrorMessage = (cause) => cause instanceof Error ? redactToken(cause.m
 
 export const redactToken = (value) => value.replace(/bot[0-9]+:[A-Za-z0-9_-]+/g, "bot[REDACTED]");
 
+const rejectUnsupportedAttachments = (platform, message) => {
+  if (Array.isArray(message.attachments) && message.attachments.length > 0) {
+    throw new Error(`${platform} attachment sending is not supported yet`);
+  }
+};
+
 const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

package/extensions/builtin/telegram/skills/telegram/SKILL.md

@@ -7,3 +7,5 @@ description: Reply to the current Telegram conversation through SendChannelMessa
 When a message comes from Telegram, use `SendChannelMessage` to reply to the current chat when a response is needed.
 
 In groups, assume the user mentioned or replied to the bot before the message reached Scorel. Keep replies concise and avoid exposing raw chat ids, user ids, bot tokens, or internal routing details.
+
+If work will take more than a brief moment, send a short acknowledgement first, then follow with concise progress or the final result.

package/extensions/builtin/wechat/adapter.d.ts

@@ -0,0 +1,24 @@
+export type WeChatAdapterOptions = {
+  webhookUrl?: string;
+  callbackHost?: string;
+  callbackPort?: number;
+  callbackPath?: string;
+  callbackToken?: string;
+};
+
+export type WeChatTarget = {
+  externalConversationId: string;
+  data?: Record<string, unknown>;
+};
+
+export type WeChatAdapter = {
+  start(ctx: unknown): Promise<void>;
+  stop(): Promise<void>;
+  callbackUrl?(): string | undefined;
+  sendMessage(target: WeChatTarget, message: { text?: string; attachments?: Array<Record<string, unknown>> }): Promise<void>;
+};
+
+export function createAdapter(options?: { config?: Record<string, string | number | boolean> }): WeChatAdapter;
+export function createWeChatAdapter(options: WeChatAdapterOptions): WeChatAdapter;
+export function normalizeWeChatEvent(event: unknown): unknown;
+export function redactWeChatSecret(value: string): string;

package/extensions/builtin/wechat/adapter.js

@@ -0,0 +1,226 @@
+import { createHash } from "node:crypto";
+import { createServer } from "node:http";
+
+export const createAdapter = ({ config = {} } = {}) => {
+  return createWeChatAdapter({
+    webhookUrl: optionalStringConfig(config.webhookUrl, "WeChat webhook URL"),
+    callbackHost: stringConfig(config.callbackHost, "127.0.0.1"),
+    callbackPort: numberConfig(config.callbackPort, undefined),
+    callbackPath: stringConfig(config.callbackPath, "/wechat/callback"),
+    callbackToken: optionalStringConfig(config.callbackToken, "WeChat callback token"),
+  });
+};
+
+export const createWeChatAdapter = (options) => {
+  if (!options.webhookUrl && !options.callbackToken) {
+    throw new Error("WeChat webhook URL or callback token is required");
+  }
+  let server;
+  let ctx;
+  let callbackPort;
+
+  return {
+    async start(startCtx) {
+      ctx = startCtx;
+      if (!options.callbackToken) {
+        ctx?.logger?.info("wechat_callback_not_configured", {});
+        return;
+      }
+      server = createServer((request, response) => {
+        void handleCallbackRequest(options, request, response, ctx).catch((cause) => {
+          ctx?.logger?.error("wechat_callback_failed", { message: redactWeChatSecret(safeErrorMessage(cause)) });
+          if (!response.headersSent) {
+            response.writeHead(500, { "content-type": "text/plain; charset=utf-8" });
+          }
+          response.end("error");
+        });
+      });
+      await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.once("listening", () => {
+          server.off("error", reject);
+          resolve();
+        });
+        server.listen(options.callbackPort ?? 0, options.callbackHost ?? "127.0.0.1");
+      });
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        throw new Error("WeChat callback server did not expose a TCP address");
+      }
+      callbackPort = address.port;
+      ctx?.logger?.info("wechat_callback_started", { url: callbackUrl(options, callbackPort) });
+    },
+    async stop() {
+      const closing = server;
+      server = undefined;
+      callbackPort = undefined;
+      if (closing) {
+        await new Promise((resolve, reject) => closing.close((error) => error ? reject(error) : resolve()));
+      }
+    },
+    callbackUrl() {
+      return callbackPort ? callbackUrl(options, callbackPort) : undefined;
+    },
+    async sendMessage(_target, message) {
+      rejectUnsupportedAttachments("WeChat", message);
+      if (!options.webhookUrl) {
+        throw new Error("WeChat outbound webhook URL is not configured");
+      }
+      const response = await fetch(options.webhookUrl, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          msgtype: "text",
+          text: { content: String(message.text).trim() },
+        }),
+      });
+      const payload = await response.json().catch(() => undefined);
+      if (!response.ok || (payload?.errcode !== undefined && payload.errcode !== 0)) {
+        throw new Error(redactWeChatSecret(`wechat send failed: ${payload?.errmsg ?? response.status}`));
+      }
+    },
+  };
+};
+
+export const normalizeWeChatEvent = (event) => {
+  const text = typeof event?.Content === "string" ? event.Content.trim() : "";
+  if (!text || event?.MsgType !== "text") {
+    return undefined;
+  }
+  const openId = optionalEventString(event.FromUserName);
+  if (!openId) {
+    return undefined;
+  }
+  const messageId = optionalEventString(event.MsgId);
+  const externalConversationId = `wechat:official:${openId}`;
+  return {
+    externalConversationId,
+    text,
+    conversationType: "official",
+    mentionedBot: true,
+    target: {
+      externalConversationId,
+      data: { kind: "official", id: openId, ...(messageId ? { messageId } : {}) },
+    },
+    data: {
+      ...(messageId ? { messageId } : {}),
+    },
+  };
+};
+
+export const redactWeChatSecret = (value) =>
+  String(value)
+    .replace(/([?&]key=)[^&\s]+/g, "$1[REDACTED]")
+    .replace(/(callbackToken"\s*:\s*")[^"]+/g, "$1[REDACTED]");
+
+const handleCallbackRequest = async (options, request, response, ctx) => {
+  const url = new URL(request.url ?? "/", "http://127.0.0.1");
+  if (url.pathname !== (options.callbackPath ?? "/wechat/callback")) {
+    response.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+    response.end("not found");
+    return;
+  }
+  const timestamp = url.searchParams.get("timestamp") ?? "";
+  const nonce = url.searchParams.get("nonce") ?? "";
+  const signature = url.searchParams.get("signature") ?? "";
+  if (!verifySignature(options.callbackToken, timestamp, nonce, signature)) {
+    response.writeHead(401, { "content-type": "text/plain; charset=utf-8" });
+    response.end("invalid signature");
+    return;
+  }
+  if (request.method === "GET") {
+    response.writeHead(200, { "content-type": "text/plain; charset=utf-8" });
+    response.end(url.searchParams.get("echostr") ?? "");
+    return;
+  }
+  if (request.method !== "POST") {
+    response.writeHead(405, { "content-type": "text/plain; charset=utf-8" });
+    response.end("method not allowed");
+    return;
+  }
+  const event = parseWeChatXml(await readText(request));
+  const incoming = normalizeWeChatEvent(event);
+  if (incoming) {
+    await ctx?.onMessage(incoming);
+  }
+  response.writeHead(200, { "content-type": "text/plain; charset=utf-8" });
+  response.end("success");
+};
+
+const optionalEventString = (value) => typeof value === "string" && value.trim() ? value.trim() : undefined;
+
+const requiredStringConfig = (value, name) => {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${name} is required`);
+  }
+  return value.trim();
+};
+
+const optionalStringConfig = (value, name) => {
+  if (value === undefined || value === "") {
+    return undefined;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`${name} must be a string`);
+  }
+  return value.trim();
+};
+
+const stringConfig = (value, fallback) => {
+  if (value === undefined || value === "") {
+    return fallback;
+  }
+  if (typeof value !== "string") {
+    throw new Error("WeChat config value must be a string");
+  }
+  return value.trim();
+};
+
+const numberConfig = (value, fallback) => {
+  if (value === undefined || value === "") {
+    return fallback;
+  }
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+    throw new Error("WeChat callback port must be a valid TCP port");
+  }
+  return parsed;
+};
+
+const callbackUrl = (options, port) =>
+  `http://${options.callbackHost ?? "127.0.0.1"}:${port}${options.callbackPath ?? "/wechat/callback"}`;
+
+const verifySignature = (token, timestamp, nonce, signature) => {
+  if (!token || !timestamp || !nonce || !signature) {
+    return false;
+  }
+  const expected = createHash("sha1").update([token, timestamp, nonce].sort().join("")).digest("hex");
+  return expected === signature;
+};
+
+const readText = async (request) => {
+  const chunks = [];
+  for await (const chunk of request) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+};
+
+const parseWeChatXml = (xml) => {
+  const result = {};
+  for (const key of ["ToUserName", "FromUserName", "CreateTime", "MsgType", "Content", "MsgId"]) {
+    const match = new RegExp(`<${key}>(?:<!\\[CDATA\\[([\\s\\S]*?)\\]\\]>|([\\s\\S]*?))<\\/${key}>`).exec(xml);
+    if (match) {
+      result[key] = (match[1] ?? match[2] ?? "").trim();
+    }
+  }
+  return result;
+};
+
+const safeErrorMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
+
+const rejectUnsupportedAttachments = (platform, message) => {
+  if (Array.isArray(message.attachments) && message.attachments.length > 0) {
+    throw new Error(`${platform} attachment sending is not supported yet`);
+  }
+};

package/extensions/builtin/wechat/scorel.extension.json

@@ -0,0 +1,7 @@
+{
+  "id": "wechat",
+  "kind": "im",
+  "displayName": "WeChat",
+  "adapter": "./adapter.js",
+  "skills": ["./skills"]
+}

package/extensions/builtin/wechat/skills/wechat/SKILL.md

@@ -0,0 +1,9 @@
+# WeChat
+
+Use this skill when replying through the WeChat IM channel.
+
+- Treat WeChat replies as human chat, not as a delayed report.
+- Use `SendChannelMessage` for the current conversation; do not expose OpenID, webhook key, or raw platform routing ids.
+- Send a short acknowledgement before long work, then send concise progress or final results.
+- Prefer short paragraphs and concrete next actions.
+- Do not imply personal WeChat account automation; Scorel uses official WeChat or WeCom-style bot surfaces.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chanlerdev/scorel",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Replayable, recoverable, remotely controllable AI Agent workspace.",
   "type": "module",
   "packageManager": "pnpm@11.1.2",