codeksei 0.1.0

package/scripts/show_shared_status.sh

@@ -0,0 +1,53 @@
+#!/bin/zsh
+set -euo pipefail
+
+PORT="${CODEKSEI_SHARED_PORT:-${CYBERBOSS_SHARED_PORT:-8765}}"
+LISTEN_URL="ws://127.0.0.1:${PORT}"
+STATE_DIR="${CODEKSEI_STATE_DIR:-${CYBERBOSS_STATE_DIR:-$HOME/.codeksei}}"
+if [[ ! -d "${STATE_DIR}" && -d "$HOME/.cyberboss" ]]; then
+  STATE_DIR="$HOME/.cyberboss"
+fi
+LOG_DIR="${STATE_DIR}/logs"
+APP_SERVER_PID_FILE="${LOG_DIR}/shared-app-server.pid"
+WECHAT_PID_FILE="${LOG_DIR}/shared-wechat.pid"
+WECHAT_LOG_FILE="${LOG_DIR}/shared-wechat.log"
+
+function print_pid_state() {
+  local label="$1"
+  local pid_file="$2"
+
+  if [[ -f "${pid_file}" ]]; then
+    local pid
+    pid="$(cat "${pid_file}" 2>/dev/null || true)"
+    if [[ -n "${pid}" ]] && kill -0 "${pid}" 2>/dev/null; then
+      echo "${label}=${pid}"
+      return
+    fi
+    echo "${label}=stale"
+    return
+  fi
+
+  echo "${label}=missing"
+}
+
+echo "listen=${LISTEN_URL}"
+print_pid_state "shared_app_server_pid" "${APP_SERVER_PID_FILE}"
+print_pid_state "shared_codeksei_pid" "${WECHAT_PID_FILE}"
+print_pid_state "shared_cyberboss_pid" "${WECHAT_PID_FILE}"
+
+if command -v curl >/dev/null 2>&1; then
+  if curl -sf "http://127.0.0.1:${PORT}/readyz" >/dev/null; then
+    echo "readyz=ok"
+  else
+    echo "readyz=down"
+  fi
+fi
+
+if command -v lsof >/dev/null 2>&1; then
+  lsof -nP -iTCP:"${PORT}" -sTCP:LISTEN || true
+fi
+
+if [[ -f "${WECHAT_LOG_FILE}" ]]; then
+  echo "--- ${WECHAT_LOG_FILE} (tail) ---"
+  tail -n 20 "${WECHAT_LOG_FILE}" || true
+fi

package/scripts/start_shared_app_server.sh

@@ -0,0 +1,65 @@
+#!/bin/zsh
+set -euo pipefail
+
+PORT="${CODEKSEI_SHARED_PORT:-${CYBERBOSS_SHARED_PORT:-8765}}"
+LISTEN_URL="ws://127.0.0.1:${PORT}"
+STATE_DIR="${CODEKSEI_STATE_DIR:-${CYBERBOSS_STATE_DIR:-$HOME/.codeksei}}"
+if [[ ! -d "${STATE_DIR}" && -d "$HOME/.cyberboss" ]]; then
+  STATE_DIR="$HOME/.cyberboss"
+fi
+LOG_DIR="${STATE_DIR}/logs"
+PID_FILE="${LOG_DIR}/shared-app-server.pid"
+LOG_FILE="${LOG_DIR}/shared-app-server.log"
+
+function lookup_listen_pid() {
+  lsof -nP -iTCP:"${PORT}" -sTCP:LISTEN 2>/dev/null \
+    | awk 'NR > 1 { print $2; found=1; exit } END { if (!found) exit 0 }'
+}
+
+mkdir -p "${LOG_DIR}"
+export CODEKSEI_STATE_DIR="${STATE_DIR}"
+export CYBERBOSS_STATE_DIR="${STATE_DIR}"
+export TIMELINE_FOR_AGENT_STATE_DIR="${STATE_DIR}"
+if [[ -z "${TIMELINE_FOR_AGENT_CHROME_PATH:-}" ]]; then
+  export TIMELINE_FOR_AGENT_CHROME_PATH="${CODEKSEI_SCREENSHOT_CHROME_PATH:-${CYBERBOSS_SCREENSHOT_CHROME_PATH:-/Applications/Google Chrome.app/Contents/MacOS/Google Chrome}}"
+fi
+
+if [[ -f "${PID_FILE}" ]]; then
+  EXISTING_PID="$(cat "${PID_FILE}")"
+  if [[ -n "${EXISTING_PID}" ]] && kill -0 "${EXISTING_PID}" 2>/dev/null; then
+    echo "shared app-server already running pid=${EXISTING_PID} listen=${LISTEN_URL}"
+    exit 0
+  fi
+  rm -f "${PID_FILE}"
+fi
+
+EXISTING_PID="$(lookup_listen_pid || true)"
+if [[ -n "${EXISTING_PID}" ]]; then
+  echo "${EXISTING_PID}" > "${PID_FILE}"
+  echo "shared app-server already running pid=${EXISTING_PID} listen=${LISTEN_URL}"
+  exit 0
+fi
+
+nohup codex app-server --listen "${LISTEN_URL}" >> "${LOG_FILE}" 2>&1 &
+APP_SERVER_PID=$!
+echo "${APP_SERVER_PID}" > "${PID_FILE}"
+sleep 1
+
+LISTEN_PID="$(lookup_listen_pid || true)"
+if kill -0 "${APP_SERVER_PID}" 2>/dev/null && [[ -n "${LISTEN_PID}" ]]; then
+  echo "${LISTEN_PID}" > "${PID_FILE}"
+  echo "started shared app-server pid=${LISTEN_PID} listen=${LISTEN_URL}"
+  echo "log=${LOG_FILE}"
+  exit 0
+fi
+
+EXISTING_PID="$(lookup_listen_pid || true)"
+if [[ -n "${EXISTING_PID}" ]]; then
+  echo "${EXISTING_PID}" > "${PID_FILE}"
+  echo "shared app-server already running pid=${EXISTING_PID} listen=${LISTEN_URL}"
+  exit 0
+fi
+
+echo "failed to start shared app-server; check ${LOG_FILE}" >&2
+tail -n 20 "${LOG_FILE}" >&2 || true
+exit 1

package/scripts/start_shared_wechat.sh

@@ -0,0 +1,108 @@
+#!/bin/zsh
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+PORT="${CODEKSEI_SHARED_PORT:-${CYBERBOSS_SHARED_PORT:-8765}}"
+STATE_DIR="${CODEKSEI_STATE_DIR:-${CYBERBOSS_STATE_DIR:-$HOME/.codeksei}}"
+if [[ ! -d "${STATE_DIR}" && -d "$HOME/.cyberboss" ]]; then
+  STATE_DIR="$HOME/.cyberboss"
+fi
+LOG_DIR="${STATE_DIR}/logs"
+PID_FILE="${LOG_DIR}/shared-wechat.pid"
+
+function resolve_pid_cwd() {
+  local pid="$1"
+  lsof -a -p "${pid}" -d cwd -Fn 2>/dev/null | sed -n 's/^n//p' | head -n 1
+}
+
+function list_bridge_processes() {
+  ps -ax -o pid=,ppid=,command= | awk '/node \.\/bin\/(codeksei|cyberboss)\.js start --checkin/ { print }'
+}
+
+function find_bridge_child_pid() {
+  local parent_pid="$1"
+  list_bridge_processes | awk -v target_ppid="${parent_pid}" '$2 == target_ppid { print $1; exit }'
+}
+
+function resolve_bridge_pid() {
+  local candidate_pid="$1"
+  [[ -n "${candidate_pid}" ]] || return 1
+  if ! kill -0 "${candidate_pid}" 2>/dev/null; then
+    return 1
+  fi
+
+  local child_pid
+  child_pid="$(find_bridge_child_pid "${candidate_pid}")"
+  if [[ -n "${child_pid}" ]]; then
+    echo "${child_pid}"
+    return 0
+  fi
+
+  if [[ "$(resolve_pid_cwd "${candidate_pid}")" == "${ROOT_DIR}" ]]; then
+    echo "${candidate_pid}"
+    return 0
+  fi
+
+  return 1
+}
+
+function find_existing_bridge_pid() {
+  if [[ -f "${PID_FILE}" ]]; then
+    local pid_from_file
+    pid_from_file="$(cat "${PID_FILE}" 2>/dev/null || true)"
+    local resolved_from_file
+    resolved_from_file="$(resolve_bridge_pid "${pid_from_file}" || true)"
+    if [[ -n "${resolved_from_file}" ]]; then
+      echo "${resolved_from_file}"
+      return 0
+    fi
+  fi
+
+  local pid
+  while read -r pid _; do
+    [[ -n "${pid}" ]] || continue
+    if [[ "$(resolve_pid_cwd "${pid}")" == "${ROOT_DIR}" ]]; then
+      echo "${pid}"
+      return 0
+    fi
+  done < <(list_bridge_processes)
+
+  return 1
+}
+
+function cleanup_pid_file() {
+  if [[ -f "${PID_FILE}" ]]; then
+    local current_pid
+    current_pid="$(cat "${PID_FILE}" 2>/dev/null || true)"
+    if [[ "${current_pid}" == "$$" ]]; then
+      rm -f "${PID_FILE}"
+    fi
+  fi
+}
+
+"${ROOT_DIR}/scripts/start_shared_app_server.sh"
+mkdir -p "${LOG_DIR}"
+
+EXISTING_PID="$(find_existing_bridge_pid || true)"
+if [[ -n "${EXISTING_PID}" ]]; then
+  echo "${EXISTING_PID}" > "${PID_FILE}"
+  echo "shared codeksei already running pid=${EXISTING_PID}"
+  exit 0
+fi
+
+BRIDGE_PID=""
+function shutdown_bridge() {
+  if [[ -n "${BRIDGE_PID}" ]] && kill -0 "${BRIDGE_PID}" 2>/dev/null; then
+    kill "${BRIDGE_PID}" 2>/dev/null || true
+  fi
+  cleanup_pid_file
+}
+
+trap shutdown_bridge EXIT INT TERM
+cd "${ROOT_DIR}"
+export CODEKSEI_CODEX_ENDPOINT="ws://127.0.0.1:${PORT}"
+export CYBERBOSS_CODEX_ENDPOINT="ws://127.0.0.1:${PORT}"
+node ./bin/codeksei.js start --checkin &
+BRIDGE_PID="$!"
+echo "${BRIDGE_PID}" > "${PID_FILE}"
+wait "${BRIDGE_PID}"

package/scripts/timeline-screenshot.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+ARGS=()
+
+for arg in "$@"; do
+  if [[ "$arg" == "--send" ]]; then
+    continue
+  fi
+  ARGS+=("$arg")
+done
+
+cd "$ROOT"
+exec node ./bin/codeksei.js timeline screenshot "${ARGS[@]}"

package/scripts/uninstall-background-tasks.ps1

@@ -0,0 +1,23 @@
+param()
+
+$ErrorActionPreference = "Stop"
+
+$taskNames = @(
+  "Codeksei Shared Start",
+  "Codeksei Shared Unlock",
+  "Codeksei Shared Resume",
+  "Codeksei Shared Watchdog",
+  "Cyberboss Shared Start",
+  "Cyberboss Shared Unlock",
+  "Cyberboss Shared Resume",
+  "Cyberboss Shared Watchdog"
+)
+
+foreach ($taskName in $taskNames) {
+  try {
+    Unregister-ScheduledTask -TaskName $taskName -Confirm:$false -ErrorAction Stop
+    Write-Host "removed=$taskName"
+  } catch {
+    Write-Host "missing=$taskName"
+  }
+}

package/src/adapters/channel/weixin/account-store.js

@@ -0,0 +1,135 @@
+const fs = require("fs");
+const path = require("path");
+const { normalizeRouteTag } = require("./protocol");
+
+function normalizeAccountId(raw) {
+  return String(raw || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+function ensureAccountsDir(config) {
+  fs.mkdirSync(config.accountsDir, { recursive: true });
+}
+
+function resolveAccountPath(config, accountId) {
+  return path.join(config.accountsDir, `${normalizeAccountId(accountId)}.json`);
+}
+
+function deleteWeixinAccount(config, accountId) {
+  const normalized = normalizeAccountId(accountId);
+  if (!normalized) {
+    return false;
+  }
+  try {
+    const filePath = resolveAccountPath(config, normalized);
+    if (!fs.existsSync(filePath)) {
+      return false;
+    }
+    fs.unlinkSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function saveWeixinAccount(config, rawAccountId, update) {
+  ensureAccountsDir(config);
+  const accountId = normalizeAccountId(rawAccountId);
+  const filePath = resolveAccountPath(config, accountId);
+  const existing = loadWeixinAccount(config, accountId) || {};
+  const hasRouteTag = Object.prototype.hasOwnProperty.call(update || {}, "routeTag");
+  const next = {
+    accountId,
+    rawAccountId: String(rawAccountId || "").trim() || existing.rawAccountId || "",
+    token: typeof update.token === "string" && update.token.trim() ? update.token.trim() : existing.token || "",
+    baseUrl: typeof update.baseUrl === "string" && update.baseUrl.trim() ? update.baseUrl.trim() : existing.baseUrl || config.weixinBaseUrl,
+    userId: typeof update.userId === "string" ? update.userId.trim() : existing.userId || "",
+    routeTag: hasRouteTag
+      ? normalizeRouteTag(update.routeTag)
+      : normalizeRouteTag(existing.routeTag || config.weixinRouteTag),
+    savedAt: new Date().toISOString(),
+  };
+  fs.writeFileSync(filePath, JSON.stringify(next, null, 2), "utf8");
+  try {
+    fs.chmodSync(filePath, 0o600);
+  } catch {
+    // best effort
+  }
+  return next;
+}
+
+function loadWeixinAccount(config, accountId) {
+  const normalized = normalizeAccountId(accountId);
+  if (!normalized) {
+    return null;
+  }
+  try {
+    const raw = fs.readFileSync(resolveAccountPath(config, normalized), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") {
+      return null;
+    }
+    return {
+      accountId: normalized,
+      rawAccountId: typeof parsed.rawAccountId === "string" ? parsed.rawAccountId : "",
+      token: typeof parsed.token === "string" ? parsed.token : "",
+      baseUrl: typeof parsed.baseUrl === "string" && parsed.baseUrl.trim() ? parsed.baseUrl.trim() : config.weixinBaseUrl,
+      userId: typeof parsed.userId === "string" ? parsed.userId : "",
+      routeTag: Object.prototype.hasOwnProperty.call(parsed, "routeTag")
+        ? normalizeRouteTag(parsed.routeTag)
+        : normalizeRouteTag(config.weixinRouteTag),
+      savedAt: typeof parsed.savedAt === "string" ? parsed.savedAt : "",
+    };
+  } catch {
+    return null;
+  }
+}
+
+function listWeixinAccounts(config) {
+  ensureAccountsDir(config);
+  const files = fs.readdirSync(config.accountsDir, { withFileTypes: true });
+  return files
+    .filter((entry) => entry.isFile() && entry.name.endsWith(".json") && !entry.name.endsWith(".context-tokens.json"))
+    .map((entry) => loadWeixinAccount(config, entry.name.slice(0, -5)))
+    .filter(Boolean)
+    .sort((left, right) => String(right.savedAt || "").localeCompare(String(left.savedAt || "")));
+}
+
+function resolveSelectedAccount(config) {
+  if (config.accountId) {
+    const account = loadWeixinAccount(config, config.accountId);
+    if (!account) {
+      throw new Error(`未找到微信账号: ${config.accountId}`);
+    }
+    if (!account.token) {
+      throw new Error(`微信账号缺少 token: ${account.accountId}，请重新执行 login`);
+    }
+    return account;
+  }
+  const accounts = listWeixinAccounts(config);
+  if (!accounts.length) {
+    throw new Error("当前没有已保存的微信账号，请先执行 `npm run login`");
+  }
+  if (accounts.length > 1) {
+    const accountIds = accounts.map((account) => account.accountId).join(", ");
+    throw new Error(`检测到多个微信账号，请设置 CODEKSEI_ACCOUNT_ID（或旧的 CYBERBOSS_ACCOUNT_ID）。可选值: ${accountIds}`);
+  }
+  if (!accounts[0].token) {
+    throw new Error(`微信账号缺少 token: ${accounts[0].accountId}，请重新执行 login`);
+  }
+  return accounts[0];
+}
+
+module.exports = {
+  deleteWeixinAccount,
+  listWeixinAccounts,
+  loadWeixinAccount,
+  normalizeAccountId,
+  resolveAccountPath,
+  resolveSelectedAccount,
+  saveWeixinAccount,
+};

package/src/adapters/channel/weixin/api-v2.js

@@ -0,0 +1,258 @@
+const crypto = require("crypto");
+const { buildJsonHeaders } = require("./protocol");
+const { PRIMARY_CHANNEL_VERSION } = require("../../../core/branding");
+
+const DEFAULT_LONG_POLL_TIMEOUT_MS = 35_000;
+const DEFAULT_API_TIMEOUT_MS = 15_000;
+const DEFAULT_CONFIG_TIMEOUT_MS = 10_000;
+const MAX_RESPONSE_BODY_BYTES = 64 << 20;
+const CHANNEL_VERSION = PRIMARY_CHANNEL_VERSION;
+
+function buildBaseInfo() {
+  return { channel_version: CHANNEL_VERSION };
+}
+
+function ensureTrailingSlash(url) {
+  return url.endsWith("/") ? url : `${url}/`;
+}
+
+async function apiPost({
+  baseUrl,
+  endpoint,
+  token,
+  body,
+  timeoutMs = 0,
+  label,
+  routeTag = "",
+  clientVersion = "",
+}) {
+  const url = new URL(endpoint, ensureTrailingSlash(baseUrl)).toString();
+  const controller = new AbortController();
+  const timeout = timeoutMs > 0 ? timeoutMs : DEFAULT_API_TIMEOUT_MS;
+  const timer = setTimeout(() => controller.abort(), timeout + 5_000);
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: buildJsonHeaders({ body, token, routeTag, clientVersion }),
+      body,
+      signal: controller.signal,
+    });
+    const raw = await response.text();
+    if (Buffer.byteLength(raw, "utf8") > MAX_RESPONSE_BODY_BYTES) {
+      throw new Error(`${label} response body exceeds ${MAX_RESPONSE_BODY_BYTES} bytes`);
+    }
+    if (!response.ok) {
+      throw new Error(`${label} http ${response.status}: ${truncateForLog(raw, 512)}`);
+    }
+    return raw;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function parseJson(raw, label) {
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`${label} returned invalid JSON: ${truncateForLog(raw, 256)}`);
+  }
+}
+
+function assertApiSuccess(parsed, label) {
+  const ret = parsed?.ret;
+  const errcode = parsed?.errcode;
+  if ((ret !== undefined && ret !== 0) || (errcode !== undefined && errcode !== 0)) {
+    throw new Error(`${label} ret=${ret ?? ""} errcode=${errcode ?? ""} errmsg=${parsed?.errmsg ?? ""}`);
+  }
+  return parsed;
+}
+
+function truncateForLog(value, max) {
+  const text = typeof value === "string" ? value : String(value || "");
+  return text.length <= max ? text : `${text.slice(0, max)}…`;
+}
+
+async function getUpdatesV2({
+  baseUrl,
+  token,
+  getUpdatesBuf = "",
+  timeoutMs = DEFAULT_LONG_POLL_TIMEOUT_MS,
+  routeTag = "",
+  clientVersion = "",
+}) {
+  const payload = JSON.stringify({
+    get_updates_buf: getUpdatesBuf,
+    base_info: buildBaseInfo(),
+  });
+  try {
+    const raw = await apiPost({
+      baseUrl,
+      endpoint: "ilink/bot/getupdates",
+      token,
+      body: payload,
+      timeoutMs,
+      label: "getUpdates",
+      routeTag,
+      clientVersion,
+    });
+    return parseJson(raw, "getUpdates");
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return { ret: 0, msgs: [], get_updates_buf: getUpdatesBuf };
+    }
+    if (String(error?.message || "").includes("aborted")) {
+      return { ret: 0, msgs: [], get_updates_buf: getUpdatesBuf };
+    }
+    throw error;
+  }
+}
+
+async function sendTextV2({
+  baseUrl,
+  token,
+  toUserId,
+  text,
+  contextToken,
+  clientId,
+  routeTag = "",
+  clientVersion = "",
+}) {
+  if (!String(contextToken || "").trim()) {
+    throw new Error("weixin-v2 sendText requires contextToken");
+  }
+  const itemList = [];
+  if (String(text || "").trim()) {
+    itemList.push({
+      type: 1,
+      text_item: { text: String(text) },
+    });
+  }
+  if (!itemList.length) {
+    throw new Error("weixin-v2 sendText requires non-empty text");
+  }
+  return sendMessageV2({
+    baseUrl,
+    token,
+    body: {
+      msg: {
+        from_user_id: "",
+        to_user_id: toUserId,
+        client_id: clientId || `cb-${crypto.randomUUID()}`,
+        message_type: 2,
+        message_state: 2,
+        item_list: itemList,
+        context_token: contextToken,
+      },
+    },
+    routeTag,
+    clientVersion,
+  });
+}
+
+async function sendMessageV2({
+  baseUrl,
+  token,
+  body,
+  routeTag = "",
+  clientVersion = "",
+  timeoutMs = DEFAULT_API_TIMEOUT_MS,
+}) {
+  const raw = await apiPost({
+    baseUrl,
+    endpoint: "ilink/bot/sendmessage",
+    token,
+    body: JSON.stringify({
+      ...body,
+      base_info: buildBaseInfo(),
+    }),
+    timeoutMs,
+    label: "sendMessage",
+    routeTag,
+    clientVersion,
+  });
+  return assertApiSuccess(parseJson(raw, "sendMessage"), "sendMessage");
+}
+
+async function getConfigV2({
+  baseUrl,
+  token,
+  ilinkUserId,
+  contextToken,
+  routeTag = "",
+  clientVersion = "",
+  timeoutMs = DEFAULT_CONFIG_TIMEOUT_MS,
+}) {
+  const raw = await apiPost({
+    baseUrl,
+    endpoint: "ilink/bot/getconfig",
+    token,
+    body: JSON.stringify({
+      ilink_user_id: ilinkUserId,
+      context_token: contextToken,
+      base_info: buildBaseInfo(),
+    }),
+    timeoutMs,
+    label: "getConfig",
+    routeTag,
+    clientVersion,
+  });
+  return assertApiSuccess(parseJson(raw, "getConfig"), "getConfig");
+}
+
+async function sendTypingV2({
+  baseUrl,
+  token,
+  body,
+  routeTag = "",
+  clientVersion = "",
+  timeoutMs = DEFAULT_CONFIG_TIMEOUT_MS,
+}) {
+  const raw = await apiPost({
+    baseUrl,
+    endpoint: "ilink/bot/sendtyping",
+    token,
+    body: JSON.stringify({
+      ...body,
+      base_info: buildBaseInfo(),
+    }),
+    timeoutMs,
+    label: "sendTyping",
+    routeTag,
+    clientVersion,
+  });
+  return assertApiSuccess(parseJson(raw, "sendTyping"), "sendTyping");
+}
+
+async function getUploadUrlV2({
+  baseUrl,
+  token,
+  routeTag = "",
+  clientVersion = "",
+  timeoutMs = DEFAULT_API_TIMEOUT_MS,
+  ...payload
+}) {
+  const raw = await apiPost({
+    baseUrl,
+    endpoint: "ilink/bot/getuploadurl",
+    token,
+    body: JSON.stringify({
+      ...payload,
+      base_info: buildBaseInfo(),
+    }),
+    timeoutMs,
+    label: "getUploadUrl",
+    routeTag,
+    clientVersion,
+  });
+  return assertApiSuccess(parseJson(raw, "getUploadUrl"), "getUploadUrl");
+}
+
+module.exports = {
+  getConfigV2,
+  getUpdatesV2,
+  getUploadUrlV2,
+  sendMessageV2,
+  sendTypingV2,
+  sendTextV2,
+};