@soimy/dingtalk 3.6.0 → 3.6.1

package/src/secret-input.ts

@@ -0,0 +1,216 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { resolveRelativePath } from "./path-utils";
+
+export type SecretInputRef = {
+  source: "env" | "file" | "exec";
+  provider: string;
+  id: string;
+};
+
+export type SecretInput = string | SecretInputRef;
+
+export type SecretInputResolutionFailure = {
+  source: SecretInputRef["source"];
+  provider: string;
+  id: string;
+  reason: string;
+};
+
+export const SECRET_INPUT_EXEC_TIMEOUT_MS = 5000;
+
+type SecretInputLog = {
+  warn?: (message: string, data?: unknown) => void;
+};
+
+const execFileAsync = promisify(execFile);
+const SECRET_INPUT_PROVIDER_PATTERN = /^[^:>]+$/;
+const SECRET_INPUT_ID_PATTERN = /^[^>]+$/;
+
+function buildSecretInputFailure(
+  value: SecretInputRef,
+  reason: string,
+): SecretInputResolutionFailure {
+  return {
+    source: value.source,
+    provider: value.provider,
+    id: value.id,
+    reason,
+  };
+}
+
+export function formatSecretInputResolutionFailure(failure: SecretInputResolutionFailure): string {
+  return `${failure.source}:${failure.provider}:${failure.id} - ${failure.reason}`;
+}
+
+export function buildSecretInputSchema() {
+  return z.union([
+    z.string(),
+    z.object({
+      source: z.enum(["env", "file", "exec"]),
+      provider: z.string().min(1).max(1024).regex(SECRET_INPUT_PROVIDER_PATTERN),
+      id: z.string().min(1).max(1024).regex(SECRET_INPUT_ID_PATTERN),
+    }),
+  ]);
+}
+
+export function isSecretInputRef(value: unknown): value is SecretInputRef {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const ref = value as SecretInputRef;
+  return (
+    (ref.source === "env" || ref.source === "file" || ref.source === "exec") &&
+    typeof ref.provider === "string" &&
+    ref.provider.trim().length > 0 &&
+    SECRET_INPUT_PROVIDER_PATTERN.test(ref.provider) &&
+    typeof ref.id === "string" &&
+    ref.id.trim().length > 0 &&
+    SECRET_INPUT_ID_PATTERN.test(ref.id)
+  );
+}
+
+export function hasConfiguredSecretInput(value: unknown): boolean {
+  if (typeof value === "string") {
+    return value.trim().length > 0;
+  }
+  if (!isSecretInputRef(value)) {
+    return false;
+  }
+  if (value.source === "env") {
+    return Boolean(process.env[value.id]?.trim());
+  }
+  // file/exec references are considered configured when the reference shape is
+  // present. The actual filesystem/process lookup happens at runtime so status
+  // checks can stay side-effect free.
+  return true;
+}
+
+export function normalizeSecretInputString(value: unknown): string | undefined {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed || undefined;
+  }
+  if (!isSecretInputRef(value)) {
+    return undefined;
+  }
+  return `<${value.source}:${value.provider}:${value.id}>`;
+}
+
+export function parseSecretInputString(value: unknown): SecretInput | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  const match = trimmed.match(/^<(env|file|exec):([^:>]+):([^>]+)>$/);
+  if (!match) {
+    return trimmed;
+  }
+  return {
+    source: match[1] as SecretInputRef["source"],
+    provider: match[2],
+    id: match[3],
+  };
+}
+
+export async function resolveSecretInputString(
+  value: unknown,
+  log?: SecretInputLog,
+): Promise<string | undefined> {
+  return (await resolveSecretInputStringWithFailure(value, log)).value;
+}
+
+export async function resolveSecretInputStringWithFailure(
+  value: unknown,
+  log?: SecretInputLog,
+): Promise<{ value?: string; failure?: SecretInputResolutionFailure }> {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return { value: trimmed || undefined };
+  }
+  if (!isSecretInputRef(value)) {
+    return {};
+  }
+  if (value.source === "env") {
+    const envValue = process.env[value.id]?.trim();
+    if (envValue) {
+      return { value: envValue };
+    }
+    const failure = buildSecretInputFailure(value, "environment variable is not set or is empty");
+    log?.warn?.("[DingTalk][SecretInput] Failed to resolve env secret", {
+      provider: value.provider,
+      id: value.id,
+      error: failure.reason,
+    });
+    return { failure };
+  }
+  if (value.source === "file") {
+    try {
+      // Trust boundary: file SecretInput reads the configured local path. Use it
+      // only with trusted plugin configuration.
+      const filePath = resolveRelativePath(value.id);
+      const secret = (await readFile(filePath, "utf8")).trim();
+      if (secret) {
+        return { value: secret };
+      }
+      return { failure: buildSecretInputFailure(value, "file secret is empty") };
+    } catch (error) {
+      const failure = buildSecretInputFailure(
+        value,
+        error instanceof Error ? error.message : String(error),
+      );
+      log?.warn?.("[DingTalk][SecretInput] Failed to read file secret", {
+        provider: value.provider,
+        id: value.id,
+        error: failure.reason,
+      });
+      return { failure };
+    }
+  }
+  try {
+    // Trust boundary: exec SecretInput runs the configured provider binary with
+    // the secret id as its only argument. Use it only with trusted plugin
+    // configuration; execFile avoids shell interpolation but still executes the
+    // selected program.
+    const result = await execFileAsync(value.provider, [value.id], {
+      encoding: "utf8",
+      timeout: SECRET_INPUT_EXEC_TIMEOUT_MS,
+      windowsHide: true,
+    });
+    const secret = String(result.stdout).trim();
+    if (secret) {
+      return { value: secret };
+    }
+    return { failure: buildSecretInputFailure(value, "exec secret output is empty") };
+  } catch (error) {
+    const failure = buildSecretInputFailure(
+      value,
+      error instanceof Error ? error.message : String(error),
+    );
+    log?.warn?.("[DingTalk][SecretInput] Failed to resolve exec secret", {
+      provider: value.provider,
+      id: value.id,
+      error: failure.reason,
+    });
+    return { failure };
+  }
+}
+
+export async function resolveDingTalkSecretConfig<T extends { clientSecret?: unknown }>(
+  config: T,
+  log?: SecretInputLog,
+): Promise<
+  T & { clientSecret?: string; clientSecretResolutionFailure?: SecretInputResolutionFailure }
+> {
+  const resolvedSecret = await resolveSecretInputStringWithFailure(config.clientSecret, log);
+  return {
+    ...config,
+    clientSecret: resolvedSecret.value,
+    clientSecretResolutionFailure: resolvedSecret.failure,
+  };
+}

package/src/targeting/agent-routing.ts

@@ -158,11 +158,36 @@ export async function dispatchSubAgents(params: {
   const { matchedAgents, cfg, accountId, data, dingtalkConfig, sessionWebhook, extractedContent, handleMessage, downloadMedia: download, log } = params;
 
   // Pre-download media once to avoid duplication across sub-agents
-  let preDownloadedMedia: { mediaPath?: string; mediaType?: string } | undefined;
-  if (extractedContent.mediaPath && resolveRobotCode(dingtalkConfig)) {
-    const media = await download(dingtalkConfig, extractedContent.mediaPath, log);
-    if (media) {
-      preDownloadedMedia = { mediaPath: media.path, mediaType: media.mimeType };
+  let preDownloadedMedia: {
+    mediaPath?: string;
+    mediaType?: string;
+    mediaPaths?: string[];
+    mediaTypes?: string[];
+  } | undefined;
+  const robotCode = resolveRobotCode(dingtalkConfig);
+  if (robotCode) {
+    const downloadCodes =
+      extractedContent.mediaPaths && extractedContent.mediaPaths.length > 0
+        ? extractedContent.mediaPaths
+        : extractedContent.mediaPath
+          ? [extractedContent.mediaPath]
+          : [];
+    const mediaPaths: string[] = [];
+    const mediaTypes: string[] = [];
+    for (const downloadCode of downloadCodes) {
+      const media = await download(dingtalkConfig, downloadCode, log);
+      if (media) {
+        mediaPaths.push(media.path);
+        mediaTypes.push(media.mimeType);
+      }
+    }
+    if (mediaPaths.length > 0) {
+      preDownloadedMedia = {
+        mediaPath: mediaPaths[0],
+        mediaType: mediaTypes[0],
+        mediaPaths,
+        mediaTypes,
+      };
     }
   }
   let helperMissingWarningSent = false;

package/src/types.ts

@@ -9,16 +9,14 @@
  * - Session and token management
  */
 
-import type {
-  ChannelPlugin as SDKChannelPlugin,
-  OpenClawConfig,
-} from "openclaw/plugin-sdk/core";
 import type {
   ChannelAccountSnapshot as SDKChannelAccountSnapshot,
   ChannelGatewayContext as SDKChannelGatewayContext,
   ChannelLogSink as SDKChannelLogSink,
 } from "openclaw/plugin-sdk/channel-runtime";
+import type { ChannelPlugin as SDKChannelPlugin, OpenClawConfig } from "openclaw/plugin-sdk/core";
 import type { ChannelSetupWizard } from "openclaw/plugin-sdk/setup";
+import type { SecretInput } from "./secret-input";
 
 export type AckReactionMode = "off" | "emoji" | "kaomoji";
 // Accept arbitrary strings for backward compatibility; the recommended
@@ -32,7 +30,7 @@ export type ContextVisibilityMode = "all" | "allowlist" | "allowlist_quote";
  */
 export interface DingTalkConfig extends OpenClawConfig {
   clientId: string;
-  clientSecret: string;
+  clientSecret: SecretInput;
   name?: string;
   enabled?: boolean;
   dmPolicy?: "open" | "pairing" | "allowlist";
@@ -50,7 +48,10 @@ export interface DingTalkConfig extends OpenClawConfig {
   cardTemplateId?: string;
   /** @deprecated 已固定使用内置模板契约 */
   cardTemplateKey?: string;
-  groups?: Record<string, { systemPrompt?: string; requireMention?: boolean; groupAllowFrom?: string[] }>;
+  groups?: Record<
+    string,
+    { systemPrompt?: string; requireMention?: boolean; groupAllowFrom?: string[] }
+  >;
   accounts?: Record<string, DingTalkConfig>;
   // Connection robustness configuration
   maxConnectionAttempts?: number;
@@ -111,7 +112,7 @@ export interface DingTalkConfig extends OpenClawConfig {
 export interface DingTalkChannelConfig {
   enabled?: boolean;
   clientId: string;
-  clientSecret: string;
+  clientSecret: SecretInput;
   name?: string;
   dmPolicy?: "open" | "pairing" | "allowlist";
   groupPolicy?: "open" | "allowlist" | "disabled";
@@ -128,7 +129,10 @@ export interface DingTalkChannelConfig {
   cardTemplateId?: string;
   /** @deprecated 已固定使用内置模板契约 */
   cardTemplateKey?: string;
-  groups?: Record<string, { systemPrompt?: string; requireMention?: boolean; groupAllowFrom?: string[] }>;
+  groups?: Record<
+    string,
+    { systemPrompt?: string; requireMention?: boolean; groupAllowFrom?: string[] }
+  >;
   accounts?: Record<string, DingTalkConfig>;
   maxConnectionAttempts?: number;
   initialReconnectDelay?: number;
@@ -306,7 +310,12 @@ export interface DingTalkInboundMessage {
   sessionWebhook: string;
 }
 
-export type QuotedRefKey = "msgId" | "processQueryKey" | "messageId" | "outTrackId" | "cardInstanceId";
+export type QuotedRefKey =
+  | "msgId"
+  | "processQueryKey"
+  | "messageId"
+  | "outTrackId"
+  | "cardInstanceId";
 
 export type AttachmentTextSource = "text" | "html" | "pdf" | "docx";
 
@@ -468,6 +477,8 @@ export interface HandleDingTalkMessageParams {
   preDownloadedMedia?: {
     mediaPath?: string;
     mediaType?: string;
+    mediaPaths?: string[];
+    mediaTypes?: string[];
   };
 }
 
@@ -644,7 +655,9 @@ export interface DingTalkOutboundHandler {
   deliveryMode: "direct" | "queued" | "batch";
   resolveTarget: (params: ResolveTargetParams) => TargetResolutionResult;
   sendText: (params: SendTextParams) => Promise<{ ok: boolean; data?: unknown; error?: unknown }>;
-  sendMedia?: (params: SendMediaParams) => Promise<{ ok: boolean; data?: unknown; error?: unknown }>;
+  sendMedia?: (
+    params: SendMediaParams,
+  ) => Promise<{ ok: boolean; data?: unknown; error?: unknown }>;
 }
 
 /**
@@ -683,6 +696,8 @@ export interface AICardInstance {
   outTrackId?: string;
   /** Cumulative DingTalk API call count for this card instance. */
   dapiUsage?: number;
+  /** True after this card has successfully opened DingTalk's streaming lifecycle. */
+  streamLifecycleOpened?: boolean;
 }
 
 /**