@soimy/dingtalk 3.6.11 → 3.7.0

package/src/{config.ts → platform/config.ts}

@@ -4,8 +4,12 @@ import {
   hasConfiguredSecretInput,
   resolveDingTalkSecretConfig,
 } from "./secret-input";
-import type { DingTalkChannelConfig, DingTalkConfig } from "./types";
-export { resolveRelativePath, resolveUserPath } from "./path-utils";
+import type {
+  DingTalkChannelConfig,
+  DingTalkConfig,
+  DingTalkGatewayCapabilitiesConfig,
+} from "./types";
+export { resolveRelativePath, resolveUserPath } from "../shared/path-utils";
 const DEFAULT_LEARNING_NOTE_TTL_MS = 6 * 60 * 60 * 1000;
 export type RuntimeDingTalkConfig = Omit<DingTalkConfig, "clientSecret"> & { clientSecret: string };
 
@@ -15,16 +19,22 @@ function normalizeLearningConfig(
 ): DingTalkConfig {
   return {
     ...config,
-    learningEnabled: options.applyDefaults ? config.learningEnabled ?? false : config.learningEnabled,
+    learningEnabled: options.applyDefaults
+      ? (config.learningEnabled ?? false)
+      : config.learningEnabled,
     learningAutoApply: options.applyDefaults
-      ? config.learningAutoApply ?? false
+      ? (config.learningAutoApply ?? false)
       : config.learningAutoApply,
     learningNoteTtlMs: options.applyDefaults
-      ? config.learningNoteTtlMs ?? DEFAULT_LEARNING_NOTE_TTL_MS
+      ? (config.learningNoteTtlMs ?? DEFAULT_LEARNING_NOTE_TTL_MS)
       : config.learningNoteTtlMs,
     cardStreamingMode: options.applyDefaults
       ? (config.cardStreamingMode ?? (config.cardRealTimeStream === true ? "all" : "off"))
       : config.cardStreamingMode,
+    // Derived, internal-only: defaults below turn an omitted mode into "off",
+    // which would otherwise be indistinguishable from an explicit "off".
+    cardStreamingModeConfigured:
+      config.cardStreamingModeConfigured ?? config.cardStreamingMode !== undefined,
   };
 }
 
@@ -53,6 +63,32 @@ function stripRemovedLegacyFields(config: DingTalkConfig): DingTalkConfig {
   return rest as DingTalkConfig;
 }
 
+/**
+ * Merge channel-level and account-level `gatewayCapabilities` gates by sub-key.
+ *
+ * `mergeAccountWithDefaults` is a shallow merge, so without this helper an
+ * account-level object would replace the whole channel-level `gatewayCapabilities` and
+ * silently drop a channel-level allowlist (fail-open). Merging `tools` /
+ * `docs` / `send` separately keeps channel-level restrictions in force unless
+ * the account explicitly overrides that exact sub-key.
+ */
+export function mergeGatewayCapabilitiesConfig(
+  channelLevel: DingTalkGatewayCapabilitiesConfig | undefined,
+  accountLevel: DingTalkGatewayCapabilitiesConfig | undefined,
+): DingTalkGatewayCapabilitiesConfig | undefined {
+  if (!channelLevel) {
+    return accountLevel;
+  }
+  if (!accountLevel) {
+    return channelLevel;
+  }
+  return {
+    tools: { ...channelLevel.tools, ...accountLevel.tools },
+    docs: { ...channelLevel.docs, ...accountLevel.docs },
+    send: { ...channelLevel.send, ...accountLevel.send },
+  };
+}
+
 /**
  * Merge channel-level defaults into an account-specific config.
  * Account-level values take precedence; `accounts` key is excluded to avoid recursion.
@@ -61,8 +97,10 @@ export function mergeAccountWithDefaults(
   channelCfg: DingTalkConfig,
   accountCfg: DingTalkConfig,
 ): DingTalkConfig {
-  const { accounts: _accounts, ...defaultCandidate } =
-    channelCfg as DingTalkConfig & { accounts?: unknown; verboseRealtimeStream?: unknown };
+  const { accounts: _accounts, ...defaultCandidate } = channelCfg as DingTalkConfig & {
+    accounts?: unknown;
+    verboseRealtimeStream?: unknown;
+  };
   const defaults = stripRemovedLegacyFields(defaultCandidate as DingTalkConfig);
   const normalizedAccountCfg = stripRemovedLegacyFields(
     normalizeLearningConfig(accountCfg, { applyDefaults: false }),
@@ -73,13 +111,23 @@ export function mergeAccountWithDefaults(
       Object.assign(overrides, { [key]: value });
     }
   }
-  return normalizeLearningConfig(
-    {
-      ...defaults,
-      ...overrides,
-    },
-    { applyDefaults: true },
+  const merged: DingTalkConfig = {
+    ...defaults,
+    ...overrides,
+  };
+  // Explicitness is inherited: the account opt-out only counts when the account
+  // (or the channel) actually wrote `cardStreamingMode` in its config.
+  merged.cardStreamingModeConfigured =
+    normalizedAccountCfg.cardStreamingModeConfigured === true ||
+    channelCfg.cardStreamingMode !== undefined;
+  const gatewayCapabilities = mergeGatewayCapabilitiesConfig(
+    defaults.gatewayCapabilities,
+    overrides.gatewayCapabilities,
   );
+  if (gatewayCapabilities) {
+    merged.gatewayCapabilities = gatewayCapabilities;
+  }
+  return normalizeLearningConfig(merged, { applyDefaults: true });
 }
 
 /**
@@ -113,6 +161,107 @@ export function isConfigured(cfg: OpenClawConfig, accountId?: string): boolean {
   return Boolean(config.clientId && hasConfiguredSecretInput(config.clientSecret));
 }
 
+/**
+ * Resolved Gateway RPC capability settings (Issue #608, 问题 3).
+ * All capabilities default to enabled; allowlists default to unrestricted.
+ */
+export interface ResolvedGatewayCapabilities {
+  /** `dingtalk.docs.*` / `dingtalk-connector.docs.*` RPCs enabled (default: true) */
+  docsEnabled: boolean;
+  /** `dingtalk-connector.sendToUser/sendToGroup/send` RPCs enabled (default: true) */
+  proactiveSendEnabled: boolean;
+  /** When set, docs RPCs only accept these spaceId values */
+  allowedSpaceIds?: string[];
+  /** When set, proactive-send RPCs only accept these `user:*` / `group:*` targets */
+  allowedTargets?: string[];
+}
+
+/** Denial reason returned when `gatewayCapabilities.tools.docs` is explicitly false. */
+export const DOCS_GATE_DISABLED_REASON =
+  "dingtalk docs Gateway RPC is disabled by config (gatewayCapabilities.tools.docs = false)";
+
+/** Denial reason returned when `gatewayCapabilities.tools.proactiveSend` is explicitly false. */
+export const PROACTIVE_SEND_GATE_DISABLED_REASON =
+  "dingtalk proactive-send Gateway RPC is disabled by config (gatewayCapabilities.tools.proactiveSend = false)";
+
+const DEFAULT_GATEWAY_CAPABILITIES: ResolvedGatewayCapabilities = Object.freeze({
+  docsEnabled: true,
+  proactiveSendEnabled: true,
+});
+
+/**
+ * Resolve Gateway RPC capability configuration for an account.
+ * Account-level `gatewayCapabilities` is merged with channel-level defaults by sub-key
+ * (see `mergeGatewayCapabilitiesConfig`); both default to all capabilities enabled.
+ */
+export function resolveGatewayCapabilityConfig(
+  cfg: OpenClawConfig,
+  accountId?: string,
+): ResolvedGatewayCapabilities {
+  const config = getConfig(cfg, accountId);
+  const gatewayCapabilities = config.gatewayCapabilities;
+  if (!gatewayCapabilities) {
+    return DEFAULT_GATEWAY_CAPABILITIES;
+  }
+  const tools = gatewayCapabilities.tools ?? {};
+  const docs = gatewayCapabilities.docs ?? {};
+  const send = gatewayCapabilities.send ?? {};
+  return {
+    docsEnabled: tools.docs !== false,
+    proactiveSendEnabled: tools.proactiveSend !== false,
+    allowedSpaceIds: docs.allowedSpaceIds,
+    allowedTargets: send.allowedTargets,
+  };
+}
+
+/**
+ * Check a docs RPC request against the configured capability gates.
+ * Returns null when allowed, or a human-readable denial reason.
+ *
+ * A configured allowlist is fail-closed: an empty list (possible only when
+ * config validation was bypassed) denies every docs RPC, and a request without
+ * a spaceId is denied as well because its doc space cannot be verified.
+ */
+export function checkDocsGatewayCapability(
+  caps: ResolvedGatewayCapabilities,
+  spaceId: string | undefined,
+): string | null {
+  if (!caps.docsEnabled) {
+    return DOCS_GATE_DISABLED_REASON;
+  }
+  if (caps.allowedSpaceIds) {
+    if (!spaceId) {
+      return "docs RPC denied: this request carries no spaceId while gatewayCapabilities.docs.allowedSpaceIds is configured (dingtalk.docs.append never carries a spaceId)";
+    }
+    if (!caps.allowedSpaceIds.includes(spaceId)) {
+      return "spaceId is not in gatewayCapabilities.docs.allowedSpaceIds allowlist";
+    }
+  }
+  return null;
+}
+
+/**
+ * Check a proactive-send RPC request against the configured capability gates.
+ * Returns null when allowed, or a human-readable denial reason.
+ *
+ * A configured allowlist is fail-closed: an empty list (possible only when
+ * config validation was bypassed) denies every proactive-send RPC.
+ */
+export function checkProactiveSendGatewayCapability(
+  caps: ResolvedGatewayCapabilities,
+  target: string,
+): string | null {
+  if (!caps.proactiveSendEnabled) {
+    return PROACTIVE_SEND_GATE_DISABLED_REASON;
+  }
+  if (caps.allowedTargets) {
+    if (!caps.allowedTargets.includes(target)) {
+      return "target is not in gatewayCapabilities.send.allowedTargets allowlist";
+    }
+  }
+  return null;
+}
+
 export async function resolveRuntimeConfig(
   config: DingTalkConfig,
   log?: { warn?: (message: string, data?: unknown) => void },
@@ -154,7 +303,10 @@ function hasOwn(obj: unknown, key: string): boolean {
   return typeof obj === "object" && obj !== null && Object.prototype.hasOwnProperty.call(obj, key);
 }
 
-function resolveAgentIdentityEmoji(cfg: OpenClawConfig, agentId?: string | null): string | undefined {
+function resolveAgentIdentityEmoji(
+  cfg: OpenClawConfig,
+  agentId?: string | null,
+): string | undefined {
   const targetAgentId = String(agentId || "").trim();
   if (!targetAgentId) {
     return undefined;
@@ -234,7 +386,6 @@ export function stripTargetPrefix(target: string): { targetId: string; isExplici
 
 const DEFAULT_ACCOUNT_ID = "default";
 
-
 /**
  * List all DingTalk account IDs from config
  */
@@ -326,10 +477,7 @@ export function resolveDingTalkAccount(
 
   const accountConfig = dingtalk?.accounts?.[id];
   if (accountConfig) {
-    const merged = mergeAccountWithDefaults(
-      dingtalk as DingTalkConfig,
-      accountConfig,
-    );
+    const merged = mergeAccountWithDefaults(dingtalk as DingTalkConfig, accountConfig);
     const publicMerged = stripRemovedLegacyFields(merged);
     return {
       ...publicMerged,

package/src/{device-registration.ts → platform/device-registration.ts}

@@ -1,4 +1,4 @@
-import httpClient from "./http-client.js";
+import httpClient from "../shared/http-client.js";
 
 // ── Constants ──────────────────────────────────────────────────────────────
 
@@ -52,7 +52,9 @@ async function apiPost(
   const errcode = data.errcode;
   if (errcode !== undefined && errcode !== 0) {
     const errmsg = asString(data.errmsg) || "unknown error";
-    throw new RegistrationError(`API error [${path}]: ${errmsg} (errcode=${typeof errcode === "number" ? errcode : asString(errcode)})`);
+    throw new RegistrationError(
+      `API error [${path}]: ${errmsg} (errcode=${typeof errcode === "number" ? errcode : asString(errcode)})`,
+    );
   }
   return data;
 }
@@ -137,8 +139,7 @@ export async function beginDeviceRegistration(): Promise<DeviceRegistrationSessi
     // Suppress unhandled rejection when abort fires outside Promise.race
     abortPromise?.catch(() => {});
 
-    const sleep = () =>
-      new Promise((resolve) => setTimeout(resolve, interval * 1000));
+    const sleep = () => new Promise((resolve) => setTimeout(resolve, interval * 1000));
 
     try {
       while (Date.now() < deadline) {

package/src/{onboarding.ts → platform/onboarding.ts}

@@ -7,10 +7,7 @@ import type {
 } from "openclaw/plugin-sdk/setup";
 import { DEFAULT_ACCOUNT_ID, formatDocsLink, normalizeAccountId } from "openclaw/plugin-sdk/setup";
 import { listDingTalkAccountIds, resolveDingTalkAccount } from "./config.js";
-import {
-  beginDeviceRegistration,
-  RegistrationError,
-} from "./device-registration.js";
+import { beginDeviceRegistration, RegistrationError } from "./device-registration.js";
 import {
   hasConfiguredSecretInput,
   normalizeSecretInputString,

package/src/{plugin-sdk-channel-actions-augment.ts → platform/plugin-sdk-channel-actions-augment.ts}

@@ -1,10 +1,11 @@
 import type { ChannelMessageActionAdapter } from "openclaw/plugin-sdk/channel-contract";
 
-type JsonResultReturn = NonNullable<ChannelMessageActionAdapter["handleAction"]> extends (
-  ...args: unknown[]
-) => Promise<infer TResult>
-  ? TResult
-  : never;
+type JsonResultReturn =
+  NonNullable<ChannelMessageActionAdapter["handleAction"]> extends (
+    ...args: unknown[]
+  ) => Promise<infer TResult>
+    ? TResult
+    : never;
 
 declare module "openclaw/plugin-sdk/channel-actions" {
   export function jsonResult(payload: unknown): JsonResultReturn;

package/src/platform/runtime-events.ts

@@ -0,0 +1,202 @@
+/**
+ * Cross-domain runtime agent-event infrastructure.
+ *
+ * Owns the generic OpenClaw `events.onAgentEvent` surface that several
+ * domains consume: event typing, reference-counted fan-out, field accessors,
+ * and run correlation. Domain owners (ack reactions, AI card task progress)
+ * build their own behavior on top of these primitives instead of importing
+ * each other's private modules.
+ */
+
+import { getErrorMessage } from "../shared/utils";
+
+export type RuntimeEventsLogger = {
+  debug?: (msg: string) => void;
+  info?: (msg: string) => void;
+  warn?: (msg: string) => void;
+};
+
+export type RuntimeAgentEvent = {
+  stream?: string;
+  runId?: string;
+  sessionKey?: string;
+  data?: {
+    phase?: string;
+    name?: string;
+    args?: unknown;
+    runId?: string;
+    sessionKey?: string;
+    toolCallId?: string;
+    meta?: {
+      runId?: string;
+      sessionKey?: string;
+    } | null;
+  };
+};
+
+export type RuntimeEventsSurface = {
+  onAgentEvent?: (listener: (event: unknown) => void) => () => void;
+};
+
+/**
+ * Fan one upstream `onAgentEvent` subscription out to multiple local consumers.
+ *
+ * The upstream subscription is reference-counted: it is created with the first
+ * local listener and released with the last one. Each listener is isolated so a
+ * throwing consumer can neither starve the remaining consumers nor bubble back
+ * into the host event emitter.
+ */
+export function createRuntimeEventsFanout(
+  upstream: RuntimeEventsSurface | undefined,
+  options: { log?: RuntimeEventsLogger } = {},
+): RuntimeEventsSurface {
+  const listeners = new Set<(event: unknown) => void>();
+  let unsubscribeUpstream: (() => void) | undefined;
+
+  const ensureUpstreamSubscription = () => {
+    if (unsubscribeUpstream || !upstream?.onAgentEvent) {
+      return;
+    }
+    unsubscribeUpstream = upstream.onAgentEvent((event: unknown) => {
+      // Dispatch against a snapshot so a listener that unsubscribes another
+      // listener during this event still receives the current event.
+      const currentListeners = Array.from(listeners);
+      for (const listener of currentListeners) {
+        try {
+          listener(event);
+        } catch (error: unknown) {
+          options.log?.warn?.(
+            `[DingTalk][RuntimeEvents] Listener failed: ${getErrorMessage(error)}`,
+          );
+        }
+      }
+    });
+  };
+
+  return {
+    onAgentEvent(listener: (event: unknown) => void) {
+      listeners.add(listener);
+      ensureUpstreamSubscription();
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0 && unsubscribeUpstream) {
+          unsubscribeUpstream();
+          unsubscribeUpstream = undefined;
+        }
+      };
+    },
+  };
+}
+
+function firstTrimmedString(...values: unknown[]): string | undefined {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return undefined;
+}
+
+export function getEventRunId(event: RuntimeAgentEvent | undefined): string | undefined {
+  return firstTrimmedString(event?.runId, event?.data?.runId, event?.data?.meta?.runId);
+}
+
+export function getEventSessionKey(event: RuntimeAgentEvent | undefined): string | undefined {
+  return firstTrimmedString(
+    event?.sessionKey,
+    event?.data?.sessionKey,
+    event?.data?.meta?.sessionKey,
+  );
+}
+
+export function describeEvent(event: RuntimeAgentEvent | undefined): string {
+  const stream = firstTrimmedString(event?.stream) || "-";
+  const phase = firstTrimmedString(event?.data?.phase) || "-";
+  const toolName = firstTrimmedString(event?.data?.name) || "-";
+  const toolCallId = firstTrimmedString(event?.data?.toolCallId) || "-";
+  return (
+    `stream=${stream} phase=${phase} runId=${getEventRunId(event) || "-"} ` +
+    `sessionKey=${getEventSessionKey(event) || "-"} toolCallId=${toolCallId} toolName=${toolName}`
+  );
+}
+
+/**
+ * Build a predicate that decides whether an agent event belongs to one reply.
+ *
+ * Correlation prefers an already captured `runId`; otherwise it accepts events
+ * whose `sessionKey` matches, and finally falls back to optimistically
+ * capturing the first session-less lifecycle start inside a short window.
+ *
+ * `consumer` labels the debug logs so two consumers sharing the same session
+ * (ack reactions and card task progress) stay distinguishable while triaging.
+ */
+export function createAgentEventCorrelator(params: {
+  /** Short label identifying the consuming domain in debug logs. */
+  consumer: string;
+  sessionKey: string;
+  enabled: boolean;
+  createdAt: number;
+  optimisticCaptureWindowMs: number;
+  log?: RuntimeEventsLogger;
+}) {
+  const logPrefix = `[DingTalk][AgentEventCorrelation][${params.consumer}]`;
+  let activeRunId: string | undefined;
+  let correlationUnavailableLogged = false;
+  let optimisticCaptureCount = 0;
+
+  return (event: RuntimeAgentEvent | undefined): boolean => {
+    const eventRunId = getEventRunId(event);
+    const eventSessionKey = getEventSessionKey(event);
+    const eventStream = firstTrimmedString(event?.stream) || "";
+    const eventPhase = firstTrimmedString(event?.data?.phase) || "";
+
+    if (activeRunId) {
+      const matched = eventRunId === activeRunId;
+      params.log?.debug?.(
+        `${logPrefix} correlation by runId matched=${matched} activeRunId=${activeRunId} ` +
+          `eventRunId=${eventRunId || "-"} eventSessionKey=${eventSessionKey || "-"}`,
+      );
+      return matched;
+    }
+
+    if (eventSessionKey === params.sessionKey) {
+      if (eventRunId) {
+        activeRunId = eventRunId;
+        params.log?.debug?.(
+          `${logPrefix} captured active runId=${activeRunId} from sessionKey=${params.sessionKey}`,
+        );
+      } else {
+        params.log?.debug?.(
+          `${logPrefix} correlated by sessionKey=${params.sessionKey} without runId`,
+        );
+      }
+      return true;
+    }
+
+    if (
+      optimisticCaptureCount === 0 &&
+      eventStream === "lifecycle" &&
+      eventPhase === "start" &&
+      eventRunId &&
+      !eventSessionKey &&
+      Date.now() - params.createdAt <= params.optimisticCaptureWindowMs
+    ) {
+      optimisticCaptureCount += 1;
+      activeRunId = eventRunId;
+      params.log?.debug?.(
+        `${logPrefix} optimistically captured active runId=${activeRunId} ` +
+          `from first lifecycle event without sessionKey windowMs=${params.optimisticCaptureWindowMs}`,
+      );
+      return true;
+    }
+
+    if (!correlationUnavailableLogged && params.enabled) {
+      correlationUnavailableLogged = true;
+      params.log?.debug?.(
+        `${logPrefix} ignored uncorrelated agent events; ` +
+          `reason=${getErrorMessage(eventRunId || eventSessionKey || "waiting for sessionKey/runId match")}`,
+      );
+    }
+    return false;
+  };
+}

package/src/{secret-input.ts → platform/secret-input.ts}

@@ -1,8 +1,10 @@
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import {
+  coerceSecretRef,
   hasConfiguredSecretInput as hasConfiguredOpenClawSecretInput,
   resolveConfiguredSecretInputString,
 } from "openclaw/plugin-sdk/secret-input-runtime";
+import { canResolveEnvSecretRefInReadOnlyPath } from "openclaw/plugin-sdk/secret-ref-readonly";
 import { z } from "zod";
 import { getDingTalkRuntime } from "./runtime";
 
@@ -28,6 +30,16 @@ type SecretInputLog = {
 const SECRET_INPUT_PROVIDER_PATTERN = /^[^:>]+$/;
 const SECRET_INPUT_ID_PATTERN = /^[^>]+$/;
 
+const SECRET_INPUT_PATH = "channels.dingtalk.clientSecret";
+
+function normalizeOptionalSecretString(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}
+
 function buildSecretInputFailure(
   value: SecretInputRef,
   reason: string,
@@ -40,6 +52,105 @@ function buildSecretInputFailure(
   };
 }
 
+/**
+ * Resolve one `env` SecretInput reference without handing the whole ambient
+ * environment to the host resolver.
+ *
+ * Mirrors the official channel pattern (`openclaw/plugin-sdk/secret-ref-readonly`):
+ * inspect the reference, require the host to authorize this provider/id for a
+ * read-only path, and only then read the single `process.env[id]`. The SDK's
+ * own `resolveReadOnlyEnvSecretRef` collapses "not authorized" and "authorized
+ * but the variable is unset" into one `blocked` status, which would tell an
+ * operator with a correct allowlist to change it; re-deriving the same checks
+ * here keeps the failure reason actionable. Both branches fail closed.
+ */
+function resolveEnvSecretInputRef(
+  value: SecretInputRef,
+  hostConfig: OpenClawConfig,
+): { value?: string; failure?: SecretInputResolutionFailure } {
+  const refLabel = `${value.source}:${value.provider}:${value.id}`;
+  const unresolved = (detail?: string) =>
+    buildSecretInputFailure(
+      value,
+      `${SECRET_INPUT_PATH} SecretRef is unresolved (${refLabel}).${detail ? ` ${detail}` : ""}`,
+    );
+
+  const ref = coerceSecretRef(value, hostConfig.secrets?.defaults);
+  if (!ref) {
+    return { failure: unresolved("SecretRef shape is not coercible.") };
+  }
+
+  if (ref.source !== "env") {
+    return {
+      failure: unresolved(
+        `Source "${ref.source}" is not usable from the DingTalk clientSecret env path.`,
+      ),
+    };
+  }
+
+  const providerConfig = hostConfig.secrets?.providers?.[ref.provider];
+  if (providerConfig && providerConfig.source !== "env") {
+    return {
+      failure: unresolved(
+        `Secret provider "${ref.provider}" has source "${providerConfig.source}" but the ref requests "env".`,
+      ),
+    };
+  }
+
+  if (
+    !canResolveEnvSecretRefInReadOnlyPath({
+      cfg: hostConfig,
+      provider: ref.provider,
+      id: ref.id,
+    })
+  ) {
+    return {
+      failure: unresolved(
+        `Environment variable "${value.id}" is not authorized for a read-only path: ` +
+          `set secrets.providers.${value.provider}.source to "env" and include ` +
+          `"${value.id}" in its allowlist.`,
+      ),
+    };
+  }
+
+  const envValue = normalizeOptionalSecretString(process.env[ref.id]);
+  if (envValue) {
+    return { value: envValue };
+  }
+  return {
+    failure: unresolved(`Environment variable "${value.id}" is authorized but unset or empty.`),
+  };
+}
+
+/**
+ * Resolve a `file` SecretInput reference with a scoped resolver call.
+ *
+ * The explicit empty `env` means this branch never reads ambient credentials.
+ * It does not stop the host from expanding a configured provider path (for
+ * example a leading `~`) against its own environment.
+ */
+async function resolveFileSecretInputRef(
+  value: SecretInputRef,
+  hostConfig: OpenClawConfig,
+): Promise<{ value?: string; failure?: SecretInputResolutionFailure }> {
+  const resolved = await resolveConfiguredSecretInputString({
+    config: hostConfig,
+    env: {},
+    value,
+    path: SECRET_INPUT_PATH,
+    unresolvedReasonStyle: "detailed",
+  });
+  if (resolved.value) {
+    return { value: resolved.value };
+  }
+  return {
+    failure: buildSecretInputFailure(
+      value,
+      resolved.unresolvedRefReason || "secret reference is unresolved",
+    ),
+  };
+}
+
 export function formatSecretInputResolutionFailure(failure: SecretInputResolutionFailure): string {
   return `${failure.source}:${failure.provider}:${failure.id} - ${failure.reason}`;
 }
@@ -133,20 +244,15 @@ export async function resolveSecretInputStringWithFailure(
     }
   }
   try {
-    const resolved = await resolveConfiguredSecretInputString({
-      config: hostConfig,
-      env: process.env,
-      value,
-      path: "channels.dingtalk.clientSecret",
-      unresolvedReasonStyle: "detailed",
-    });
+    const resolved =
+      value.source === "env"
+        ? resolveEnvSecretInputRef(value, hostConfig)
+        : await resolveFileSecretInputRef(value, hostConfig);
     if (resolved.value) {
       return { value: resolved.value };
     }
-    const failure = buildSecretInputFailure(
-      value,
-      resolved.unresolvedRefReason || "secret reference is unresolved",
-    );
+    const failure =
+      resolved.failure ?? buildSecretInputFailure(value, "secret reference is unresolved");
     log?.warn?.("[DingTalk][SecretInput] Failed to resolve secret", {
       provider: value.provider,
       id: value.id,