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/slack/src/approval-handler.runtime.ts

@@ -0,0 +1,527 @@
+// Slack plugin module implements approval handler behavior.
+import type { App } from "@slack/bolt";
+import type { Block, KnownBlock } from "@slack/web-api";
+import type {
+  ChannelApprovalCapabilityHandlerContext,
+  ExecApprovalExpiredView,
+  ExecApprovalPendingView,
+  ExecApprovalResolvedView,
+  ExpiredApprovalView,
+  PendingApprovalView,
+  PluginApprovalExpiredView,
+  PluginApprovalPendingView,
+  PluginApprovalResolvedView,
+  ResolvedApprovalView,
+} from "openclaw/plugin-sdk/approval-handler-runtime";
+import { createChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-runtime";
+import { buildChannelApprovalNativeTargetKey } from "openclaw/plugin-sdk/approval-native-runtime";
+import { buildApprovalPresentationFromActionDescriptors } from "openclaw/plugin-sdk/approval-reply-runtime";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-contracts";
+import { logError } from "openclaw/plugin-sdk/logging-core";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import {
+  isSlackAnyNativeApprovalClientEnabled,
+  resolveSlackApprovalKind,
+  shouldHandleSlackNativeApprovalRequest,
+} from "./approval-native-gates.js";
+import { normalizeSlackApproverId } from "./exec-approvals.js";
+import { resolveSlackReplyBlocks } from "./reply-blocks.js";
+import { sendMessageSlack } from "./send.js";
+import { truncateSlackText } from "./truncate.js";
+
+type SlackBlock = Block | KnownBlock;
+type SlackPendingApproval = {
+  channelId: string;
+  messageTs: string;
+};
+type SlackPendingDelivery = {
+  text: string;
+  blocks: SlackBlock[];
+};
+type SlackMetadataItem = {
+  label: string;
+  value: string;
+};
+type SlackPluginApprovalView =
+  | PluginApprovalPendingView
+  | PluginApprovalResolvedView
+  | PluginApprovalExpiredView;
+
+const SLACK_CONTEXT_ELEMENTS_MAX = 10;
+const SLACK_CHAT_UPDATE_TEXT_LIMIT = 4000;
+const SLACK_TEXT_OBJECT_MAX = 3000;
+
+type SlackExecApprovalConfig = NonNullable<
+  NonNullable<NonNullable<OpenClawConfig["channels"]>["slack"]>["execApprovals"]
+>;
+
+export type SlackApprovalHandlerContext = {
+  app: App;
+  config: SlackExecApprovalConfig;
+};
+
+function resolveHandlerContext(params: ChannelApprovalCapabilityHandlerContext): {
+  accountId: string;
+  context: SlackApprovalHandlerContext;
+} | null {
+  const context = params.context as SlackApprovalHandlerContext | undefined;
+  const accountId = normalizeOptionalString(params.accountId) ?? "";
+  if (!context?.app || !accountId) {
+    return null;
+  }
+  return { accountId, context };
+}
+
+function truncateSlackMrkdwn(text: string, maxChars: number): string {
+  const limit = Math.max(0, Math.floor(maxChars));
+  if (text.length <= limit) {
+    return text;
+  }
+  if (limit <= 1) {
+    return truncateUtf16Safe(text, limit);
+  }
+  return `${truncateUtf16Safe(text, limit - 1)}…`;
+}
+
+function buildSlackCodeBlock(text: string): string {
+  let fence = "```";
+  while (text.includes(fence)) {
+    fence += "`";
+  }
+  return `${fence}\n${text}\n${fence}`;
+}
+
+function formatSlackApprover(resolvedBy?: string | null): string | null {
+  const normalized = resolvedBy ? normalizeSlackApproverId(resolvedBy) : undefined;
+  if (normalized) {
+    return `<@${normalized}>`;
+  }
+  const trimmed = normalizeOptionalString(resolvedBy);
+  return trimmed ? trimmed : null;
+}
+
+function formatSlackMetadataLine(label: string, value: string): string {
+  return `*${label}:* ${value}`;
+}
+
+function buildSlackMetadataLines(metadata: readonly SlackMetadataItem[]): string[] {
+  const lines: string[] = [];
+  for (const item of metadata) {
+    lines.push(formatSlackMetadataLine(item.label, item.value));
+  }
+  return lines;
+}
+
+function buildSlackMetadataContextElements(metadata: readonly SlackMetadataItem[]) {
+  const lines = buildSlackMetadataLines(metadata);
+  const visibleLineCount =
+    lines.length > SLACK_CONTEXT_ELEMENTS_MAX ? SLACK_CONTEXT_ELEMENTS_MAX - 1 : lines.length;
+  const elements: Array<{ type: "mrkdwn"; text: string }> = [];
+  for (let index = 0; index < visibleLineCount; index += 1) {
+    const line = lines[index];
+    if (line === undefined) {
+      continue;
+    }
+    elements.push({
+      type: "mrkdwn",
+      text: truncateSlackMrkdwn(line, SLACK_TEXT_OBJECT_MAX),
+    });
+  }
+  if (lines.length > SLACK_CONTEXT_ELEMENTS_MAX) {
+    elements.push({
+      type: "mrkdwn",
+      text: `…+${lines.length - visibleLineCount} more`,
+    });
+  }
+  return elements;
+}
+
+function buildSlackMetadataContextBlocks(metadata: readonly SlackMetadataItem[]): SlackBlock[] {
+  const metadataElements = buildSlackMetadataContextElements(metadata);
+  return metadataElements.length > 0
+    ? [
+        {
+          type: "context",
+          elements: metadataElements,
+        } satisfies SlackBlock,
+      ]
+    : [];
+}
+
+function resolveSlackApprovalDecisionLabel(
+  decision: "allow-once" | "allow-always" | "deny",
+): string {
+  return decision === "allow-once"
+    ? "Allowed once"
+    : decision === "allow-always"
+      ? "Allowed always"
+      : "Denied";
+}
+
+function buildSlackPluginMetadata(view: SlackPluginApprovalView): SlackMetadataItem[] {
+  return [{ label: "Approval ID", value: view.approvalId }, ...view.metadata];
+}
+
+function resolveSlackPluginDescription(view: SlackPluginApprovalView): string {
+  return normalizeOptionalString(view.description) ?? "A plugin action needs your approval.";
+}
+
+function buildSlackPluginRequestBlocks(view: SlackPluginApprovalView): SlackBlock[] {
+  return [
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*Request*\n${truncateSlackMrkdwn(view.title, 2600)}`,
+      },
+    },
+    ...buildSlackMetadataContextBlocks(buildSlackPluginMetadata(view)),
+  ];
+}
+
+function buildSlackExecPendingApprovalText(view: ExecApprovalPendingView): string {
+  const metadataLines = buildSlackMetadataLines(view.metadata);
+  const lines = [
+    "*Exec approval required*",
+    "A command needs your approval.",
+    "",
+    "*Command*",
+    buildSlackCodeBlock(view.commandText),
+    ...metadataLines,
+  ];
+  return lines.join("\n");
+}
+
+function buildSlackPluginPendingApprovalText(view: PluginApprovalPendingView): string {
+  const metadataLines = buildSlackMetadataLines(buildSlackPluginMetadata(view));
+  const lines = [
+    "*Plugin approval required*",
+    resolveSlackPluginDescription(view),
+    "",
+    "*Request*",
+    view.title,
+    ...metadataLines,
+  ];
+  return lines.join("\n");
+}
+
+function buildSlackPendingApprovalText(view: PendingApprovalView): string {
+  return view.approvalKind === "plugin"
+    ? buildSlackPluginPendingApprovalText(view)
+    : buildSlackExecPendingApprovalText(view);
+}
+
+function buildSlackExecPendingApprovalBlocks(view: ExecApprovalPendingView): SlackBlock[] {
+  const interactiveBlocks =
+    resolveSlackReplyBlocks({
+      text: "",
+      presentation: buildApprovalPresentationFromActionDescriptors(view.actions),
+    }) ?? [];
+  return [
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: "*Exec approval required*\nA command needs your approval.",
+      },
+    },
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*Command*\n${buildSlackCodeBlock(truncateSlackMrkdwn(view.commandText, 2600))}`,
+      },
+    },
+    ...buildSlackMetadataContextBlocks(view.metadata),
+    ...interactiveBlocks,
+  ];
+}
+
+function buildSlackPluginPendingApprovalBlocks(view: PluginApprovalPendingView): SlackBlock[] {
+  const interactiveBlocks =
+    resolveSlackReplyBlocks({
+      text: "",
+      presentation: buildApprovalPresentationFromActionDescriptors(view.actions),
+    }) ?? [];
+  return [
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*Plugin approval required*\n${truncateSlackMrkdwn(
+          resolveSlackPluginDescription(view),
+          2600,
+        )}`,
+      },
+    },
+    ...buildSlackPluginRequestBlocks(view),
+    ...interactiveBlocks,
+  ];
+}
+
+function buildSlackPendingApprovalBlocks(view: PendingApprovalView): SlackBlock[] {
+  return view.approvalKind === "plugin"
+    ? buildSlackPluginPendingApprovalBlocks(view)
+    : buildSlackExecPendingApprovalBlocks(view);
+}
+
+function buildSlackExecResolvedText(view: ExecApprovalResolvedView): string {
+  const resolvedBy = formatSlackApprover(view.resolvedBy);
+  const lines = [
+    `*Exec approval: ${resolveSlackApprovalDecisionLabel(view.decision)}*`,
+    resolvedBy ? `Resolved by ${resolvedBy}.` : "Resolved.",
+    "",
+    "*Command*",
+    buildSlackCodeBlock(view.commandText),
+  ];
+  return lines.join("\n");
+}
+
+function buildSlackPluginResolvedText(view: PluginApprovalResolvedView): string {
+  const resolvedBy = formatSlackApprover(view.resolvedBy);
+  const metadataLines = buildSlackMetadataLines(buildSlackPluginMetadata(view));
+  const lines = [
+    `*Plugin approval: ${resolveSlackApprovalDecisionLabel(view.decision)}*`,
+    resolvedBy ? `Resolved by ${resolvedBy}.` : "Resolved.",
+    "",
+    "*Request*",
+    view.title,
+    ...metadataLines,
+  ];
+  return lines.join("\n");
+}
+
+function buildSlackResolvedText(view: ResolvedApprovalView): string {
+  return view.approvalKind === "plugin"
+    ? buildSlackPluginResolvedText(view)
+    : buildSlackExecResolvedText(view);
+}
+
+function buildSlackExecResolvedBlocks(view: ExecApprovalResolvedView): SlackBlock[] {
+  const resolvedBy = formatSlackApprover(view.resolvedBy);
+  return [
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*Exec approval: ${resolveSlackApprovalDecisionLabel(view.decision)}*\n${
+          resolvedBy ? `Resolved by ${resolvedBy}.` : "Resolved."
+        }`,
+      },
+    },
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*Command*\n${buildSlackCodeBlock(truncateSlackMrkdwn(view.commandText, 2600))}`,
+      },
+    },
+  ];
+}
+
+function buildSlackPluginResolvedBlocks(view: PluginApprovalResolvedView): SlackBlock[] {
+  const resolvedBy = formatSlackApprover(view.resolvedBy);
+  return [
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*Plugin approval: ${resolveSlackApprovalDecisionLabel(view.decision)}*\n${
+          resolvedBy ? `Resolved by ${resolvedBy}.` : "Resolved."
+        }`,
+      },
+    },
+    ...buildSlackPluginRequestBlocks(view),
+  ];
+}
+
+function buildSlackResolvedBlocks(view: ResolvedApprovalView): SlackBlock[] {
+  return view.approvalKind === "plugin"
+    ? buildSlackPluginResolvedBlocks(view)
+    : buildSlackExecResolvedBlocks(view);
+}
+
+function buildSlackExecExpiredText(view: ExecApprovalExpiredView): string {
+  return [
+    "*Exec approval expired*",
+    "This approval request expired before it was resolved.",
+    "",
+    "*Command*",
+    buildSlackCodeBlock(view.commandText),
+  ].join("\n");
+}
+
+function buildSlackPluginExpiredText(view: PluginApprovalExpiredView): string {
+  const metadataLines = buildSlackMetadataLines(buildSlackPluginMetadata(view));
+  return [
+    "*Plugin approval expired*",
+    "This approval request expired before it was resolved.",
+    "",
+    "*Request*",
+    view.title,
+    ...metadataLines,
+  ].join("\n");
+}
+
+function buildSlackExpiredText(view: ExpiredApprovalView): string {
+  return view.approvalKind === "plugin"
+    ? buildSlackPluginExpiredText(view)
+    : buildSlackExecExpiredText(view);
+}
+
+function buildSlackExecExpiredBlocks(view: ExecApprovalExpiredView): SlackBlock[] {
+  return [
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: "*Exec approval expired*\nThis approval request expired before it was resolved.",
+      },
+    },
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*Command*\n${buildSlackCodeBlock(truncateSlackMrkdwn(view.commandText, 2600))}`,
+      },
+    },
+  ];
+}
+
+function buildSlackPluginExpiredBlocks(view: PluginApprovalExpiredView): SlackBlock[] {
+  return [
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: "*Plugin approval expired*\nThis approval request expired before it was resolved.",
+      },
+    },
+    ...buildSlackPluginRequestBlocks(view),
+  ];
+}
+
+function buildSlackExpiredBlocks(view: ExpiredApprovalView): SlackBlock[] {
+  return view.approvalKind === "plugin"
+    ? buildSlackPluginExpiredBlocks(view)
+    : buildSlackExecExpiredBlocks(view);
+}
+
+async function updateMessage(params: {
+  app: App;
+  channelId: string;
+  messageTs: string;
+  text: string;
+  blocks: SlackBlock[];
+}): Promise<void> {
+  try {
+    await params.app.client.chat.update({
+      channel: params.channelId,
+      ts: params.messageTs,
+      text: truncateSlackText(params.text, SLACK_CHAT_UPDATE_TEXT_LIMIT),
+      blocks: params.blocks,
+    });
+  } catch (err) {
+    logError(`slack approvals: failed to update message: ${String(err)}`);
+  }
+}
+
+export const slackApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter<
+  SlackPendingDelivery,
+  { to: string; threadTs?: string },
+  SlackPendingApproval,
+  never,
+  SlackPendingDelivery
+>({
+  eventKinds: ["exec", "plugin"],
+  availability: {
+    isConfigured: (params) => {
+      const resolved = resolveHandlerContext(params);
+      return resolved
+        ? isSlackAnyNativeApprovalClientEnabled({
+            cfg: params.cfg,
+            accountId: resolved.accountId,
+          })
+        : false;
+    },
+    shouldHandle: (params) => {
+      const resolved = resolveHandlerContext(params);
+      if (!resolved) {
+        return false;
+      }
+      return shouldHandleSlackNativeApprovalRequest({
+        cfg: params.cfg,
+        accountId: resolved.accountId,
+        approvalKind: resolveSlackApprovalKind(params.request),
+        request: params.request,
+      });
+    },
+  },
+  presentation: {
+    buildPendingPayload: ({ view }) => ({
+      text: buildSlackPendingApprovalText(view),
+      blocks: buildSlackPendingApprovalBlocks(view),
+    }),
+    buildResolvedResult: ({ view }) => ({
+      kind: "update",
+      payload: {
+        text: buildSlackResolvedText(view),
+        blocks: buildSlackResolvedBlocks(view),
+      },
+    }),
+    buildExpiredResult: ({ view }) => ({
+      kind: "update",
+      payload: {
+        text: buildSlackExpiredText(view),
+        blocks: buildSlackExpiredBlocks(view),
+      },
+    }),
+  },
+  transport: {
+    prepareTarget: ({ plannedTarget }) => ({
+      dedupeKey: buildChannelApprovalNativeTargetKey(plannedTarget.target),
+      target: {
+        to: plannedTarget.target.to,
+        threadTs:
+          plannedTarget.target.threadId != null ? String(plannedTarget.target.threadId) : undefined,
+      },
+    }),
+    deliverPending: async ({ cfg, accountId, context, preparedTarget, pendingPayload }) => {
+      const resolved = resolveHandlerContext({ cfg, accountId, context });
+      if (!resolved) {
+        return null;
+      }
+      const message = await sendMessageSlack(preparedTarget.to, pendingPayload.text, {
+        cfg,
+        accountId: resolved.accountId,
+        threadTs: preparedTarget.threadTs,
+        blocks: pendingPayload.blocks,
+        client: resolved.context.app.client,
+      });
+      return {
+        channelId: message.channelId,
+        messageTs: message.messageId,
+      };
+    },
+    updateEntry: async ({ cfg, accountId, context, entry, payload }) => {
+      const resolved = resolveHandlerContext({ cfg, accountId, context });
+      if (!resolved) {
+        return;
+      }
+      const nextPayload = payload;
+      await updateMessage({
+        app: resolved.context.app,
+        channelId: entry.channelId,
+        messageTs: entry.messageTs,
+        text: nextPayload.text,
+        blocks: nextPayload.blocks,
+      });
+    },
+  },
+  observe: {
+    onDeliveryError: ({ error, request }) => {
+      logError(`slack approvals: failed to deliver approval ${request.id}: ${String(error)}`);
+    },
+  },
+});