Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

extensions/qqbot/src/bridge/approval/handler-runtime.ts

@@ -0,0 +1,204 @@
+/**
+ * QQ Bot Native Approval Runtime Adapter.
+ *
+ * Implements the framework's ChannelApprovalNativeRuntimeSpec to deliver
+ * approval requests as QQ messages with inline keyboard buttons and handle
+ * resolved/expired lifecycle events.
+ *
+ * This file is lazily imported by capability.ts to avoid loading
+ * heavy dependencies on the critical startup path.
+ */
+
+import type { ChannelApprovalNativeRuntimeSpec } from "openclaw/plugin-sdk/approval-handler-runtime";
+import { createChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-runtime";
+import type { ChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-runtime";
+import { resolveApprovalRequestSessionConversation } from "openclaw/plugin-sdk/approval-native-runtime";
+import {
+  buildExecApprovalText,
+  buildPluginApprovalText,
+  buildApprovalKeyboard,
+  resolveApprovalTarget,
+  type ExecApprovalRequest,
+  type PluginApprovalRequest,
+} from "../../engine/approval/index.js";
+import { getMessageApi, accountToCreds } from "../../engine/messaging/sender.js";
+import type { ChatScope, InlineKeyboard, MessageResponse } from "../../engine/types.js";
+import {
+  matchesQQBotApprovalAccount,
+  resolveQQBotExecApprovalConfig,
+  isQQBotExecApprovalClientEnabled,
+  shouldHandleQQBotExecApprovalRequest,
+} from "../../exec-approvals.js";
+import { ensurePlatformAdapter } from "../bootstrap.js";
+import { resolveQQBotAccount } from "../config.js";
+import { getBridgeLogger } from "../logger.js";
+
+type ApprovalRequest = ExecApprovalRequest | PluginApprovalRequest;
+
+type QQBotPendingEntry = {
+  messageId?: string;
+  targetType: ChatScope;
+  targetId: string;
+};
+
+type QQBotPendingPayload = {
+  text: string;
+  keyboard: InlineKeyboard;
+};
+
+function isExecRequest(request: ApprovalRequest): request is ExecApprovalRequest {
+  return "expiresAtMs" in request;
+}
+
+function resolveQQTarget(request: ApprovalRequest): { type: ChatScope; id: string } | null {
+  const sessionConversation = resolveApprovalRequestSessionConversation({
+    request: request as never,
+    channel: "qqbot",
+    bundledFallback: true,
+  });
+
+  const sessionKey = request.request.sessionKey ?? null;
+  const turnSourceTo = request.request.turnSourceTo ?? null;
+
+  const target = resolveApprovalTarget(sessionKey, turnSourceTo);
+  if (target) {
+    return target;
+  }
+
+  if (sessionConversation?.id) {
+    const kind = sessionConversation.kind;
+    const chatScope: ChatScope = kind === "group" ? "group" : "c2c";
+    return { type: chatScope, id: sessionConversation.id };
+  }
+
+  return null;
+}
+
+type QQBotPreparedTarget = { type: ChatScope; id: string };
+
+const qqbotApprovalRuntimeSpec: ChannelApprovalNativeRuntimeSpec<
+  QQBotPendingPayload,
+  QQBotPreparedTarget,
+  QQBotPendingEntry
+> = {
+  eventKinds: ["exec", "plugin"],
+
+  availability: {
+    isConfigured: ({ cfg, accountId }) => {
+      if (resolveQQBotExecApprovalConfig({ cfg, accountId }) !== undefined) {
+        const result = isQQBotExecApprovalClientEnabled({ cfg, accountId });
+        getBridgeLogger().debug?.(
+          `[qqbot:approval-runtime] isConfigured(profile) accountId=${accountId} → ${result}`,
+        );
+        return result;
+      }
+      const account = resolveQQBotAccount(cfg, accountId ?? undefined);
+      const result = account.enabled && account.secretSource !== "none";
+      getBridgeLogger().debug?.(
+        `[qqbot:approval-runtime] isConfigured(fallback) accountId=${accountId} enabled=${account.enabled} secretSource=${account.secretSource} → ${result}`,
+      );
+      return result;
+    },
+    shouldHandle: ({ cfg, accountId, request }) => {
+      if (resolveQQBotExecApprovalConfig({ cfg, accountId }) !== undefined) {
+        const result = shouldHandleQQBotExecApprovalRequest({ cfg, accountId, request });
+        getBridgeLogger().debug?.(
+          `[qqbot:approval-runtime] shouldHandle(profile) accountId=${accountId} → ${result}`,
+        );
+        return result;
+      }
+      const target = resolveQQTarget(request as ApprovalRequest);
+      if (target === null) {
+        getBridgeLogger().debug?.(
+          `[qqbot:approval-runtime] shouldHandle(fallback) accountId=${accountId} target=null → false`,
+        );
+        return false;
+      }
+      const accountMatches = matchesQQBotApprovalAccount({
+        cfg,
+        accountId,
+        request: request as ApprovalRequest,
+      });
+      getBridgeLogger().debug?.(
+        `[qqbot:approval-runtime] shouldHandle(fallback) accountId=${accountId} target=${JSON.stringify(
+          target,
+        )} accountMatches=${accountMatches} → ${accountMatches}`,
+      );
+      return accountMatches;
+    },
+  },
+
+  presentation: {
+    buildPendingPayload: ({ request, view }) => {
+      const req = request as ApprovalRequest;
+      const text = isExecRequest(req) ? buildExecApprovalText(req) : buildPluginApprovalText(req);
+      const keyboard = buildApprovalKeyboard(
+        req.id,
+        view.actions.map((action) => action.decision),
+      );
+      getBridgeLogger().debug?.(
+        `[qqbot:approval-runtime] buildPendingPayload requestId=${req.id} kind=${
+          isExecRequest(req) ? "exec" : "plugin"
+        }`,
+      );
+      return { text, keyboard };
+    },
+    buildResolvedResult: () => ({ kind: "leave" }),
+    buildExpiredResult: () => ({ kind: "leave" }),
+  },
+
+  transport: {
+    prepareTarget: ({ request }) => {
+      const target = resolveQQTarget(request as ApprovalRequest);
+      getBridgeLogger().debug?.(
+        `[qqbot:approval-runtime] prepareTarget requestId=${request.id} target=${JSON.stringify(target)}`,
+      );
+      if (!target) {
+        return null;
+      }
+      return { target, dedupeKey: `${target.type}:${target.id}` };
+    },
+
+    deliverPending: async ({ cfg, accountId, preparedTarget, pendingPayload }) => {
+      // Ensure the PlatformAdapter is registered — resolveQQBotAccount below
+      // calls getPlatformAdapter() to resolve secret inputs.
+      ensurePlatformAdapter();
+      const account = resolveQQBotAccount(cfg, accountId ?? undefined);
+      const creds = accountToCreds(account);
+      const messageApi = getMessageApi(account.appId);
+
+      let result: MessageResponse;
+      try {
+        getBridgeLogger().debug?.(
+          `[qqbot:approval-runtime] deliverPending accountId=${accountId} target=${preparedTarget.type}:${preparedTarget.id}`,
+        );
+        result = await messageApi.sendMessage(
+          preparedTarget.type,
+          preparedTarget.id,
+          pendingPayload.text,
+          creds,
+          { inlineKeyboard: pendingPayload.keyboard },
+        );
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(
+          `Failed to send approval message to ${preparedTarget.type}:${preparedTarget.id}: ${msg}`,
+          { cause: err },
+        );
+      }
+
+      getBridgeLogger().debug?.(
+        `[qqbot:approval-runtime] deliverPending success accountId=${accountId} messageId=${result.id ?? ""}`,
+      );
+      return {
+        messageId: result.id,
+        targetType: preparedTarget.type,
+        targetId: preparedTarget.id,
+      };
+    },
+  },
+};
+
+export const qqbotApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter(
+  qqbotApprovalRuntimeSpec,
+) as unknown as ChannelApprovalNativeRuntimeAdapter;