@workclaw/openclaw-workclaw 1.0.16 → 1.0.18

package/src/media/upload.ts

@@ -1,43 +1,42 @@
-import { readFile, stat } from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+import { Agent, fetch as undiciFetch } from "undici";
 
 export function isLocalMediaSource(value: string): boolean {
-  const trimmed = value.trim()
+  const trimmed = value.trim();
   return (
-    trimmed.startsWith('/')
-    || trimmed.startsWith('./')
-    || trimmed.startsWith('../')
-    || trimmed.startsWith('~')
-    || trimmed.startsWith('file://')
-  )
+    trimmed.startsWith("/") ||
+    trimmed.startsWith("./") ||
+    trimmed.startsWith("../") ||
+    trimmed.startsWith("~") ||
+    trimmed.startsWith("file://")
+  );
 }
 
 export function resolveLocalPath(input: string): string {
-  if (input.startsWith('file://')) {
-    return fileURLToPath(input)
+  if (input.startsWith("file://")) {
+    return fileURLToPath(input);
   }
-  if (input.startsWith('~')) {
-    return path.join(os.homedir(), input.slice(1))
+  if (input.startsWith("~")) {
+    return path.join(os.homedir(), input.slice(1));
   }
-  return path.resolve(input)
+  return path.resolve(input);
 }
 
 function readResponseUrlPath(
   data: Record<string, unknown>,
   pathValue?: string,
 ): string | undefined {
-  if (!pathValue)
-    return undefined
-  const parts = pathValue.split('.').filter(Boolean)
-  let current: unknown = data
+  if (!pathValue) return undefined;
+  const parts = pathValue.split(".").filter(Boolean);
+  let current: unknown = data;
   for (const part of parts) {
-    if (!current || typeof current !== 'object')
-      return undefined
-    current = (current as Record<string, unknown>)[part]
+    if (!current || typeof current !== "object") return undefined;
+    current = (current as Record<string, unknown>)[part];
   }
-  return typeof current === 'string' ? current : undefined
+  return typeof current === "string" ? current : undefined;
 }
 
 function extractUploadedUrl(
@@ -45,110 +44,101 @@ function extractUploadedUrl(
   responseData: Record<string, unknown>,
   pathValue?: string,
 ): string | undefined {
-  const fromPath = readResponseUrlPath(responseData, pathValue)
-  if (fromPath)
-    return fromPath
-
-  const direct
-    = (responseData.url as string | undefined)
-      ?? (responseData.mediaUrl as string | undefined)
-  if (typeof direct === 'string' && direct.trim())
-    return direct
-
-  const dataObj = responseData.data
-  if (dataObj && typeof dataObj === 'object') {
-    const dataUrl = (dataObj as Record<string, unknown>).url
-    const dataMedia = (dataObj as Record<string, unknown>).mediaUrl
-    if (typeof dataUrl === 'string' && dataUrl.trim())
-      return dataUrl
-    if (typeof dataMedia === 'string' && dataMedia.trim())
-      return dataMedia
+  const fromPath = readResponseUrlPath(responseData, pathValue);
+  if (fromPath) return fromPath;
+
+  const direct =
+    (responseData.url as string | undefined) ??
+    (responseData.mediaUrl as string | undefined);
+  if (typeof direct === "string" && direct.trim()) return direct;
+
+  const dataObj = responseData.data;
+  if (dataObj && typeof dataObj === "object") {
+    const dataUrl = (dataObj as Record<string, unknown>).url;
+    const dataMedia = (dataObj as Record<string, unknown>).mediaUrl;
+    if (typeof dataUrl === "string" && dataUrl.trim()) return dataUrl;
+    if (typeof dataMedia === "string" && dataMedia.trim()) return dataMedia;
   }
 
-  const resultObj = responseData.result
-  if (resultObj && typeof resultObj === 'object') {
-    const resultUrl = (resultObj as Record<string, unknown>).url
-    const resultMedia = (resultObj as Record<string, unknown>).mediaUrl
-    if (typeof resultUrl === 'string' && resultUrl.trim())
-      return resultUrl
-    if (typeof resultMedia === 'string' && resultMedia.trim())
-      return resultMedia
+  const resultObj = responseData.result;
+  if (resultObj && typeof resultObj === "object") {
+    const resultUrl = (resultObj as Record<string, unknown>).url;
+    const resultMedia = (resultObj as Record<string, unknown>).mediaUrl;
+    if (typeof resultUrl === "string" && resultUrl.trim()) return resultUrl;
+    if (typeof resultMedia === "string" && resultMedia.trim()) return resultMedia;
   }
 
   if (responseText.trim() && /^https?:\/\//i.test(responseText.trim())) {
-    return responseText.trim()
+    return responseText.trim();
   }
-  return undefined
+  return undefined;
 }
 
 export interface UploadLocalMediaParams {
-  uploadUrl: string
-  filePath: string
-  uploadFieldName?: string
-  uploadHeaders?: Record<string, string>
-  uploadFormFields?: Record<string, string | number | boolean>
-  uploadResponseUrlPath?: string
-  requestTimeout: number
-  allowInsecureTls?: boolean
+  uploadUrl: string;
+  filePath: string;
+  uploadFieldName?: string;
+  uploadHeaders?: Record<string, string>;
+  uploadFormFields?: Record<string, string | number | boolean>;
+  uploadResponseUrlPath?: string;
+  requestTimeout: number;
+  allowInsecureTls?: boolean;
 }
 
 export async function uploadLocalMedia(params: UploadLocalMediaParams): Promise<string> {
-  const stats = await stat(params.filePath)
+  const stats = await stat(params.filePath);
   if (!stats.isFile()) {
-    throw new Error(`mediaUrl is not a file: ${params.filePath}`)
+    throw new Error(`mediaUrl is not a file: ${params.filePath}`);
   }
 
-  const content = await readFile(params.filePath)
-  const form = new FormData()
-  const fieldName = params.uploadFieldName?.trim() || 'file'
-  const fileName = path.basename(params.filePath)
-  form.set(fieldName, new Blob([content], { type: 'application/octet-stream' }), fileName)
+  const content = await readFile(params.filePath);
+  const form = new FormData();
+  const fieldName = params.uploadFieldName?.trim() || "file";
+  const fileName = path.basename(params.filePath);
+  form.set(fieldName, new Blob([content], { type: "application/octet-stream" }), fileName);
 
   if (params.uploadFormFields) {
     for (const [key, value] of Object.entries(params.uploadFormFields)) {
-      form.set(key, String(value))
+      form.set(key, String(value));
     }
   }
 
-  const controller = new AbortController()
-  const timeoutId = setTimeout(() => controller.abort(), params.requestTimeout)
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), params.requestTimeout);
 
-  let dispatcher: unknown
-  let doFetch: any = globalThis.fetch.bind(globalThis)
+  let dispatcher: unknown = undefined;
+  let doFetch: any = globalThis.fetch.bind(globalThis);
 
   if (params.allowInsecureTls) {
     try {
-      const { Agent, fetch: undiciFetchFn } = await import('undici')
-      dispatcher = new Agent({ connect: { rejectUnauthorized: false } })
-      doFetch = undiciFetchFn as any
-    }
-    catch (error) {
-      const message = error instanceof Error ? error.message : String(error)
-      throw new Error(`allowInsecureTls requires undici. ${message}`)
+      dispatcher = new Agent({ connect: { rejectUnauthorized: false } });
+      doFetch = undiciFetch as any;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`allowInsecureTls requires undici. ${message}`);
     }
   }
 
   try {
     const response = await doFetch(params.uploadUrl, {
-      method: 'POST',
+      method: "POST",
       headers: params.uploadHeaders ?? {},
       body: form,
       signal: controller.signal,
       ...(dispatcher ? { dispatcher } : {}),
-    })
+    });
 
-    const responseText = await response.text().catch(() => '')
+    const responseText = await response.text().catch(() => "");
     if (!response.ok) {
-      throw new Error(`Upload failed: ${response.status} ${responseText}`)
+      throw new Error(`Upload failed: ${response.status} ${responseText}`);
     }
 
-    let data: Record<string, unknown> = {}
+    let data: Record<string, unknown> = {};
     if (responseText) {
       try {
-        data = JSON.parse(responseText) as Record<string, unknown>
-      }
-      catch {
-        data = {}
+        data = JSON.parse(responseText) as Record<string, unknown>;
+      } catch {
+        data = {};
       }
     }
 
@@ -156,13 +146,12 @@ export async function uploadLocalMedia(params: UploadLocalMediaParams): Promise<
       responseText,
       data,
       params.uploadResponseUrlPath,
-    )
+    );
     if (!uploadedUrl) {
-      throw new Error('Upload response missing file URL')
+      throw new Error("Upload response missing file URL");
     }
-    return uploadedUrl
-  }
-  finally {
-    clearTimeout(timeoutId)
+    return uploadedUrl;
+  } finally {
+    clearTimeout(timeoutId);
   }
 }

package/src/outbound/index.ts

@@ -1,12 +1,13 @@
-import type { OpenClawConfig } from 'openclaw/plugin-sdk'
-import type { OpenclawWorkclawConfig, OpenclawWorkclawSendResult } from '../types.js'
-import { resolveAccountByUserIdAndAgentId, resolveOpenclawWorkclawAccount } from '../accounts.js'
-
-import { isLocalMediaSource, resolveLocalPath, uploadLocalMedia } from '../media/upload.js'
-import { getOpenclawWorkclawLogger } from '../runtime.js'
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import type { WorkclawSendResult, WorkclawConfig } from "../types.js";
+import { resolveWorkclawAccountWithCache } from "../accounts.js";
+import { resolveAccountByUserIdAndAgentId } from "../accounts.js";
+import { isLocalMediaSource, resolveLocalPath, uploadLocalMedia } from "../media/upload.js";
 import {
-  sendOpenclawWorkclawOutboundMessage,
-} from './workclaw-sender.js'
+  sendWorkclawOutboundMessage,
+} from "./workclaw-sender.js";
+import { getWorkclawLogger, setLastOutboundAt } from "../runtime.js";
+import { stat } from "node:fs/promises";
 
 /**
  * 根据 target (userId) 和可选的 agentId 查找匹配的账户
@@ -28,15 +29,15 @@ function findAccountIdByTarget(
   return undefined
 }
 
-export interface SendOpenclawWorkclawMessageParams {
-  cfg: OpenClawConfig
-  to: string
-  text: string
-  mediaUrl?: string
-  replyToMessageId?: string
-  accountId?: string
-  openConversationId?: string
-  agentId?: string | number
+export type SendWorkclawMessageParams = {
+  cfg: OpenClawConfig;
+  to: string;
+  text: string;
+  mediaUrl?: string;
+  replyToMessageId?: string;
+  accountId?: string;
+  openConversationId?: string;
+  agentId?: string | number;
   /**
    * 消息类型：
    * - "reply": 回复消息（用户触发）
@@ -49,7 +50,7 @@ export interface SendOpenclawWorkclawMessageParams {
 
 async function resolveMediaUrl(
   mediaUrl: string | undefined,
-  config: OpenclawWorkclawConfig,
+  config: WorkclawConfig,
 ): Promise<string | undefined> {
   if (!mediaUrl)
     return undefined
@@ -63,10 +64,9 @@ async function resolveMediaUrl(
 
   const filePath = resolveLocalPath(mediaUrl)
 
-  if (typeof config.mediaMaxMb === 'number' && config.mediaMaxMb > 0) {
-    const { stat } = await import('node:fs/promises')
-    const stats = await stat(filePath)
-    const maxBytes = config.mediaMaxMb * 1024 * 1024
+  if (typeof config.mediaMaxMb === "number" && config.mediaMaxMb > 0) {
+    const stats = await stat(filePath);
+    const maxBytes = config.mediaMaxMb * 1024 * 1024;
     if (stats.size > maxBytes) {
       throw new Error(`mediaUrl exceeds limit (${config.mediaMaxMb} MB)`)
     }
@@ -86,11 +86,11 @@ async function resolveMediaUrl(
   })
 }
 
-export async function sendMessageOpenclawWorkclaw(
-  params: SendOpenclawWorkclawMessageParams,
-): Promise<OpenclawWorkclawSendResult> {
-  const { cfg, to, text, mediaUrl, replyToMessageId, accountId, openConversationId, agentId, messageType, msgType, last }
-    = params
+export async function sendMessageWorkclaw(
+  params: SendWorkclawMessageParams,
+): Promise<WorkclawSendResult> {
+  const { cfg, to, text, mediaUrl, replyToMessageId, accountId, openConversationId, agentId, messageType, msgType, last } =
+    params;
 
   // 如果没有指定 messageType，根据是否有 replyToMessageId 来判断
   // - 有 replyToMessageId: 回复消息
@@ -106,30 +106,26 @@ export async function sendMessageOpenclawWorkclaw(
     }
   }
 
-  if (!resolvedAccountId) {
-    throw new Error('无法确定账户ID')
-  }
-
-  const account = resolveOpenclawWorkclawAccount({ cfg, accountId: resolvedAccountId })
+  const account = resolveWorkclawAccountWithCache({ cfg, accountId: resolvedAccountId });
   if (!account.configured) {
-    throw new Error(`OpenclawWorkclaw account "${account.accountId}" not configured`)
+    throw new Error(`Workclaw account "${account.accountId}" not configured`);
   }
 
   const resolvedMediaUrl = await resolveMediaUrl(mediaUrl, account.config)
 
   // 优先使用传入的 openConversationId，其次从 cfg 中直接读取（绕过 account.config 快照问题）
   // 这样可以获取到运行时动态保存的 openConversationId
-  interface ChannelWithAccounts { accounts?: Record<string, any>, openConversationId?: string }
-  const cfgChannel = (cfg.channels?.['openclaw-workclaw'] as unknown as ChannelWithAccounts) ?? {}
-  const cfgAccounts = cfgChannel.accounts ?? {}
-  const cfgAccount = cfgAccounts[resolvedAccountId] ?? {}
-  const cfgOpenConversationId = cfgAccount?.openConversationId ?? cfgChannel?.openConversationId
-  const effectiveOpenConversationId = openConversationId ?? cfgOpenConversationId
-  getOpenclawWorkclawLogger().info(`sendMessageOpenclawWorkclaw - resolvedAccountId: ${resolvedAccountId}, openConversationId param: ${openConversationId}, cfgOpenConversationId: ${cfgOpenConversationId}, effectiveOpenConversationId: ${effectiveOpenConversationId}, messageType: ${resolvedMessageType}, replyToMessageId: ${replyToMessageId}`)
+  type ChannelWithAccounts = { accounts?: Record<string, any>; openConversationId?: string };
+  const cfgChannel = (cfg.channels?.['openclaw-workclaw'] as unknown as ChannelWithAccounts) ?? {};
+  const cfgAccounts = cfgChannel.accounts ?? {};
+  const cfgAccount = cfgAccounts[resolvedAccountId] ?? {};
+  const cfgOpenConversationId = cfgAccount?.openConversationId ?? cfgChannel?.openConversationId;
+  const effectiveOpenConversationId = openConversationId ?? cfgOpenConversationId;
+  getWorkclawLogger().info(`sendMessageWorkclaw - resolvedAccountId: ${resolvedAccountId}, openConversationId param: ${openConversationId}, cfgOpenConversationId: ${cfgOpenConversationId}, effectiveOpenConversationId: ${effectiveOpenConversationId}, messageType: ${resolvedMessageType}, replyToMessageId: ${replyToMessageId}`);
 
   // 使用 appKey 作为缓存键，让所有账户共享同一个 token
-  const tokenCacheKey = account.config.appKey || account.accountId
-  const result = await sendOpenclawWorkclawOutboundMessage({
+  const tokenCacheKey = account.config.appKey || account.accountId;
+  const result = await sendWorkclawOutboundMessage({
     cacheKey: tokenCacheKey,
     to,
     text,
@@ -141,17 +137,23 @@ export async function sendMessageOpenclawWorkclaw(
     config: account.config,
     messageType: resolvedMessageType,
     last,
-  })
+  });
+
+  // 更新上次出站时间
+  if (resolvedAccountId) {
+    setLastOutboundAt(resolvedAccountId, Date.now());
+  }
+
   return {
     messageId: result.messageId,
     chatId: to,
   }
 }
 
-export async function getMessageOpenclawWorkclaw(_params: {
-  cfg: OpenClawConfig
-  messageId: string
-  accountId?: string
+export async function getMessageWorkclaw(_params: {
+  cfg: OpenClawConfig;
+  messageId: string;
+  accountId?: string;
 }): Promise<null> {
   return null
 }
@@ -160,10 +162,10 @@ export async function getMessageOpenclawWorkclaw(_params: {
  * 发送主动推送消息（定时任务使用）
  * 使用 pushEndpoint 配置的端口
  */
-export async function sendPushMessageOpenclawWorkclaw(
-  params: Omit<SendOpenclawWorkclawMessageParams, 'messageType'>,
-): Promise<OpenclawWorkclawSendResult> {
-  return sendMessageOpenclawWorkclaw({
+export async function sendPushMessageWorkclaw(
+  params: Omit<SendWorkclawMessageParams, "messageType">,
+): Promise<WorkclawSendResult> {
+  return sendMessageWorkclaw({
     ...params,
     messageType: 'push',
   })
@@ -173,10 +175,10 @@ export async function sendPushMessageOpenclawWorkclaw(
  * 发送回复消息（用户触发）
  * 使用 replyEndpoint 配置的端口
  */
-export async function sendReplyMessageOpenclawWorkclaw(
-  params: Omit<SendOpenclawWorkclawMessageParams, 'messageType'>,
-): Promise<OpenclawWorkclawSendResult> {
-  return sendMessageOpenclawWorkclaw({
+export async function sendReplyMessageWorkclaw(
+  params: Omit<SendWorkclawMessageParams, "messageType">,
+): Promise<WorkclawSendResult> {
+  return sendMessageWorkclaw({
     ...params,
     messageType: 'reply',
   })