codeksei 0.1.0

package/src/adapters/channel/weixin/message-utils.js

@@ -0,0 +1,199 @@
+const TEXT_ITEM_TYPE = 1;
+const IMAGE_ITEM_TYPE = 2;
+const VOICE_ITEM_TYPE = 3;
+const FILE_ITEM_TYPE = 4;
+const VIDEO_ITEM_TYPE = 5;
+const BOT_MESSAGE_TYPE = 2;
+
+function normalizeWeixinIncomingMessage(message, config, accountId) {
+  if (!message || typeof message !== "object") {
+    return null;
+  }
+  if (Number(message.message_type) === BOT_MESSAGE_TYPE) {
+    return null;
+  }
+
+  const senderId = normalizeText(message.from_user_id);
+  if (!senderId) {
+    return null;
+  }
+
+  const text = extractTextBody(message.item_list);
+  const attachments = extractAttachmentItems(message.item_list);
+  if (!text && !attachments.length) {
+    return null;
+  }
+
+  return {
+    provider: "weixin",
+    accountId,
+    workspaceId: config.workspaceId,
+    senderId,
+    chatId: senderId,
+    messageId: normalizeText(message.message_id),
+    threadKey: normalizeText(message.session_id),
+    text,
+    attachments,
+    contextToken: normalizeText(message.context_token),
+    receivedAt: resolveReceivedAt(message),
+  };
+}
+
+function extractTextBody(itemList) {
+  if (!Array.isArray(itemList) || !itemList.length) {
+    return "";
+  }
+
+  for (const item of itemList) {
+    if (Number(item?.type) === TEXT_ITEM_TYPE && typeof item?.text_item?.text === "string") {
+      return item.text_item.text.trim();
+    }
+    if (Number(item?.type) === VOICE_ITEM_TYPE && typeof item?.voice_item?.text === "string") {
+      return item.voice_item.text.trim();
+    }
+  }
+
+  return "";
+}
+
+function extractAttachmentItems(itemList) {
+  if (!Array.isArray(itemList) || !itemList.length) {
+    return [];
+  }
+
+  const attachments = [];
+  for (let index = 0; index < itemList.length; index += 1) {
+    const normalized = normalizeAttachmentItem(itemList[index], index);
+    if (normalized) {
+      attachments.push(normalized);
+    }
+  }
+
+  return attachments;
+}
+
+function normalizeAttachmentItem(item, index) {
+  const itemType = Number(item?.type);
+  const payload = resolveAttachmentPayload(itemType, item);
+  if (!payload) {
+    return null;
+  }
+
+  const media = payload.media && typeof payload.media === "object"
+    ? payload.media
+    : {};
+
+  return {
+    kind: payload.kind,
+    itemType,
+    index,
+    fileName: normalizeText(
+      payload.body?.file_name
+      || payload.body?.filename
+      || item?.file_name
+      || item?.filename
+    ),
+    sizeBytes: parseOptionalInt(
+      payload.body?.len
+      || payload.body?.file_size
+      || payload.body?.size
+      || payload.body?.video_size
+      || item?.len
+    ),
+    directUrls: collectStringValues([
+      payload.body?.url,
+      payload.body?.download_url,
+      payload.body?.cdn_url,
+      media?.url,
+      media?.download_url,
+      media?.cdn_url,
+    ]),
+    mediaRef: {
+      encryptQueryParam: normalizeText(
+        media?.encrypt_query_param
+        || media?.encrypted_query_param
+        || payload.body?.encrypt_query_param
+        || payload.body?.encrypted_query_param
+        || item?.encrypt_query_param
+        || item?.encrypted_query_param
+      ),
+      aesKey: normalizeText(
+        media?.aes_key
+        || payload.body?.aes_key
+        || item?.aes_key
+      ),
+      aesKeyHex: normalizeText(
+        payload.body?.aeskey
+        || payload.body?.aes_key_hex
+        || item?.aeskey
+      ),
+      encryptType: Number(
+        media?.encrypt_type
+        ?? payload.body?.encrypt_type
+        ?? item?.encrypt_type
+        ?? 1
+      ),
+      fileKey: normalizeText(
+        media?.filekey
+        || payload.body?.filekey
+        || item?.filekey
+      ),
+    },
+    rawItem: item,
+  };
+}
+
+function resolveAttachmentPayload(itemType, item) {
+  if (itemType === IMAGE_ITEM_TYPE && item?.image_item && typeof item.image_item === "object") {
+    return { kind: "image", body: item.image_item, media: item.image_item.media };
+  }
+  if (itemType === FILE_ITEM_TYPE && item?.file_item && typeof item.file_item === "object") {
+    return { kind: "file", body: item.file_item, media: item.file_item.media };
+  }
+  if (itemType === VIDEO_ITEM_TYPE && item?.video_item && typeof item.video_item === "object") {
+    return { kind: "video", body: item.video_item, media: item.video_item.media };
+  }
+  return null;
+}
+
+function collectStringValues(values) {
+  const seen = new Set();
+  const result = [];
+  for (const value of values) {
+    const normalized = normalizeText(value);
+    if (!normalized || seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    result.push(normalized);
+  }
+  return result;
+}
+
+function parseOptionalInt(value) {
+  if (value == null || value === "") {
+    return 0;
+  }
+  const parsed = Number.parseInt(String(value), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+}
+
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function resolveReceivedAt(message) {
+  const rawMs = Number(message?.create_time_ms);
+  if (Number.isFinite(rawMs) && rawMs > 0) {
+    return new Date(rawMs).toISOString();
+  }
+  const rawSeconds = Number(message?.create_time);
+  if (Number.isFinite(rawSeconds) && rawSeconds > 0) {
+    return new Date(rawSeconds * 1000).toISOString();
+  }
+  return new Date().toISOString();
+}
+
+module.exports = {
+  normalizeWeixinIncomingMessage,
+};

package/src/adapters/channel/weixin/protocol.js

@@ -0,0 +1,77 @@
+const crypto = require("crypto");
+
+const DEFAULT_PROTOCOL_CLIENT_VERSION = "2.1.1";
+const BOT_API_USER_AGENT = "node";
+const ILINK_APP_ID = "bot";
+// Keep one stable sender identity per bridge process. Re-randomizing this on
+// every request makes retries look like they came from different clients,
+// which weakens upstream dedupe and can amplify duplicate sends.
+const PROCESS_WECHAT_UIN = createStableWechatUin();
+
+function normalizeRouteTag(routeTag) {
+  return typeof routeTag === "string" ? routeTag.trim() : "";
+}
+
+function normalizeProtocolClientVersion(version) {
+  const normalized = typeof version === "string" ? version.trim() : "";
+  return normalized || DEFAULT_PROTOCOL_CLIENT_VERSION;
+}
+
+function encodeClientVersion(version) {
+  const parts = normalizeProtocolClientVersion(version).split(".");
+  const parse = (index) => {
+    const value = Number.parseInt(parts[index] || "0", 10);
+    return Number.isFinite(value) ? value : 0;
+  };
+  const major = parse(0);
+  const minor = parse(1);
+  const patch = parse(2);
+  const encoded = ((major & 0xff) << 16) | ((minor & 0xff) << 8) | (patch & 0xff);
+  return String(encoded);
+}
+
+function buildCommonHeaders({ routeTag = "", clientVersion = DEFAULT_PROTOCOL_CLIENT_VERSION } = {}) {
+  const headers = {
+    "User-Agent": BOT_API_USER_AGENT,
+    "iLink-App-Id": ILINK_APP_ID,
+    "iLink-App-ClientVersion": encodeClientVersion(clientVersion),
+  };
+  const normalizedRouteTag = normalizeRouteTag(routeTag);
+  if (normalizedRouteTag) {
+    headers.SKRouteTag = normalizedRouteTag;
+  }
+  return headers;
+}
+
+function createStableWechatUin() {
+  const uint32 = crypto.randomBytes(4).readUInt32BE(0);
+  return Buffer.from(String(uint32), "utf8").toString("base64");
+}
+
+function getStableWechatUin() {
+  return PROCESS_WECHAT_UIN;
+}
+
+function buildJsonHeaders({ body, token = "", routeTag = "", clientVersion = DEFAULT_PROTOCOL_CLIENT_VERSION }) {
+  const headers = {
+    "Content-Type": "application/json",
+    AuthorizationType: "ilink_bot_token",
+    "Content-Length": String(Buffer.byteLength(String(body || ""), "utf8")),
+    "X-WECHAT-UIN": getStableWechatUin(),
+    ...buildCommonHeaders({ routeTag, clientVersion }),
+  };
+  const normalizedToken = typeof token === "string" ? token.trim() : "";
+  if (normalizedToken) {
+    headers.Authorization = `Bearer ${normalizedToken}`;
+  }
+  return headers;
+}
+
+module.exports = {
+  DEFAULT_PROTOCOL_CLIENT_VERSION,
+  buildCommonHeaders,
+  buildJsonHeaders,
+  getStableWechatUin,
+  normalizeProtocolClientVersion,
+  normalizeRouteTag,
+};

package/src/adapters/channel/weixin/redact.js

@@ -0,0 +1,41 @@
+const SENSITIVE_FIELD_NAMES = [
+  "context_token",
+  "bot_token",
+  "token",
+  "authorization",
+  "Authorization",
+  "aeskey",
+  "aes_key",
+  "upload_param",
+  "encrypted_query_param",
+];
+
+const JSON_FIELD_PATTERN = new RegExp(
+  `"(${SENSITIVE_FIELD_NAMES.join("|")})"\\s*:\\s*"[^"]*"`,
+  "g"
+);
+
+const QUERY_FIELD_PATTERN = new RegExp(
+  `([?&](?:${SENSITIVE_FIELD_NAMES.join("|")})=)[^&\\s]+`,
+  "g"
+);
+
+const BEARER_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/=-]+/g;
+
+function redactSensitiveText(input, maxLen = 800) {
+  const text = typeof input === "string" ? input : String(input || "");
+  if (!text) {
+    return "";
+  }
+  const redacted = text
+    .replace(JSON_FIELD_PATTERN, '"$1":"<redacted>"')
+    .replace(QUERY_FIELD_PATTERN, "$1<redacted>")
+    .replace(BEARER_PATTERN, "Bearer <redacted>");
+  if (redacted.length <= maxLen) {
+    return redacted;
+  }
+  return `${redacted.slice(0, maxLen)}…(truncated, totalLen=${redacted.length})`;
+}
+
+module.exports = { redactSensitiveText };
+

package/src/adapters/channel/weixin/reminder-queue-store.js

@@ -0,0 +1,101 @@
+const fs = require("fs");
+const path = require("path");
+
+class ReminderQueueStore {
+  constructor({ filePath }) {
+    this.filePath = filePath;
+    this.state = { reminders: [] };
+    this.ensureParentDirectory();
+    this.load();
+  }
+
+  ensureParentDirectory() {
+    fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+  }
+
+  load() {
+    try {
+      const raw = fs.readFileSync(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      const reminders = Array.isArray(parsed?.reminders) ? parsed.reminders : [];
+      this.state = {
+        reminders: reminders
+          .map(normalizeReminder)
+          .filter(Boolean)
+          .sort((left, right) => left.dueAtMs - right.dueAtMs),
+      };
+    } catch {
+      this.state = { reminders: [] };
+    }
+  }
+
+  save() {
+    fs.writeFileSync(this.filePath, JSON.stringify(this.state, null, 2));
+  }
+
+  enqueue(reminder) {
+    this.load();
+    const normalized = normalizeReminder(reminder);
+    if (!normalized) {
+      throw new Error("invalid reminder");
+    }
+    this.state.reminders.push(normalized);
+    this.state.reminders.sort((left, right) => left.dueAtMs - right.dueAtMs);
+    this.save();
+    return normalized;
+  }
+
+  listDue(nowMs = Date.now()) {
+    this.load();
+    const due = [];
+    const pending = [];
+
+    for (const reminder of this.state.reminders) {
+      if (reminder.dueAtMs <= nowMs) {
+        due.push(reminder);
+      } else {
+        pending.push(reminder);
+      }
+    }
+
+    if (due.length) {
+      this.state.reminders = pending;
+      this.save();
+    }
+
+    return due;
+  }
+
+  peekNextDueAtMs() {
+    this.load();
+    const first = this.state.reminders[0];
+    return Number.isFinite(first?.dueAtMs) ? first.dueAtMs : 0;
+  }
+}
+
+function normalizeReminder(reminder) {
+  if (!reminder || typeof reminder !== "object") {
+    return null;
+  }
+  const id = typeof reminder.id === "string" ? reminder.id.trim() : "";
+  const accountId = typeof reminder.accountId === "string" ? reminder.accountId.trim() : "";
+  const senderId = typeof reminder.senderId === "string" ? reminder.senderId.trim() : "";
+  const contextToken = typeof reminder.contextToken === "string" ? reminder.contextToken.trim() : "";
+  const text = typeof reminder.text === "string" ? reminder.text.trim() : "";
+  const dueAtMs = Number(reminder.dueAtMs);
+  const createdAt = typeof reminder.createdAt === "string" ? reminder.createdAt.trim() : "";
+  if (!id || !accountId || !senderId || !contextToken || !text || !Number.isFinite(dueAtMs) || dueAtMs <= 0) {
+    return null;
+  }
+  return {
+    id,
+    accountId,
+    senderId,
+    contextToken,
+    text,
+    dueAtMs,
+    createdAt: createdAt || new Date().toISOString(),
+  };
+}
+
+module.exports = { ReminderQueueStore };

package/src/adapters/channel/weixin/sync-buffer-store.js

@@ -0,0 +1,35 @@
+const fs = require("fs");
+const path = require("path");
+const { normalizeAccountId } = require("./account-store");
+
+function ensureSyncBufferDir(config) {
+  fs.mkdirSync(config.syncBufferDir, { recursive: true });
+}
+
+function resolveSyncBufferPath(config, accountId) {
+  ensureSyncBufferDir(config);
+  return path.join(config.syncBufferDir, `${normalizeAccountId(accountId)}.txt`);
+}
+
+function loadSyncBuffer(config, accountId) {
+  try {
+    const filePath = resolveSyncBufferPath(config, accountId);
+    if (!fs.existsSync(filePath)) {
+      return "";
+    }
+    return fs.readFileSync(filePath, "utf8").trim();
+  } catch {
+    return "";
+  }
+}
+
+function saveSyncBuffer(config, accountId, buffer) {
+  const filePath = resolveSyncBufferPath(config, accountId);
+  fs.writeFileSync(filePath, String(buffer || ""), "utf8");
+}
+
+module.exports = {
+  loadSyncBuffer,
+  resolveSyncBufferPath,
+  saveSyncBuffer,
+};

package/src/adapters/runtime/codex/events.js

@@ -0,0 +1,252 @@
+const {
+  extractAssistantPhase,
+  extractAssistantText,
+  extractFailureText,
+  extractThreadIdFromParams,
+  extractTurnIdFromParams,
+} = require("./message-utils");
+
+function mapCodexMessageToRuntimeEvent(message) {
+  if (message?.type === "event_msg" && message?.payload?.type === "token_count") {
+    return {
+      type: "runtime.usage.updated",
+      payload: normalizeUsagePayload(message.payload),
+    };
+  }
+  const method = normalizeString(message?.method);
+  const params = message?.params || {};
+  const threadId = extractThreadIdFromParams(params);
+  const turnId = extractTurnIdFromParams(params);
+
+  if (!method) {
+    return null;
+  }
+
+  if (method === "turn/started" || method === "turn/start") {
+    return {
+      type: "runtime.turn.started",
+      payload: {
+        threadId,
+        turnId,
+      },
+    };
+  }
+
+  if (method === "turn/completed") {
+    return {
+      type: "runtime.turn.completed",
+      payload: {
+        threadId,
+        turnId,
+      },
+    };
+  }
+
+  if (method === "turn/failed") {
+    return {
+      type: "runtime.turn.failed",
+      payload: {
+        threadId,
+        turnId,
+        text: extractFailureText(params),
+      },
+    };
+  }
+
+  if (method === "item/agentMessage/delta") {
+    const text = extractAssistantText(params);
+    const phase = extractAssistantPhase(params);
+    if (!text) {
+      return null;
+    }
+    return {
+      type: "runtime.reply.delta",
+      payload: {
+        threadId,
+        turnId,
+        itemId: normalizeString(params?.itemId || params?.item?.id),
+        text,
+        phase,
+      },
+    };
+  }
+
+  if (method === "item/completed" && normalizeString(params?.item?.type).toLowerCase() === "agentmessage") {
+    const text = extractAssistantText(params);
+    const phase = extractAssistantPhase(params);
+    return {
+      type: "runtime.reply.completed",
+      payload: {
+        threadId,
+        turnId,
+        itemId: normalizeString(params?.item?.id),
+        text,
+        phase,
+      },
+    };
+  }
+
+  if (isApprovalRequestMethod(method)) {
+    return {
+      type: "runtime.approval.requested",
+      payload: {
+        threadId,
+        requestId: message?.id ?? null,
+        reason: normalizeString(params?.reason),
+        command: extractApprovalDisplayCommand(params),
+        commandTokens: extractApprovalCommandTokens(params),
+      },
+    };
+  }
+
+  return null;
+}
+
+function normalizeUsagePayload(payload) {
+  const info = payload?.info || {};
+  const total = info?.total_token_usage || {};
+  const last = info?.last_token_usage || {};
+  const rateLimits = payload?.rate_limits || {};
+  return {
+    totalInputTokens: numberOrZero(total.input_tokens),
+    totalCachedInputTokens: numberOrZero(total.cached_input_tokens),
+    totalOutputTokens: numberOrZero(total.output_tokens),
+    totalReasoningTokens: numberOrZero(total.reasoning_output_tokens),
+    totalTokens: numberOrZero(total.total_tokens),
+    lastInputTokens: numberOrZero(last.input_tokens),
+    lastCachedInputTokens: numberOrZero(last.cached_input_tokens),
+    lastOutputTokens: numberOrZero(last.output_tokens),
+    lastReasoningTokens: numberOrZero(last.reasoning_output_tokens),
+    lastTotalTokens: numberOrZero(last.total_tokens),
+    modelContextWindow: numberOrZero(info?.model_context_window),
+    primaryUsedPercent: numberOrZero(rateLimits?.primary?.used_percent),
+    secondaryUsedPercent: numberOrZero(rateLimits?.secondary?.used_percent),
+  };
+}
+
+function isApprovalRequestMethod(method) {
+  return typeof method === "string" && method.endsWith("requestApproval");
+}
+
+function extractApprovalDisplayCommand(params) {
+  const commandTokens = extractApprovalCommandTokens(params);
+  const direct = params?.command;
+  if (typeof direct === "string" && direct.trim()) {
+    return direct.trim();
+  }
+  if (Array.isArray(direct)) {
+    const normalized = normalizeCommandTokens(direct);
+    if (normalized.length) {
+      return buildApprovalCommandPreview(normalized);
+    }
+  }
+  return buildApprovalCommandPreview(commandTokens);
+}
+
+function extractApprovalCommandTokens(params) {
+  return normalizeCommandTokens(extractTokens(params));
+}
+
+function extractTokens(value) {
+  if (!value) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value.every((entry) => typeof entry === "string")
+      ? value.map((entry) => entry.trim()).filter(Boolean)
+      : [];
+  }
+  if (typeof value === "string") {
+    return splitCommandLine(value);
+  }
+  if (typeof value !== "object") {
+    return [];
+  }
+
+  for (const key of ["proposedExecpolicyAmendment", "argv", "args", "command", "cmd", "exec", "shellCommand", "script"]) {
+    const tokens = extractTokens(value[key]);
+    if (tokens.length) {
+      return tokens;
+    }
+  }
+
+  for (const [key, nested] of Object.entries(value)) {
+    const normalizedKey = key.toLowerCase();
+    if (normalizedKey.includes("execpolicy") || normalizedKey.includes("exec_policy")) {
+      const tokens = extractTokens(nested);
+      if (tokens.length) {
+        return tokens;
+      }
+    }
+  }
+
+  return [];
+}
+
+function splitCommandLine(input) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  let escaped = false;
+
+  for (const char of String(input || "")) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === "\"" || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+
+  if (current) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+
+function buildApprovalCommandPreview(tokens) {
+  const normalized = normalizeCommandTokens(tokens);
+  if (!normalized.length) {
+    return "";
+  }
+  return normalized.map((token) => (token.includes(" ") ? JSON.stringify(token) : token)).join(" ");
+}
+
+function normalizeCommandTokens(tokens) {
+  return Array.isArray(tokens)
+    ? tokens.map((part) => normalizeString(part)).filter(Boolean)
+    : [];
+}
+
+function normalizeString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function numberOrZero(value) {
+  return Number.isFinite(Number(value)) ? Number(value) : 0;
+}
+
+module.exports = { mapCodexMessageToRuntimeEvent };