@insta-dev01/intclaw 1.0.11 → 1.1.0

package/src/services/media/chunk-upload.ts

@@ -0,0 +1,293 @@
+/**
+ * IntClaw文件分块上传模块
+ * 支持大文件（>20MB）的分块上传
+ * 
+ * API 文档：
+ * - 开启事务：https://open.intclaw.com/document/development/enable-upload-transaction
+ * - 上传块：https://open.intclaw.com/document/development/upload-file-blocks
+ * - 提交事务：https://open.intclaw.com/document/development/submit-a-file-upload-transaction
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { createLogger } from '../../utils/logger.ts';
+import { intclawOapiHttp, intclawUploadHttp } from '../../utils/http-client.ts';
+import { INTCLAW_CONFIG } from '../../../config.ts';
+
+const INTCLAW_OAPI = INTCLAW_CONFIG.OAPI_BASE_URL;
+
+/** 分块上传配置 */
+export const CHUNK_CONFIG = {
+  MIN_CHUNK_SIZE: 100 * 1024, // 最小分块 100KB
+  MAX_CHUNK_SIZE: 8 * 1024 * 1024, // 最大分块 8MB
+  DEFAULT_CHUNK_SIZE: 5 * 1024 * 1024, // 默认分块 5MB
+  SIZE_THRESHOLD: 20 * 1024 * 1024, // 超过 20MB 使用分块上传
+};
+
+/** 开启上传事务响应 */
+interface UploadTransactionResponse {
+  errcode: number;
+  errmsg: string;
+  upload_id: string;
+}
+
+/** 上传文件块响应 */
+interface UploadBlockResponse {
+  errcode: number;
+  errmsg: string;
+}
+
+/** 提交上传事务响应 */
+interface SubmitTransactionResponse {
+  errcode: number;
+  errmsg: string;
+  file_id?: string;
+  download_code?: string;
+}
+
+/**
+ * 步骤一：开启分块上传事务
+ * @param oapiToken IntClaw access_token
+ * @param fileName 文件名
+ * @param fileSize 文件大小（字节）
+ * @param log 日志对象
+ */
+export async function enableUploadTransaction(
+  oapiToken: string,
+  fileName: string,
+  fileSize: number,
+  debug: boolean = false,
+): Promise<string | null> {
+  const log = createLogger(debug, 'IntClaw][ChunkUpload');
+  
+  try {
+    log.info(`开启上传事务：${fileName}, 大小：${(fileSize / 1024 / 1024).toFixed(2)}MB`);
+
+    const resp = await intclawOapiHttp.get<UploadTransactionResponse>(
+      `${INTCLAW_OAPI}/file/upload/transaction/enable`,
+      {
+        params: {
+          access_token: oapiToken,
+          file_name: fileName,
+          file_size: fileSize,
+        },
+        timeout: 30_000,
+      }
+    );
+
+    if (resp.data.errcode === 0) {
+      log.info(`事务开启成功，upload_id: ${resp.data.upload_id}`);
+      return resp.data.upload_id;
+    } else {
+      log.error(`开启事务失败：${resp.data.errmsg}`);
+      return null;
+    }
+  } catch (err: any) {
+    log.error(`开启事务异常：${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * 步骤二：上传文件块
+ * @param oapiToken IntClaw access_token
+ * @param uploadId 上传事务 ID
+ * @param chunkData 文件块数据
+ * @param chunkNumber 块编号（从 1 开始）
+ * @param totalChunks 总块数
+ * @param log 日志对象
+ */
+export async function uploadFileBlock(
+  oapiToken: string,
+  uploadId: string,
+  chunkData: Buffer,
+  chunkNumber: number,
+  totalChunks: number,
+  debug: boolean = false,
+): Promise<boolean> {
+  const log = createLogger(debug, 'IntClaw][ChunkUpload');
+  
+  try {
+    log.info(`上传块 ${chunkNumber}/${totalChunks}, 大小：${(chunkData.length / 1024).toFixed(2)}KB`);
+
+    const FormData = (await import('form-data')).default;
+    const form = new FormData();
+    form.append('upload_id', uploadId);
+    form.append('chunk_number', chunkNumber.toString());
+    form.append('total_chunks', totalChunks.toString());
+    form.append('file', chunkData, {
+      filename: `chunk_${chunkNumber}`,
+      contentType: 'application/octet-stream',
+    });
+
+    const resp = await intclawUploadHttp.post<UploadBlockResponse>(
+      `${INTCLAW_OAPI}/file/upload/chunk`,
+      form,
+      {
+        params: { access_token: oapiToken },
+        headers: form.getHeaders(),
+        timeout: 60_000,
+        maxBodyLength: Infinity,
+      }
+    );
+
+    if (resp.data.errcode === 0) {
+      log.info(`块 ${chunkNumber} 上传成功`);
+      return true;
+    } else {
+      log.error(`块 ${chunkNumber} 上传失败：${resp.data.errmsg}`);
+      return false;
+    }
+  } catch (err: any) {
+    log.error(`块 ${chunkNumber} 上传异常：${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * 步骤三：提交分块上传事务
+ * @param oapiToken IntClaw access_token
+ * @param uploadId 上传事务 ID
+ * @param fileName 文件名
+ * @param log 日志对象
+ */
+export async function submitUploadTransaction(
+  oapiToken: string,
+  uploadId: string,
+  fileName: string,
+  debug: boolean = false,
+): Promise<{ fileId?: string; downloadCode?: string } | null> {
+  const log = createLogger(debug, 'IntClaw][ChunkUpload');
+  
+  try {
+    log.info(`提交上传事务：${uploadId}`);
+
+    const resp = await intclawOapiHttp.get<SubmitTransactionResponse>(
+      `${INTCLAW_OAPI}/file/upload/transaction/submit`,
+      {
+        params: {
+          access_token: oapiToken,
+          upload_id: uploadId,
+          file_name: fileName,
+        },
+        timeout: 60_000,
+      }
+    );
+
+    if (resp.data.errcode === 0) {
+      log.info(`事务提交成功，file_id: ${resp.data.file_id}, download_code: ${resp.data.download_code}`);
+      return {
+        fileId: resp.data.file_id,
+        downloadCode: resp.data.download_code,
+      };
+    } else {
+      log.error(`事务提交失败：${resp.data.errmsg}`);
+      return null;
+    }
+  } catch (err: any) {
+    log.error(`事务提交异常：${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * 计算分块参数
+ */
+function calculateChunkParams(fileSize: number): { chunkSize: number; totalChunks: number } {
+  // 根据文件大小动态调整分块大小
+  let chunkSize = CHUNK_CONFIG.DEFAULT_CHUNK_SIZE;
+  
+  if (fileSize > 100 * 1024 * 1024) {
+    // >100MB，使用最大分块 8MB
+    chunkSize = CHUNK_CONFIG.MAX_CHUNK_SIZE;
+  } else if (fileSize > 50 * 1024 * 1024) {
+    // >50MB，使用 6MB 分块
+    chunkSize = 6 * 1024 * 1024;
+  }
+  
+  const totalChunks = Math.ceil(fileSize / chunkSize);
+  return { chunkSize, totalChunks };
+}
+
+/**
+ * 分块上传大文件（>20MB）
+ * @param filePath 文件路径
+ * @param mediaType 媒体类型：video, file
+ * @param oapiToken IntClaw access_token
+ * @param log 日志对象
+ * @returns download_code 或 null
+ */
+export async function uploadLargeFileByChunks(
+  filePath: string,
+  mediaType: 'video' | 'file',
+  oapiToken: string,
+  debug: boolean = false,
+): Promise<string | null> {
+  const log = createLogger(debug, 'IntClaw][ChunkUpload');
+  
+  try {
+    const absPath = path.resolve(filePath);
+    if (!fs.existsSync(absPath)) {
+      log.warn(`文件不存在：${absPath}`);
+      return null;
+    }
+
+    const stats = fs.statSync(absPath);
+    const fileSize = stats.size;
+    const fileName = path.basename(absPath);
+    const fileSizeMB = (fileSize / 1024 / 1024).toFixed(2);
+
+    log.info(`开始分块上传：${fileName}, 大小：${fileSizeMB}MB, 类型：${mediaType}`);
+
+    // 步骤一：开启上传事务
+    const uploadId = await enableUploadTransaction(oapiToken, fileName, fileSize, debug);
+    if (!uploadId) {
+      log.error(`开启事务失败，终止上传`);
+      return null;
+    }
+
+    // 计算分块参数
+    const { chunkSize, totalChunks } = calculateChunkParams(fileSize);
+    log.info(`分块参数：chunkSize=${(chunkSize / 1024 / 1024).toFixed(2)}MB, totalChunks=${totalChunks}`);
+
+    // 步骤二：分块上传
+    const fileBuffer = fs.readFileSync(absPath);
+    let successCount = 0;
+
+    for (let i = 0; i < totalChunks; i++) {
+      const start = i * chunkSize;
+      const end = Math.min(start + chunkSize, fileSize);
+      const chunkData = fileBuffer.slice(start, end);
+
+      const success = await uploadFileBlock(
+        oapiToken,
+        uploadId,
+        chunkData,
+        i + 1, // chunkNumber 从 1 开始
+        totalChunks,
+        debug
+      );
+
+      if (!success) {
+        log.error(`块 ${i + 1} 上传失败，终止上传`);
+        return null;
+      }
+
+      successCount++;
+      log.info(`进度：${successCount}/${totalChunks} (${((successCount / totalChunks) * 100).toFixed(1)}%)`);
+    }
+
+    // 步骤三：提交上传事务
+    const result = await submitUploadTransaction(oapiToken, uploadId, fileName, debug);
+    if (!result || !result.downloadCode) {
+      log.error(`提交事务失败`);
+      return null;
+    }
+
+    log.info(`分块上传完成：${fileName}, download_code: ${result.downloadCode}`);
+    return result.downloadCode;
+  } catch (err: any) {
+    log.error(`分块上传异常：${err.message}`);
+    return null;
+  }
+}

package/src/services/media/common.ts

@@ -0,0 +1,154 @@
+/**
+ * 媒体处理公共工具和常量
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { createLogger } from '../../utils/logger.ts';
+import { CHUNK_CONFIG } from './chunk-upload.ts';
+import { intclawOapiHttp, intclawUploadHttp } from '../../utils/http-client.ts';
+import { INTCLAW_CONFIG } from '../../../config.ts';
+
+// ============ 常量 ============
+
+/** 文本文件扩展名 */
+export const TEXT_FILE_EXTENSIONS = new Set([
+  '.txt', '.md', '.json', '.yaml', '.yml', '.xml', '.html', '.css',
+  '.js', '.ts', '.py', '.java', '.c', '.cpp', '.h', '.sh', '.bat', '.csv',
+]);
+
+/** 图片文件扩展名 */
+export const IMAGE_EXTENSIONS = /\.(png|jpg|jpeg|gif|bmp|webp|tiff|svg)$/i;
+
+/** 本地图片路径正则表达式（跨平台） */
+export const LOCAL_IMAGE_RE =
+  /!\[([^\]]*)\]\(((?:file:\/\/|MEDIA:|attachment:\/\/)[^)]+|\/(?:tmp|var|private|Users|home|root)[^)]+|[A-Za-z]:[\\/][^)]+)\)/g;
+
+/** 纯文本图片路径正则表达式 */
+export const BARE_IMAGE_PATH_RE =
+  /`?((?:\/(?:tmp|var|private|Users|home|root)\/[^\s`'",)]+|[A-Za-z]:[\\/][^\s`'",)]+)\.(?:png|jpg|jpeg|gif|bmp|webp))`?/gi;
+
+/** 视频标记正则表达式 */
+export const VIDEO_MARKER_PATTERN = /\[INTCLAW_VIDEO\](.*?)\[\/INTCLAW_VIDEO\]/gs;
+
+/** 音频标记正则表达式 */
+export const AUDIO_MARKER_PATTERN = /\[INTCLAW_AUDIO\](.*?)\[\/INTCLAW_AUDIO\]/gs;
+
+/** 文件标记正则表达式 */
+export const FILE_MARKER_PATTERN = /\[INTCLAW_FILE\](.*?)\[\/INTCLAW_FILE\]/gs;
+
+// ============ 工具函数 ============
+
+/**
+ * 去掉 file:// / MEDIA: / attachment:// 前缀，得到实际的绝对路径
+ */
+export function toLocalPath(raw: string): string {
+  let filePath = raw;
+  if (filePath.startsWith('file://')) filePath = filePath.replace('file://', '');
+  else if (filePath.startsWith('MEDIA:')) filePath = filePath.replace('MEDIA:', '');
+  else if (filePath.startsWith('attachment://')) filePath = filePath.replace('attachment://', '');
+
+  try {
+    filePath = decodeURIComponent(filePath);
+  } catch {
+    // 解码失败则保持原样
+  }
+  return filePath;
+}
+
+/**
+ * 通用媒体文件上传函数
+ */
+export async function uploadMediaToIntClaw(
+  filePath: string,
+  mediaType: 'image' | 'file' | 'video' | 'voice',
+  oapiToken: string,
+  maxSize: number = 20 * 1024 * 1024,
+  logOrDebug?: any,
+  debug?: boolean,
+): Promise<string | null> {
+  const debugEnabled =
+    typeof logOrDebug === 'boolean' ? logOrDebug === true : debug === true;
+  const externalLog = typeof logOrDebug === 'boolean' ? undefined : logOrDebug;
+  const log = externalLog ?? createLogger(debugEnabled, `IntClaw][${mediaType}`);
+  
+  log?.info?.(
+    `[uploadMediaToIntClaw] 开始上传，filePath: ${filePath}, mediaType: ${mediaType}, debug: ${debugEnabled}`,
+  );
+  
+  try {
+    const FormData = (await import('form-data')).default;
+
+    const absPath = toLocalPath(filePath);
+    log?.info?.(`检查文件是否存在：${absPath}`);
+    if (!fs.existsSync(absPath)) {
+      log?.warn?.(`文件不存在：${absPath}`);
+      return null;
+    }
+
+    const stats = fs.statSync(absPath);
+    const fileSizeMB = (stats.size / (1024 * 1024)).toFixed(2);
+    const fileSize = stats.size;
+
+    // ✅ 对于视频和文件类型，如果超过 20MB，使用分块上传
+    if ((mediaType === 'video' || mediaType === 'file') && fileSize > CHUNK_CONFIG.SIZE_THRESHOLD) {
+      log?.info?.(`文件超过 20MB，使用分块上传：${absPath} (${fileSizeMB}MB)`);
+      try {
+        const { uploadLargeFileByChunks } = await import('./chunk-upload.js');
+        const downloadCode = await uploadLargeFileByChunks(absPath, mediaType, oapiToken, debugEnabled);
+        if (downloadCode) {
+          log?.info?.(`分块上传成功：${absPath}, download_code: ${downloadCode}`);
+          return downloadCode;
+        }
+        log?.error?.(`分块上传失败：${absPath}`);
+      } catch (chunkErr: any) {
+        log?.error?.(`分块上传异常：${chunkErr.message}`);
+      }
+      return null;
+    }
+
+    // 检查文件大小（对于小于 20MB 的文件）
+    if (stats.size > maxSize) {
+      const maxSizeMB = (maxSize / (1024 * 1024)).toFixed(0);
+      log?.warn?.(
+        `文件过大：${absPath}, 大小：${fileSizeMB}MB, 超过限制 ${maxSizeMB}MB`,
+      );
+      return null;
+    }
+
+    const form = new FormData();
+    form.append('media', fs.createReadStream(absPath), {
+      filename: path.basename(absPath),
+      contentType: mediaType === 'image' ? 'image/jpeg' : 'application/octet-stream',
+    });
+
+    const uploadType = mediaType;
+
+    log?.info?.(`上传文件：${absPath} (${fileSizeMB}MB), uploadType=${uploadType}`);
+    const resp = await intclawUploadHttp.post(
+      `${INTCLAW_OAPI}/media/upload`,
+      form,
+      {
+        params: { access_token: oapiToken, type: mediaType },
+        headers: form.getHeaders(),
+        timeout: 60_000,
+        maxBodyLength: Infinity,
+      },
+    );
+
+    const mediaId = resp.data?.media_id;
+    if (mediaId) {
+      const cleanMediaId = mediaId.startsWith('@') ? mediaId.substring(1) : mediaId;
+      log?.info?.(`上传成功：mediaId=${cleanMediaId}`);
+      return cleanMediaId;
+    }
+    log?.warn?.(`上传返回无 media_id`);
+    return null;
+  } catch (err: any) {
+    log?.error?.(`上传失败：${err.message}`);
+    return null;
+  }
+}
+
+/** IntClaw OAPI 常量 */
+export const INTCLAW_OAPI = INTCLAW_CONFIG.OAPI_BASE_URL;

package/src/services/media/file.ts

@@ -0,0 +1,70 @@
+/**
+ * 文件处理模块
+ * 支持文档解析（docx, pdf, txt 等）和文件上传
+ */
+
+import * as fs from 'fs';
+import type { IntclawConfig } from '../../types/index.ts';
+import { FILE_MARKER_PATTERN, toLocalPath, uploadMediaToIntClaw, TEXT_FILE_EXTENSIONS } from './common.ts';
+
+/**
+ * 解析文档文件，提取文本内容
+ */
+export async function parseDocumentFile(filePath: string, log?: any): Promise<string | null> {
+  try {
+    const ext = '.' + filePath.split('.').pop()?.toLowerCase();
+    
+    if (!TEXT_FILE_EXTENSIONS.has(ext)) {
+      log?.warn?.(`[IntClaw][File] 不支持的文件类型：${ext}`);
+      return null;
+    }
+
+    const content = fs.readFileSync(filePath, 'utf-8');
+    log?.info?.(`[IntClaw][File] 解析文件成功：${filePath}, 长度=${content.length}`);
+    return content;
+  } catch (err: any) {
+    log?.error?.(`[IntClaw][File] 解析文件失败：${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * 提取文件标记并发送文件消息
+ */
+export async function processFileMarkers(
+  content: string,
+  sessionWebhook: string,
+  config: IntclawConfig,
+  oapiToken: string | null,
+  log?: any,
+  useProactiveApi: boolean = false,
+  target?: any,
+): Promise<string> {
+  const logPrefix = useProactiveApi ? '[IntClaw][File][Proactive]' : '[IntClaw][File]';
+
+  if (!oapiToken) {
+    log?.warn?.(`${logPrefix} 无 oapiToken，跳过文件处理`);
+    return content;
+  }
+
+  const matches = [...content.matchAll(FILE_MARKER_PATTERN)];
+  if (matches.length === 0) return content;
+
+  log?.info?.(`${logPrefix} 检测到 ${matches.length} 个文件，开始上传...`);
+
+  let result = content;
+  for (const match of matches) {
+    const full = match[0];
+    try {
+      const fileData = JSON.parse(match[1]);
+      const absPath = toLocalPath(fileData.path);
+      const uploadResult = await uploadMediaToIntClaw(absPath, 'file', oapiToken, 20 * 1024 * 1024, log);
+      result = result.replace(full, uploadResult ? `[文件已上传：${uploadResult.downloadUrl}]` : '⚠️ 文件上传失败');
+    } catch {
+      log?.warn?.(`${logPrefix} 解析文件标记失败：${match[1]}`);
+      result = result.replace(full, '');
+    }
+  }
+
+  return result;
+}

package/src/services/media/image.ts

@@ -0,0 +1,67 @@
+/**
+ * 图片处理模块
+ * 支持图片上传、本地路径处理
+ */
+
+import type { Logger } from 'openclaw/plugin-sdk';
+import {
+  LOCAL_IMAGE_RE,
+  BARE_IMAGE_PATH_RE,
+  toLocalPath,
+  uploadMediaToIntClaw,
+} from './common.ts';
+
+/**
+ * 扫描内容中的本地图片路径，上传到IntClaw并替换为 media_id
+ */
+export async function processLocalImages(
+  content: string,
+  oapiToken: string | null,
+  log?: Logger,
+): Promise<string> {
+  if (!oapiToken) {
+    log?.warn?.(`[IntClaw][Media] 无 oapiToken，跳过图片后处理`);
+    return content;
+  }
+
+  let result = content;
+
+  // 第一步：匹配 markdown 图片语法 ![alt](path)
+  const mdMatches = [...content.matchAll(LOCAL_IMAGE_RE)];
+  if (mdMatches.length > 0) {
+    log?.info?.(`[IntClaw][Media] 检测到 ${mdMatches.length} 个 markdown 图片，开始上传...`);
+    for (const match of mdMatches) {
+      const [fullMatch, alt, rawPath] = match;
+      const cleanPath = rawPath.replace(/\\ /g, ' ');
+      const uploadResult = await uploadMediaToIntClaw(cleanPath, 'image', oapiToken, 20 * 1024 * 1024, log);
+      if (uploadResult) {
+        result = result.replace(fullMatch, `![${alt}](${uploadResult.downloadUrl})`);
+      }
+    }
+  }
+
+  // 第二步：匹配纯文本中的本地图片路径
+  const bareMatches = [...result.matchAll(BARE_IMAGE_PATH_RE)];
+  const newBareMatches = bareMatches.filter((m) => {
+    if (m.index === undefined) return false;
+    const idx = m.index;
+    const before = result.slice(Math.max(0, idx - 10), idx);
+    return !before.includes('](');
+  });
+
+  if (newBareMatches.length > 0) {
+    log?.info?.(`[IntClaw][Media] 检测到 ${newBareMatches.length} 个纯文本图片路径，开始上传...`);
+    for (const match of newBareMatches.reverse()) {
+      const [fullMatch, rawPath] = match;
+      log?.info?.(`[IntClaw][Media] 纯文本图片："${fullMatch}" -> path="${rawPath}"`);
+      const uploadResult = await uploadMediaToIntClaw(rawPath, 'image', oapiToken, 20 * 1024 * 1024, log);
+      if (uploadResult) {
+        const replacement = `![](${uploadResult.downloadUrl})`;
+        result = result.slice(0, match.index!) + result.slice(match.index!).replace(fullMatch, replacement);
+        log?.info?.(`[IntClaw][Media] 替换纯文本路径为图片：${replacement}`);
+      }
+    }
+  }
+
+  return result;
+}

package/src/services/media/index.ts

@@ -0,0 +1,10 @@
+/**
+ * 媒体处理模块统一导出
+ */
+
+export * from './common.ts';
+export * from './image.ts';
+export * from './video.ts';
+export * from './audio.ts';
+export * from './file.ts';
+export * from './chunk-upload.ts';