@tencent-weixin/openclaw-weixin 1.0.0

package/src/storage/sync-buf.ts

@@ -0,0 +1,81 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { deriveRawAccountId } from "../auth/accounts.js";
+
+import { resolveStateDir } from "./state-dir.js";
+
+function resolveAccountsDir(): string {
+  return path.join(resolveStateDir(), "openclaw-weixin", "accounts");
+}
+
+/**
+ * Path to the persistent get_updates_buf file for an account.
+ * Stored alongside account data: ~/.openclaw/openclaw-weixin/accounts/{accountId}.sync.json
+ */
+export function getSyncBufFilePath(accountId: string): string {
+  return path.join(resolveAccountsDir(), `${accountId}.sync.json`);
+}
+
+/** Legacy single-account syncbuf (pre multi-account): `.openclaw-weixin-sync/default.json`. */
+function getLegacySyncBufDefaultJsonPath(): string {
+  return path.join(
+    resolveStateDir(),
+    "agents",
+    "default",
+    "sessions",
+    ".openclaw-weixin-sync",
+    "default.json",
+  );
+}
+
+export type SyncBufData = {
+  get_updates_buf: string;
+};
+
+function readSyncBufFile(filePath: string): string | undefined {
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(raw) as { get_updates_buf?: string };
+    if (typeof data.get_updates_buf === "string") {
+      return data.get_updates_buf;
+    }
+  } catch {
+    // file not found or invalid
+  }
+  return undefined;
+}
+
+/**
+ * Load persisted get_updates_buf.
+ * Falls back in order:
+ *   1. Primary path (normalized accountId, new installs)
+ *   2. Compat path (raw accountId derived from pattern, old installs)
+ *   3. Legacy single-account path (very old installs without multi-account support)
+ */
+export function loadGetUpdatesBuf(filePath: string): string | undefined {
+  const value = readSyncBufFile(filePath);
+  if (value !== undefined) return value;
+
+  // Compat: if given path uses a normalized accountId (e.g. "b0f5860fdecb-im-bot.sync.json"),
+  // also try the old raw-ID filename (e.g. "b0f5860fdecb@im.bot.sync.json").
+  const accountId = path.basename(filePath, ".sync.json");
+  const rawId = deriveRawAccountId(accountId);
+  if (rawId) {
+    const compatPath = path.join(resolveAccountsDir(), `${rawId}.sync.json`);
+    const compatValue = readSyncBufFile(compatPath);
+    if (compatValue !== undefined) return compatValue;
+  }
+
+  // Legacy fallback: old single-account installs stored syncbuf without accountId.
+  return readSyncBufFile(getLegacySyncBufDefaultJsonPath());
+}
+
+/**
+ * Persist get_updates_buf. Creates parent dir if needed.
+ */
+export function saveGetUpdatesBuf(filePath: string, getUpdatesBuf: string): void {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify({ get_updates_buf: getUpdatesBuf }, null, 0), "utf-8");
+}

package/src/util/logger.ts

@@ -0,0 +1,143 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+/**
+ * Plugin logger — writes JSON lines to the main openclaw log file:
+ *   /tmp/openclaw/openclaw-YYYY-MM-DD.log
+ * Same file and format used by all other channels.
+ */
+
+const MAIN_LOG_DIR = path.join("/tmp", "openclaw");
+const SUBSYSTEM = "gateway/channels/openclaw-weixin";
+const RUNTIME = "node";
+const RUNTIME_VERSION = process.versions.node;
+const HOSTNAME = os.hostname() || "unknown";
+const PARENT_NAMES = ["openclaw"];
+
+/** tslog-compatible level IDs (higher = more severe). */
+const LEVEL_IDS: Record<string, number> = {
+  TRACE: 1,
+  DEBUG: 2,
+  INFO: 3,
+  WARN: 4,
+  ERROR: 5,
+  FATAL: 6,
+};
+
+const DEFAULT_LOG_LEVEL = "INFO";
+
+function resolveMinLevel(): number {
+  const env = process.env.OPENCLAW_LOG_LEVEL?.toUpperCase();
+  if (env && env in LEVEL_IDS) return LEVEL_IDS[env];
+  return LEVEL_IDS[DEFAULT_LOG_LEVEL];
+}
+
+let minLevelId = resolveMinLevel();
+
+/** Dynamically change the minimum log level at runtime. */
+export function setLogLevel(level: string): void {
+  const upper = level.toUpperCase();
+  if (!(upper in LEVEL_IDS)) {
+    throw new Error(`Invalid log level: ${level}. Valid levels: ${Object.keys(LEVEL_IDS).join(", ")}`);
+  }
+  minLevelId = LEVEL_IDS[upper];
+}
+
+/** Shift a Date into local time so toISOString() renders local clock digits. */
+function toLocalISO(now: Date): string {
+  const offsetMs = -now.getTimezoneOffset() * 60_000;
+  const sign = offsetMs >= 0 ? "+" : "-";
+  const abs = Math.abs(now.getTimezoneOffset());
+  const offStr = `${sign}${String(Math.floor(abs / 60)).padStart(2, "0")}:${String(abs % 60).padStart(2, "0")}`;
+  return new Date(now.getTime() + offsetMs).toISOString().replace("Z", offStr);
+}
+
+function localDateKey(now: Date): string {
+  return toLocalISO(now).slice(0, 10);
+}
+
+function resolveMainLogPath(): string {
+  const dateKey = localDateKey(new Date());
+  return path.join(MAIN_LOG_DIR, `openclaw-${dateKey}.log`);
+}
+
+let logDirEnsured = false;
+
+export type Logger = {
+  info(message: string): void;
+  debug(message: string): void;
+  warn(message: string): void;
+  error(message: string): void;
+  /** Returns a child logger whose messages are prefixed with `[accountId]`. */
+  withAccount(accountId: string): Logger;
+  /** Returns the current main log file path. */
+  getLogFilePath(): string;
+  close(): void;
+};
+
+function buildLoggerName(accountId?: string): string {
+  return accountId ? `${SUBSYSTEM}/${accountId}` : SUBSYSTEM;
+}
+
+function writeLog(level: string, message: string, accountId?: string): void {
+  const levelId = LEVEL_IDS[level] ?? LEVEL_IDS.INFO;
+  if (levelId < minLevelId) return;
+
+  const now = new Date();
+  const loggerName = buildLoggerName(accountId);
+  const prefixedMessage = accountId ? `[${accountId}] ${message}` : message;
+  const entry = JSON.stringify({
+    "0": loggerName,
+    "1": prefixedMessage,
+    _meta: {
+      runtime: RUNTIME,
+      runtimeVersion: RUNTIME_VERSION,
+      hostname: HOSTNAME,
+      name: loggerName,
+      parentNames: PARENT_NAMES,
+      date: now.toISOString(),
+      logLevelId: LEVEL_IDS[level] ?? LEVEL_IDS.INFO,
+      logLevelName: level,
+    },
+    time: toLocalISO(now),
+  });
+  try {
+    if (!logDirEnsured) {
+      fs.mkdirSync(MAIN_LOG_DIR, { recursive: true });
+      logDirEnsured = true;
+    }
+    fs.appendFileSync(resolveMainLogPath(), `${entry}\n`, "utf-8");
+  } catch {
+    // Best-effort; never block on logging failures.
+  }
+}
+
+/** Creates a logger instance, optionally bound to a specific account. */
+function createLogger(accountId?: string): Logger {
+  return {
+    info(message: string): void {
+      writeLog("INFO", message, accountId);
+    },
+    debug(message: string): void {
+      writeLog("DEBUG", message, accountId);
+    },
+    warn(message: string): void {
+      writeLog("WARN", message, accountId);
+    },
+    error(message: string): void {
+      writeLog("ERROR", message, accountId);
+    },
+    withAccount(id: string): Logger {
+      return createLogger(id);
+    },
+    getLogFilePath(): string {
+      return resolveMainLogPath();
+    },
+    close(): void {
+      // No-op: appendFileSync has no persistent handle to close.
+    },
+  };
+}
+
+export const logger: Logger = createLogger();

package/src/util/random.ts

@@ -0,0 +1,17 @@
+import crypto from "node:crypto";
+
+/**
+ * Generate a prefixed unique ID using timestamp + crypto random bytes.
+ * Format: `{prefix}:{timestamp}-{8-char hex}`
+ */
+export function generateId(prefix: string): string {
+  return `${prefix}:${Date.now()}-${crypto.randomBytes(4).toString("hex")}`;
+}
+
+/**
+ * Generate a temporary file name with random suffix.
+ * Format: `{prefix}-{timestamp}-{8-char hex}{ext}`
+ */
+export function tempFileName(prefix: string, ext: string): string {
+  return `${prefix}-${Date.now()}-${crypto.randomBytes(4).toString("hex")}${ext}`;
+}

package/src/util/redact.ts

@@ -0,0 +1,46 @@
+const DEFAULT_BODY_MAX_LEN = 200;
+const DEFAULT_TOKEN_PREFIX_LEN = 6;
+
+/**
+ * Truncate a string, appending a length indicator when trimmed.
+ * Returns `""` for empty/undefined input.
+ */
+export function truncate(s: string | undefined, max: number): string {
+  if (!s) return "";
+  if (s.length <= max) return s;
+  return `${s.slice(0, max)}…(len=${s.length})`;
+}
+
+/**
+ * Redact a token/secret: show only the first few chars + total length.
+ * Returns `"(none)"` when absent.
+ */
+export function redactToken(token: string | undefined, prefixLen = DEFAULT_TOKEN_PREFIX_LEN): string {
+  if (!token) return "(none)";
+  if (token.length <= prefixLen) return `****(len=${token.length})`;
+  return `${token.slice(0, prefixLen)}…(len=${token.length})`;
+}
+
+/**
+ * Truncate a JSON body string to `maxLen` chars for safe logging.
+ * Appends original length so the reader knows how much was dropped.
+ */
+export function redactBody(body: string | undefined, maxLen = DEFAULT_BODY_MAX_LEN): string {
+  if (!body) return "(empty)";
+  if (body.length <= maxLen) return body;
+  return `${body.slice(0, maxLen)}…(truncated, totalLen=${body.length})`;
+}
+
+/**
+ * Strip query string (which often contains signatures/tokens) from a URL,
+ * keeping only origin + pathname.
+ */
+export function redactUrl(rawUrl: string): string {
+  try {
+    const u = new URL(rawUrl);
+    const base = `${u.origin}${u.pathname}`;
+    return u.search ? `${base}?<redacted>` : base;
+  } catch {
+    return truncate(rawUrl, 80);
+  }
+}

package/src/vendor.d.ts

@@ -0,0 +1,25 @@
+declare module "qrcode-terminal" {
+  const qrcodeTerminal: {
+    generate(
+      text: string,
+      options?: { small?: boolean },
+      callback?: (qr: string) => void,
+    ): void;
+  };
+  export default qrcodeTerminal;
+}
+
+declare module "fluent-ffmpeg" {
+  interface FfmpegCommand {
+    setFfmpegPath(path: string): FfmpegCommand;
+    seekInput(time: number): FfmpegCommand;
+    frames(n: number): FfmpegCommand;
+    outputOptions(opts: string[]): FfmpegCommand;
+    output(path: string): FfmpegCommand;
+    on(event: "end", cb: () => void): FfmpegCommand;
+    on(event: "error", cb: (err: Error) => void): FfmpegCommand;
+    run(): void;
+  }
+  function ffmpeg(input: string): FfmpegCommand;
+  export default ffmpeg;
+}