@zhin.js/adapter-weixin-ilink 0.1.0

package/src/cdn-upload.ts

@@ -0,0 +1,87 @@
+import { encryptAesEcb } from "./aes-ecb.js";
+import { buildCdnUploadUrl } from "./cdn-url.js";
+import { logger } from "./ilink-logger.js";
+import { redactUrl } from "./ilink-redact.js";
+
+/** Maximum retry attempts for CDN upload. */
+const UPLOAD_MAX_RETRIES = 3;
+
+/**
+ * Upload one buffer to the Weixin CDN with AES-128-ECB encryption.
+ * Returns the download encrypted_query_param from the CDN response.
+ * Retries up to UPLOAD_MAX_RETRIES times on server errors; client errors (4xx) abort immediately.
+ */
+export async function uploadBufferToCdn(params: {
+  buf: Buffer;
+  /** From getUploadUrl.upload_full_url; POST target when set (takes precedence over uploadParam). */
+  uploadFullUrl?: string;
+  uploadParam?: string;
+  filekey: string;
+  cdnBaseUrl: string;
+  label: string;
+  aeskey: Buffer;
+}): Promise<{ downloadParam: string }> {
+  const { buf, uploadFullUrl, uploadParam, filekey, cdnBaseUrl, label, aeskey } = params;
+  const ciphertext = encryptAesEcb(buf, aeskey);
+  const trimmedFull = uploadFullUrl?.trim();
+  let cdnUrl: string;
+  if (trimmedFull) {
+    cdnUrl = trimmedFull;
+  } else if (uploadParam) {
+    cdnUrl = buildCdnUploadUrl({ cdnBaseUrl, uploadParam, filekey });
+  } else {
+    throw new Error(`${label}: CDN upload URL missing (need upload_full_url or upload_param)`);
+  }
+  logger.debug(`${label}: CDN POST url=${redactUrl(cdnUrl)} ciphertextSize=${ciphertext.length}`);
+
+  let downloadParam: string | undefined;
+  let lastError: unknown;
+
+  for (let attempt = 1; attempt <= UPLOAD_MAX_RETRIES; attempt++) {
+    try {
+      const res = await fetch(cdnUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/octet-stream" },
+        body: new Uint8Array(ciphertext),
+      });
+      if (res.status >= 400 && res.status < 500) {
+        const errMsg = res.headers.get("x-error-message") ?? (await res.text());
+        logger.error(
+          `${label}: CDN client error attempt=${attempt} status=${res.status} errMsg=${errMsg}`,
+        );
+        throw new Error(`CDN upload client error ${res.status}: ${errMsg}`);
+      }
+      if (res.status !== 200) {
+        const errMsg = res.headers.get("x-error-message") ?? `status ${res.status}`;
+        logger.error(
+          `${label}: CDN server error attempt=${attempt} status=${res.status} errMsg=${errMsg}`,
+        );
+        throw new Error(`CDN upload server error: ${errMsg}`);
+      }
+      downloadParam = res.headers.get("x-encrypted-param") ?? undefined;
+      if (!downloadParam) {
+        logger.error(
+          `${label}: CDN response missing x-encrypted-param header attempt=${attempt}`,
+        );
+        throw new Error("CDN upload response missing x-encrypted-param header");
+      }
+      logger.debug(`${label}: CDN upload success attempt=${attempt}`);
+      break;
+    } catch (err) {
+      lastError = err;
+      if (err instanceof Error && err.message.includes("client error")) throw err;
+      if (attempt < UPLOAD_MAX_RETRIES) {
+        logger.error(`${label}: attempt ${attempt} failed, retrying... err=${String(err)}`);
+      } else {
+        logger.error(`${label}: all ${UPLOAD_MAX_RETRIES} attempts failed err=${String(err)}`);
+      }
+    }
+  }
+
+  if (!downloadParam) {
+    throw lastError instanceof Error
+      ? lastError
+      : new Error(`CDN upload failed after ${UPLOAD_MAX_RETRIES} attempts`);
+  }
+  return { downloadParam };
+}

package/src/cdn-url.ts

@@ -0,0 +1,20 @@
+/**
+ * Unified CDN URL construction for Weixin CDN upload/download.
+ */
+
+/** 设为 true 时，当服务端未返回 full_url 字段，回退到客户端拼接 URL；false 则直接报错。 */
+export const ENABLE_CDN_URL_FALLBACK = true;
+
+/** Build a CDN download URL from encrypt_query_param. */
+export function buildCdnDownloadUrl(encryptedQueryParam: string, cdnBaseUrl: string): string {
+  return `${cdnBaseUrl}/download?encrypted_query_param=${encodeURIComponent(encryptedQueryParam)}`;
+}
+
+/** Build a CDN upload URL from upload_param and filekey. */
+export function buildCdnUploadUrl(params: {
+  cdnBaseUrl: string;
+  uploadParam: string;
+  filekey: string;
+}): string {
+  return `${params.cdnBaseUrl}/upload?encrypted_query_param=${encodeURIComponent(params.uploadParam)}&filekey=${encodeURIComponent(params.filekey)}`;
+}

package/src/context-store.ts

@@ -0,0 +1,8 @@
+export {
+  setContextToken,
+  getContextToken,
+  restoreContextTokens,
+  clearContextTokensForAccount,
+  bodyFromItemList,
+  isMediaItem,
+} from "./weixin-inbound.js";

package/src/credentials.ts

@@ -0,0 +1,64 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export interface WeixinIlinkCredentials {
+  botToken: string;
+  ilinkUserId?: string;
+  ilinkBotId?: string;
+  baseUrl?: string;
+  updatedAt?: string;
+}
+
+const DEFAULT_DATA_DIR = "./data/weixin-ilink";
+
+export function resolveStateDir(): string {
+  return process.env.ZHIN_DATA_DIR
+    ? path.join(process.env.ZHIN_DATA_DIR, "weixin-ilink")
+    : DEFAULT_DATA_DIR;
+}
+
+export function credentialsPath(botName: string): string {
+  return path.join(resolveStateDir(), `${botName}.json`);
+}
+
+export function loadCredentials(botName: string): WeixinIlinkCredentials | null {
+  const file = credentialsPath(botName);
+  try {
+    if (!fs.existsSync(file)) return null;
+    const raw = fs.readFileSync(file, "utf-8");
+    const data = JSON.parse(raw) as WeixinIlinkCredentials;
+    if (!data.botToken?.trim()) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+export function saveCredentials(botName: string, creds: WeixinIlinkCredentials): void {
+  const file = credentialsPath(botName);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(
+    file,
+    JSON.stringify({ ...creds, updatedAt: new Date().toISOString() }, null, 2),
+    "utf-8",
+  );
+}
+
+export function syncBufPath(botName: string): string {
+  return path.join(resolveStateDir(), `${botName}.sync-buf`);
+}
+
+export function loadSyncBuf(botName: string): string {
+  const file = syncBufPath(botName);
+  try {
+    return fs.existsSync(file) ? fs.readFileSync(file, "utf-8") : "";
+  } catch {
+    return "";
+  }
+}
+
+export function saveSyncBuf(botName: string, buf: string): void {
+  const file = syncBufPath(botName);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, buf, "utf-8");
+}

package/src/ilink-api.ts

@@ -0,0 +1,349 @@
+import crypto from "node:crypto";
+
+import { logger } from "./ilink-logger.js";
+import {
+  buildBaseInfo,
+  ILINK_APP_CLIENT_VERSION,
+  ILINK_APP_ID,
+} from "./ilink-meta.js";
+import { redactBody, redactUrl } from "./ilink-redact.js";
+
+import type {
+  GetUploadUrlReq,
+  GetUploadUrlResp,
+  GetUpdatesReq,
+  GetUpdatesResp,
+  NotifyStopResp,
+  NotifyStartResp,
+  SendMessageReq,
+  SendTypingReq,
+  GetConfigResp,
+} from "./ilink-types.js";
+
+export { buildBaseInfo, sanitizeBotAgent } from "./ilink-meta.js";
+
+export type WeixinApiOptions = {
+  baseUrl: string;
+  token?: string;
+  timeoutMs?: number;
+  /** Long-poll timeout for getUpdates (server may hold the request up to this). */
+  longPollTimeoutMs?: number;
+};
+
+/** Default timeout for long-poll getUpdates requests. */
+const DEFAULT_LONG_POLL_TIMEOUT_MS = 35_000;
+/** Default timeout for regular API requests (sendMessage, getUploadUrl). */
+const DEFAULT_API_TIMEOUT_MS = 15_000;
+/** Default timeout for lightweight API requests (getConfig, sendTyping). */
+const DEFAULT_CONFIG_TIMEOUT_MS = 10_000;
+
+function ensureTrailingSlash(url: string): string {
+  return url.endsWith("/") ? url : `${url}/`;
+}
+
+/** X-WECHAT-UIN header: random uint32 -> decimal string -> base64. */
+function randomWechatUin(): string {
+  const uint32 = crypto.randomBytes(4).readUInt32BE(0);
+  return Buffer.from(String(uint32), "utf-8").toString("base64");
+}
+
+/** Build headers shared by both GET and POST requests. */
+function buildCommonHeaders(): Record<string, string> {
+  const headers: Record<string, string> = {
+    "iLink-App-Id": ILINK_APP_ID,
+    "iLink-App-ClientVersion": String(ILINK_APP_CLIENT_VERSION),
+  };
+  return headers;
+}
+
+function buildHeaders(opts: { token?: string }): Record<string, string> {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    AuthorizationType: "ilink_bot_token",
+    "X-WECHAT-UIN": randomWechatUin(),
+    ...buildCommonHeaders(),
+  };
+  if (opts.token?.trim()) {
+    headers.Authorization = `Bearer ${opts.token.trim()}`;
+  }
+  logger.debug(
+    `requestHeaders: ${JSON.stringify({ ...headers, Authorization: headers.Authorization ? "Bearer ***" : undefined })}`,
+  );
+  return headers;
+}
+
+/**
+ * GET fetch wrapper: send a GET request to a Weixin API endpoint.
+ * When `timeoutMs` is set, the request is aborted after that many milliseconds.
+ * Query parameters should already be encoded in `endpoint`.
+ * Returns the raw response text on success; throws on HTTP error or (if used) timeout abort.
+ */
+export async function apiGetFetch(params: {
+  baseUrl: string;
+  endpoint: string;
+  timeoutMs?: number;
+  label: string;
+}): Promise<string> {
+  const base = ensureTrailingSlash(params.baseUrl);
+  const url = new URL(params.endpoint, base);
+  const hdrs = buildCommonHeaders();
+  logger.debug(`GET ${redactUrl(url.toString())}`);
+
+  const timeoutMs = params.timeoutMs;
+  const controller =
+    timeoutMs != null && timeoutMs > 0 ? new AbortController() : undefined;
+  const t =
+    controller != null && timeoutMs != null
+      ? setTimeout(() => controller.abort(), timeoutMs)
+      : undefined;
+  try {
+    const res = await fetch(url.toString(), {
+      method: "GET",
+      headers: hdrs,
+      ...(controller ? { signal: controller.signal } : {}),
+    });
+    if (t !== undefined) clearTimeout(t);
+    const rawText = await res.text();
+    logger.debug(`${params.label} status=${res.status} raw=${redactBody(rawText)}`);
+    if (!res.ok) {
+      throw new Error(`${params.label} ${res.status}: ${rawText}`);
+    }
+    return rawText;
+  } catch (err) {
+    if (t !== undefined) clearTimeout(t);
+    throw err;
+  }
+}
+
+function combineAbortSignals(
+  internal: AbortController | undefined,
+  external: AbortSignal | undefined,
+): { signal?: AbortSignal; cleanup: () => void } {
+  if (!internal && !external) return { cleanup: () => {} };
+  if (!internal) return { signal: external, cleanup: () => {} };
+  if (!external) return { signal: internal.signal, cleanup: () => {} };
+
+  if (external.aborted) {
+    internal.abort();
+    return { signal: internal.signal, cleanup: () => {} };
+  }
+
+  const onExternalAbort = () => internal.abort();
+  external.addEventListener("abort", onExternalAbort, { once: true });
+  return {
+    signal: internal.signal,
+    cleanup: () => external.removeEventListener("abort", onExternalAbort),
+  };
+}
+
+/**
+ * Common fetch wrapper: POST JSON to a Weixin API endpoint.
+ * When `timeoutMs` is provided, the request is aborted after that many milliseconds.
+ * When omitted, no client-side timeout is applied (relies on OS/TCP stack).
+ * When `abortSignal` is provided, an external channel stop also aborts the request.
+ * Returns the raw response text on success; throws on HTTP error or timeout.
+ */
+export async function apiPostFetch(params: {
+  baseUrl: string;
+  endpoint: string;
+  body: string;
+  token?: string;
+  timeoutMs?: number;
+  label: string;
+  abortSignal?: AbortSignal;
+}): Promise<string> {
+  const base = ensureTrailingSlash(params.baseUrl);
+  const url = new URL(params.endpoint, base);
+  const hdrs = buildHeaders({ token: params.token });
+  logger.debug(`POST ${redactUrl(url.toString())} body=${redactBody(params.body)}`);
+
+  const controller =
+    params.timeoutMs !== undefined ? new AbortController() : undefined;
+  const t =
+    controller != null && params.timeoutMs !== undefined
+      ? setTimeout(() => controller.abort(), params.timeoutMs)
+      : undefined;
+  const { signal, cleanup } = combineAbortSignals(controller, params.abortSignal);
+  try {
+    const res = await fetch(url.toString(), {
+      method: "POST",
+      headers: hdrs,
+      body: params.body,
+      ...(signal ? { signal } : {}),
+    });
+    const rawText = await res.text();
+    logger.debug(`${params.label} status=${res.status} raw=${redactBody(rawText)}`);
+    if (!res.ok) {
+      throw new Error(`${params.label} ${res.status}: ${rawText}`);
+    }
+    return rawText;
+  } catch (err) {
+    throw err;
+  } finally {
+    if (t !== undefined) clearTimeout(t);
+    cleanup();
+  }
+}
+
+/**
+ * Long-poll getUpdates. Server should hold the request until new messages or timeout.
+ *
+ * On client-side timeout (no server response within timeoutMs), returns an empty response
+ * with ret=0 so the caller can simply retry. This is normal for long-poll.
+ */
+export async function getUpdates(
+  params: GetUpdatesReq & {
+    baseUrl: string;
+    token?: string;
+    timeoutMs?: number;
+    /**
+     * Optional external abort signal (e.g. from the gateway when stopping the
+     * channel). When this aborts, the in-flight long-poll is terminated
+     * immediately so the monitor loop can exit well within the gateway's
+     * channel-stop budget (#141).
+     */
+    abortSignal?: AbortSignal;
+  },
+): Promise<GetUpdatesResp> {
+  const timeout = params.timeoutMs ?? DEFAULT_LONG_POLL_TIMEOUT_MS;
+  try {
+    const rawText = await apiPostFetch({
+      baseUrl: params.baseUrl,
+      endpoint: "ilink/bot/getupdates",
+      body: JSON.stringify({
+        get_updates_buf: params.get_updates_buf ?? "",
+        base_info: buildBaseInfo(),
+      }),
+      token: params.token,
+      timeoutMs: timeout,
+      label: "getUpdates",
+      abortSignal: params.abortSignal,
+    });
+    const resp: GetUpdatesResp = JSON.parse(rawText);
+    return resp;
+  } catch (err) {
+    // Long-poll timeout *or* external abort both surface as AbortError. The caller
+    // re-checks `abortSignal?.aborted` after we return; when aborted, it exits
+    // the loop. When not aborted (i.e. plain client-side long-poll timeout),
+    // returning the empty response lets the caller retry — preserving prior
+    // behavior for the normal long-poll case.
+    if (err instanceof Error && err.name === "AbortError") {
+      if (params.abortSignal?.aborted) {
+        logger.debug(`getUpdates: aborted by external signal`);
+      } else {
+        logger.debug(`getUpdates: client-side timeout after ${timeout}ms, returning empty response`);
+      }
+      return { ret: 0, msgs: [], get_updates_buf: params.get_updates_buf };
+    }
+    throw err;
+  }
+}
+
+/** Get a pre-signed CDN upload URL for a file. */
+export async function getUploadUrl(
+  params: GetUploadUrlReq & WeixinApiOptions,
+): Promise<GetUploadUrlResp> {
+  const rawText = await apiPostFetch({
+    baseUrl: params.baseUrl,
+    endpoint: "ilink/bot/getuploadurl",
+    body: JSON.stringify({
+      filekey: params.filekey,
+      media_type: params.media_type,
+      to_user_id: params.to_user_id,
+      rawsize: params.rawsize,
+      rawfilemd5: params.rawfilemd5,
+      filesize: params.filesize,
+      thumb_rawsize: params.thumb_rawsize,
+      thumb_rawfilemd5: params.thumb_rawfilemd5,
+      thumb_filesize: params.thumb_filesize,
+      no_need_thumb: params.no_need_thumb,
+      aeskey: params.aeskey,
+      base_info: buildBaseInfo(),
+    }),
+    token: params.token,
+    timeoutMs: params.timeoutMs ?? DEFAULT_API_TIMEOUT_MS,
+    label: "getUploadUrl",
+  });
+  const resp: GetUploadUrlResp = JSON.parse(rawText);
+  return resp;
+}
+
+/** Send a single message downstream. */
+export async function sendMessage(
+  params: WeixinApiOptions & { body: SendMessageReq },
+): Promise<void> {
+  await apiPostFetch({
+    baseUrl: params.baseUrl,
+    endpoint: "ilink/bot/sendmessage",
+    body: JSON.stringify({ ...params.body, base_info: buildBaseInfo() }),
+    token: params.token,
+    timeoutMs: params.timeoutMs ?? DEFAULT_API_TIMEOUT_MS,
+    label: "sendMessage",
+  });
+}
+
+/** Fetch bot config (includes typing_ticket) for a given user. */
+export async function getConfig(
+  params: WeixinApiOptions & { ilinkUserId: string; contextToken?: string },
+): Promise<GetConfigResp> {
+  const rawText = await apiPostFetch({
+    baseUrl: params.baseUrl,
+    endpoint: "ilink/bot/getconfig",
+    body: JSON.stringify({
+      ilink_user_id: params.ilinkUserId,
+      context_token: params.contextToken,
+      base_info: buildBaseInfo(),
+    }),
+    token: params.token,
+    timeoutMs: params.timeoutMs ?? DEFAULT_CONFIG_TIMEOUT_MS,
+    label: "getConfig",
+  });
+  const resp: GetConfigResp = JSON.parse(rawText);
+  return resp;
+}
+
+/** Send a typing indicator to a user. */
+export async function sendTyping(
+  params: WeixinApiOptions & { body: SendTypingReq },
+): Promise<void> {
+  await apiPostFetch({
+    baseUrl: params.baseUrl,
+    endpoint: "ilink/bot/sendtyping",
+    body: JSON.stringify({ ...params.body, base_info: buildBaseInfo() }),
+    token: params.token,
+    timeoutMs: params.timeoutMs ?? DEFAULT_CONFIG_TIMEOUT_MS,
+    label: "sendTyping",
+  });
+}
+
+/**
+ * Notify Weixin that this channel client is stopping (gateway shutdown / channel stop).
+ * Uses a standalone timeout (not the gateway abort signal) so the request can finish
+ * after OpenClaw has already aborted the long-poll.
+ */
+export async function notifyStop(params: WeixinApiOptions): Promise<NotifyStopResp> {
+  const rawText = await apiPostFetch({
+    baseUrl: params.baseUrl,
+    endpoint: "ilink/bot/msg/notifystop",
+    body: JSON.stringify({ base_info: buildBaseInfo() }),
+    token: params.token,
+    timeoutMs: params.timeoutMs ?? DEFAULT_CONFIG_TIMEOUT_MS,
+    label: "notifyStop",
+  });
+  return JSON.parse(rawText) as NotifyStopResp;
+}
+
+/**
+ * Notify Weixin that this channel client is starting (gateway startup / channel start).
+ */
+export async function notifyStart(params: WeixinApiOptions): Promise<NotifyStartResp> {
+  const rawText = await apiPostFetch({
+    baseUrl: params.baseUrl,
+    endpoint: "ilink/bot/msg/notifystart",
+    body: JSON.stringify({ base_info: buildBaseInfo() }),
+    token: params.token,
+    timeoutMs: params.timeoutMs ?? DEFAULT_CONFIG_TIMEOUT_MS,
+    label: "notifyStart",
+  });
+  return JSON.parse(rawText) as NotifyStartResp;
+}

package/src/ilink-config-cache.ts

@@ -0,0 +1,79 @@
+import { getConfig } from "./ilink-api.js";
+
+/** Subset of getConfig fields that we actually need; add new fields here as needed. */
+export interface CachedConfig {
+  typingTicket: string;
+}
+
+const CONFIG_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+const CONFIG_CACHE_INITIAL_RETRY_MS = 2_000;
+const CONFIG_CACHE_MAX_RETRY_MS = 60 * 60 * 1000;
+
+interface ConfigCacheEntry {
+  config: CachedConfig;
+  everSucceeded: boolean;
+  nextFetchAt: number;
+  retryDelayMs: number;
+}
+
+/**
+ * Per-user getConfig cache with periodic random refresh (within 24h) and
+ * exponential-backoff retry (up to 1h) on failure.
+ */
+export class WeixinConfigManager {
+  private cache = new Map<string, ConfigCacheEntry>();
+
+  constructor(
+    private apiOpts: { baseUrl: string; token?: string },
+    private log: (msg: string) => void,
+  ) {}
+
+  async getForUser(userId: string, contextToken?: string): Promise<CachedConfig> {
+    const now = Date.now();
+    const entry = this.cache.get(userId);
+    const shouldFetch = !entry || now >= entry.nextFetchAt;
+
+    if (shouldFetch) {
+      let fetchOk = false;
+      try {
+        const resp = await getConfig({
+          baseUrl: this.apiOpts.baseUrl,
+          token: this.apiOpts.token,
+          ilinkUserId: userId,
+          contextToken,
+        });
+        if (resp.ret === 0) {
+          this.cache.set(userId, {
+            config: { typingTicket: resp.typing_ticket ?? "" },
+            everSucceeded: true,
+            nextFetchAt: now + Math.random() * CONFIG_CACHE_TTL_MS,
+            retryDelayMs: CONFIG_CACHE_INITIAL_RETRY_MS,
+          });
+          this.log(
+            `[weixin] config ${entry?.everSucceeded ? "refreshed" : "cached"} for ${userId}`,
+          );
+          fetchOk = true;
+        }
+      } catch (err) {
+        this.log(`[weixin] getConfig failed for ${userId} (ignored): ${String(err)}`);
+      }
+      if (!fetchOk) {
+        const prevDelay = entry?.retryDelayMs ?? CONFIG_CACHE_INITIAL_RETRY_MS;
+        const nextDelay = Math.min(prevDelay * 2, CONFIG_CACHE_MAX_RETRY_MS);
+        if (entry) {
+          entry.nextFetchAt = now + nextDelay;
+          entry.retryDelayMs = nextDelay;
+        } else {
+          this.cache.set(userId, {
+            config: { typingTicket: "" },
+            everSucceeded: false,
+            nextFetchAt: now + CONFIG_CACHE_INITIAL_RETRY_MS,
+            retryDelayMs: CONFIG_CACHE_INITIAL_RETRY_MS,
+          });
+        }
+      }
+    }
+
+    return this.cache.get(userId)?.config ?? { typingTicket: "" };
+  }
+}

package/src/ilink-logger.ts

@@ -0,0 +1,36 @@
+export type IlinkLogger = {
+  debug: (msg: string) => void;
+  info: (msg: string) => void;
+  warn: (msg: string) => void;
+  error: (msg: string) => void;
+  withAccount: (accountId: string) => IlinkLogger;
+};
+
+let sink: IlinkLogger = {
+  debug: () => {},
+  info: () => {},
+  warn: (msg) => console.warn(`[weixin-ilink] ${msg}`),
+  error: (msg) => console.error(`[weixin-ilink] ${msg}`),
+  withAccount(accountId) {
+    const prefix = `[weixin-ilink:${accountId}]`;
+    return {
+      debug: (msg) => sink.debug(`${prefix} ${msg}`),
+      info: (msg) => sink.info(`${prefix} ${msg}`),
+      warn: (msg) => sink.warn(`${prefix} ${msg}`),
+      error: (msg) => sink.error(`${prefix} ${msg}`),
+      withAccount: () => this,
+    };
+  },
+};
+
+export function setIlinkLogger(next: IlinkLogger): void {
+  sink = next;
+}
+
+export const logger: IlinkLogger = {
+  debug: (msg) => sink.debug(msg),
+  info: (msg) => sink.info(msg),
+  warn: (msg) => sink.warn(msg),
+  error: (msg) => sink.error(msg),
+  withAccount: (accountId) => sink.withAccount(accountId),
+};