aiconductor-cli 1.2.3 → 1.3.1

package/src/api.js

@@ -12,8 +12,10 @@ const DOUYIN_USER_VIDEOS_PATH = "/api/douyin_user_videos";
 const DOUYIN_USER_DETAIL_PATH = "/api/douyin_user_detail";
 const DOUYIN_USER_SEARCH_PATH = "/api/douyin_user_search";
 const DOUYIN_VIDEO_SEARCH_PATH = "/api/douyin_video_search";
-const DOUYIN_LINK_TO_TEXT_PATH = "/api/douyin_link_to_text_v2";
-const XHS_NOTE_PUBLISH_PATH = "/api/xhs_note_publish";
+const DOUYIN_LINK_TO_TEXT_PATH = "/api/douyin_link_to_text_v2";
+const XHS_NOTE_PUBLISH_PATH = "/api/xhs_note_publish";
+const R2_UPLOADER_PATH = "/api/r2_uploader";
+const MAX_R2_FILE_SIZE = 100 * 1024 * 1024;
 
 /**
  * 解析 API Key，三级优先级：命令行参数 > 系统环境变量 > .env 文件
@@ -73,21 +75,20 @@ function validateInt(value, name) {
  * @param {object} body
  * @returns {Promise<object>}
  */
-function httpPost(host, path, body, headers = {}) {
-  return new Promise((resolve, reject) => {
-    const data = JSON.stringify(body);
-
-    const options = {
-      hostname: host,
-      port: 443,
-      path: path,
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Content-Length": Buffer.byteLength(data),
-        ...headers,
-      },
-    };
+function httpPost(host, requestPath, body, headers = {}) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const options = {
+      hostname: host,
+      port: 443,
+      path: requestPath,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(data),
+        ...headers,
+      },
+    };
 
     const req = https.request(options, (res) => {
       let chunks = [];
@@ -118,10 +119,122 @@ function httpPost(host, path, body, headers = {}) {
       reject({ type: "network_error", message: err.message });
     });
 
-    req.write(data);
-    req.end();
-  });
-}
+    req.write(data);
+    req.end();
+  });
+}
+
+function contentTypeForFilename(filename) {
+  const types = {
+    ".avif": "image/avif",
+    ".bmp": "image/bmp",
+    ".gif": "image/gif",
+    ".heic": "image/heic",
+    ".heif": "image/heif",
+    ".jpeg": "image/jpeg",
+    ".jpg": "image/jpeg",
+    ".png": "image/png",
+    ".webp": "image/webp",
+    ".avi": "video/x-msvideo",
+    ".m4v": "video/x-m4v",
+    ".mkv": "video/x-matroska",
+    ".mov": "video/quicktime",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+  };
+  return types[path.extname(filename).toLowerCase()] || "application/octet-stream";
+}
+
+function contentTypeForBase64(value, fallback) {
+  const prefix = Buffer.from(value.replace(/\s/g, "").slice(0, 64), "base64");
+  if (prefix.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) {
+    return "image/png";
+  }
+  if (prefix[0] === 0xff && prefix[1] === 0xd8 && prefix[2] === 0xff) return "image/jpeg";
+  if (prefix.toString("ascii", 0, 2) === "BM") return "image/bmp";
+  if (prefix.toString("ascii", 0, 3) === "GIF") return "image/gif";
+  if (prefix.toString("ascii", 0, 4) === "RIFF" && prefix.toString("ascii", 8, 12) === "WEBP") {
+    return "image/webp";
+  }
+  if (prefix.toString("ascii", 0, 4) === "RIFF" && prefix.toString("ascii", 8, 11) === "AVI") {
+    return "video/x-msvideo";
+  }
+  if (prefix.toString("ascii", 4, 8) === "ftyp") {
+    const brand = prefix.toString("ascii", 8, 12);
+    if (["heic", "heix", "hevc", "hevx", "mif1", "msf1"].includes(brand)) return "image/heic";
+    if (["avif", "avis"].includes(brand)) return "image/avif";
+    return brand === "qt  " ? "video/quicktime" : "video/mp4";
+  }
+  if (prefix.subarray(0, 4).equals(Buffer.from([0x1a, 0x45, 0xdf, 0xa3]))) return "video/webm";
+  return fallback || "application/octet-stream";
+}
+
+/**
+ * 上传远程文件、本地文件或 Base64 内容到临时 R2。
+ * @param {string} apiKey
+ * @param {{ filePath?: string, fileUrl?: string, fileBase64?: string, filename?: string, defaultContentType?: string, validDays?: number }} params
+ * @returns {Promise<object>}
+ */
+async function r2Upload(apiKey, params) {
+  const sourceCount = [params.filePath, params.fileUrl, params.fileBase64]
+    .filter((value) => value !== undefined && value !== null).length;
+  if (sourceCount !== 1) {
+    throw Object.assign(new Error("filePath、fileUrl、fileBase64 必须且只能提供一个"), {
+      type: "validation_error",
+    });
+  }
+
+  const validDays = params.validDays === undefined ? 1 : Number(params.validDays);
+  if (validDays !== 1 && validDays !== 7) {
+    throw Object.assign(new Error(`validDays 仅支持 1 或 7，收到: ${params.validDays}`), {
+      type: "validation_error",
+    });
+  }
+
+  let fileBase64 = params.fileBase64;
+  let filename = params.filename;
+  if (params.filePath) {
+    const absolutePath = path.resolve(params.filePath);
+    let stat;
+    try {
+      stat = await fs.promises.stat(absolutePath);
+    } catch (err) {
+      throw Object.assign(new Error(`无法读取本地文件 ${absolutePath}: ${err.message}`), {
+        type: "validation_error",
+      });
+    }
+    if (!stat.isFile()) {
+      throw Object.assign(new Error(`本地路径不是文件: ${absolutePath}`), {
+        type: "validation_error",
+      });
+    }
+    if (stat.size > MAX_R2_FILE_SIZE) {
+      throw Object.assign(new Error(`本地文件超过 100MB: ${absolutePath}`), {
+        type: "validation_error",
+      });
+    }
+
+    const file = await fs.promises.readFile(absolutePath);
+    filename = params.filename || path.basename(absolutePath);
+    fileBase64 = `data:${contentTypeForFilename(filename)};base64,${file.toString("base64")}`;
+  } else if (fileBase64 && !/^data:/i.test(fileBase64)) {
+    const compactBase64 = fileBase64.replace(/\s/g, "");
+    fileBase64 = `data:${contentTypeForBase64(compactBase64, params.defaultContentType)};base64,${compactBase64}`;
+  }
+
+  const body = { valid_days: validDays };
+  if (params.fileUrl) body.file_url = params.fileUrl;
+  if (fileBase64) body.file_base64 = fileBase64;
+  if (filename) body.filename = filename;
+  const resp = await httpPost(API_HOST, R2_UPLOADER_PATH, body, {
+    Authorization: `Bearer ${apiKey}`,
+  });
+
+  if (!resp || resp.success === false || !resp.file_url) {
+    throw new Error(`R2 上传失败: ${resp?.message || "接口未返回 file_url"}`);
+  }
+  return stripBilling(resp);
+}
 
 /**
  * 发布 HTML 到线上
@@ -304,17 +417,16 @@ async function douyinLinkToText(apiKey, videoUrl) {
 /**
  * 小红书笔记发布 — 生成扫码发布 H5 页面与二维码
  * @param {string} apiKey
- * @param {{ type: string, title?: string, content?: string, images?: string[], video?: string, cover?: string, transferToOss?: boolean }} params
+ * @param {{ type: string, title?: string, content?: string, images?: string[], video?: string, cover?: string }} params
  * @returns {Promise<object>}
  */
 async function xhsNotePublish(apiKey, params) {
   const body = { type: params.type };
   if (params.title) body.title = params.title;
   if (params.content) body.content = params.content;
-  if (params.images && params.images.length > 0) body.images = params.images;
-  if (params.video) body.video = params.video;
-  if (params.cover) body.cover = params.cover;
-  if (params.transferToOss !== undefined) body.transfer_to_oss = params.transferToOss;
+  if (params.images && params.images.length > 0) body.images = params.images;
+  if (params.video) body.video = params.video;
+  if (params.cover) body.cover = params.cover;
 
   const resp = await httpPost(API_HOST, XHS_NOTE_PUBLISH_PATH, body, {
     Authorization: `Bearer ${apiKey}`,
@@ -332,7 +444,8 @@ module.exports = {
   douyinUserVideos,
   douyinUserDetail,
   douyinUserSearch,
-  douyinVideoSearch,
-  douyinLinkToText,
-  xhsNotePublish,
-};
+  douyinVideoSearch,
+  douyinLinkToText,
+  r2Upload,
+  xhsNotePublish,
+};

package/src/commands/xhs.js

@@ -1,6 +1,82 @@
-const { xhsNotePublish } = require("../api");
+const fs = require("fs");
+const path = require("path");
+const { r2Upload, xhsNotePublish } = require("../api");
 const { outputResult, resolveKeyOrExit, handleApiError } = require("../lib/cli-utils");
 
+const MAX_IMAGE_SIZE = 32 * 1024 * 1024;
+const MAX_UPLOAD_SIZE = 100 * 1024 * 1024;
+
+function validationError(message) {
+  return Object.assign(new Error(message), { type: "validation_error" });
+}
+
+function resolveBase64Input(value, label) {
+  if (!value.startsWith("@")) return value;
+  const filePath = path.resolve(value.slice(1));
+  let content;
+  try {
+    content = fs.readFileSync(filePath, "utf-8").trim();
+  } catch (err) {
+    throw validationError(`${label} Base64 文件读取失败 ${filePath}: ${err.message}`);
+  }
+  if (!content) throw validationError(`${label} Base64 文件内容为空: ${filePath}`);
+  return content;
+}
+
+function validateLocalFile(filePath, label, maxSize) {
+  const absolutePath = path.resolve(filePath);
+  let stat;
+  try {
+    stat = fs.statSync(absolutePath);
+  } catch (err) {
+    throw validationError(`${label}文件读取失败 ${absolutePath}: ${err.message}`);
+  }
+  if (!stat.isFile()) throw validationError(`${label}路径不是文件: ${absolutePath}`);
+  if (stat.size > maxSize) {
+    throw validationError(`${label}文件超过 ${maxSize / 1024 / 1024}MB: ${absolutePath}`);
+  }
+}
+
+function validateUrl(value, label) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch (_) {
+    throw validationError(`${label}不是有效 URL: ${value}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw validationError(`${label}仅支持 HTTP/HTTPS URL: ${value}`);
+  }
+}
+
+function validateBase64Size(value, label, maxSize) {
+  const dataUrlPrefix = value.match(/^data:[^,]*,/i)?.[0];
+  const payload = (dataUrlPrefix ? value.slice(dataUrlPrefix.length) : value).replace(/\s/g, "");
+  const padding = payload.endsWith("==") ? 2 : payload.endsWith("=") ? 1 : 0;
+  const size = Math.max(0, Math.floor(payload.length * 3 / 4) - padding);
+  if (size > maxSize) {
+    throw validationError(`${label} Base64 内容超过 ${maxSize / 1024 / 1024}MB`);
+  }
+}
+
+async function uploadMedia(apiKey, params, label) {
+  try {
+    const result = await r2Upload(apiKey, params);
+    return result.file_url;
+  } catch (err) {
+    const detail = err.type === "http_error"
+      ? `HTTP ${err.statusCode}: ${err.body?.message || JSON.stringify(err.body)}`
+      : err.message || err;
+    const wrapped = new Error(`${label}上传失败: ${detail}`);
+    wrapped.type = err.type === "validation_error" || err.type === "network_error"
+      ? err.type
+      : "api_error";
+    wrapped.statusCode = err.statusCode;
+    wrapped.body = err.body;
+    throw wrapped;
+  }
+}
+
 /**
  * text 格式输出：用 ✓ 开头展示关键信息
  */
@@ -12,7 +88,6 @@ function textFormatter(resp) {
   lines.push(`  H5 地址:  ${d.url}`);
   if (resp.message) lines.push(`  消息:     ${resp.message}`);
   if (d.qrcode) lines.push(`  二维码:   ${d.qrcode.substring(0, 50)}...`);
-  if (d.transfer_to_oss) lines.push(`  OSS转存:  是`);
   if (d.media) {
     if (d.media.images) lines.push(`  图片:     ${d.media.images.length} 张`);
     if (d.media.video) lines.push(`  视频:     ${d.media.video}`);
@@ -25,24 +100,119 @@ async function notePublishCommand(type, options = {}) {
   const format = options.format || "json";
   const apiKey = resolveKeyOrExit(options.apiKey, format);
 
-  // 解析 --images（逗号分隔的 URL 列表）
-  let images;
-  if (options.images) {
-    images = options.images.split(",").map((s) => s.trim()).filter(Boolean);
-  }
+  try {
+    if (type !== "normal" && type !== "video") {
+      throw validationError(`笔记类型仅支持 normal 或 video，收到: ${type}`);
+    }
 
-  // 解析 --transfer-to-oss（布尔标志）
-  const transferToOss = options.transferToOss !== undefined;
+    const imageUrls = options.images
+      ? options.images.split(",").map((value) => value.trim()).filter(Boolean)
+      : [];
+    const imageFiles = options.imageFile || [];
+    const imageBase64 = (options.imageBase64 || []).map((value, index) =>
+      resolveBase64Input(value, `第 ${imageUrls.length + imageFiles.length + index + 1} 张图片`)
+    );
+    const videoBase64 = options.videoBase64
+      ? resolveBase64Input(options.videoBase64, "视频")
+      : undefined;
+    const coverBase64 = options.coverBase64
+      ? resolveBase64Input(options.coverBase64, "视频封面")
+      : undefined;
+    const imageCount = imageUrls.length + imageFiles.length + imageBase64.length;
+    const videoSources = [options.video, options.videoFile, videoBase64].filter(Boolean);
+    const coverSources = [options.cover, options.coverFile, coverBase64].filter(Boolean);
+    const validDays = Number(options.uploadValidDays || 7);
+
+    if (validDays !== 1 && validDays !== 7) {
+      throw validationError(`--upload-valid-days 仅支持 1 或 7，收到: ${options.uploadValidDays}`);
+    }
+    if (type === "normal") {
+      if (videoSources.length > 0 || coverSources.length > 0) {
+        throw validationError("normal 类型不能使用视频或封面参数");
+      }
+      if (imageCount === 0) {
+        throw validationError("normal 类型至少需要一张图片，请使用 --images、--image-file 或 --image-base64");
+      }
+      if (imageCount > 18) {
+        throw validationError(`图片最多 18 张，当前共 ${imageCount} 张`);
+      }
+      imageUrls.forEach((url, index) => validateUrl(url, `第 ${index + 1} 张图片`));
+      imageFiles.forEach((filePath, index) => validateLocalFile(
+        filePath,
+        `第 ${imageUrls.length + index + 1} 张图片`,
+        MAX_IMAGE_SIZE
+      ));
+      imageBase64.forEach((value, index) => validateBase64Size(
+        value,
+        `第 ${imageUrls.length + imageFiles.length + index + 1} 张图片`,
+        MAX_IMAGE_SIZE
+      ));
+    } else {
+      if (imageCount > 0) {
+        throw validationError("video 类型不能使用图片参数");
+      }
+      if (videoSources.length !== 1) {
+        throw validationError("video 类型必须且只能使用 --video、--video-file、--video-base64 之一");
+      }
+      if (coverSources.length > 1) {
+        throw validationError("视频封面只能使用 --cover、--cover-file、--cover-base64 之一");
+      }
+      if (options.video) validateUrl(options.video, "视频");
+      if (options.videoFile) validateLocalFile(options.videoFile, "视频", MAX_UPLOAD_SIZE);
+      if (videoBase64) validateBase64Size(videoBase64, "视频", MAX_UPLOAD_SIZE);
+      if (options.cover) validateUrl(options.cover, "视频封面");
+      if (options.coverFile) validateLocalFile(options.coverFile, "视频封面", MAX_IMAGE_SIZE);
+      if (coverBase64) validateBase64Size(coverBase64, "视频封面", MAX_IMAGE_SIZE);
+    }
+
+    let images;
+    let video;
+    let cover;
+    if (type === "normal") {
+      const uploadedImages = await Promise.all([
+        ...imageFiles.map((filePath, index) => uploadMedia(
+          apiKey,
+          { filePath, validDays },
+          `第 ${imageUrls.length + index + 1} 张图片`
+        )),
+        ...imageBase64.map((fileBase64, index) => uploadMedia(
+          apiKey,
+          { fileBase64, defaultContentType: "image/jpeg", validDays },
+          `第 ${imageUrls.length + imageFiles.length + index + 1} 张图片`
+        )),
+      ]);
+      images = [...imageUrls, ...uploadedImages];
+    } else {
+      video = options.video;
+      if (options.videoFile) {
+        video = await uploadMedia(apiKey, { filePath: options.videoFile, validDays }, "视频");
+      } else if (videoBase64) {
+        video = await uploadMedia(
+          apiKey,
+          { fileBase64: videoBase64, defaultContentType: "video/mp4", validDays },
+          "视频"
+        );
+      }
+
+      cover = options.cover;
+      if (options.coverFile) {
+        cover = await uploadMedia(apiKey, { filePath: options.coverFile, validDays }, "视频封面");
+      } else if (coverBase64) {
+        cover = await uploadMedia(
+          apiKey,
+          { fileBase64: coverBase64, defaultContentType: "image/jpeg", validDays },
+          "视频封面"
+        );
+      }
+    }
 
-  try {
     const result = await xhsNotePublish(apiKey, {
       type,
       title: options.title,
       content: options.content,
       images,
-      video: options.video,
-      cover: options.cover,
-      transferToOss,
+      video,
+      cover,
     });
     outputResult(result, format, textFormatter);
     process.exit(0);

package/src/lib/cli-utils.js

@@ -60,6 +60,10 @@ function handleApiError(err, format) {
     );
   } else if (err.type === "network_error") {
     outputError({ message: `网络错误: ${err.message}` }, format);
+  } else if (err.type === "validation_error") {
+    outputError({ message: `参数错误: ${err.message}` }, format);
+  } else if (err.type === "api_error") {
+    outputError({ message: err.message }, format);
   } else {
     outputError({ message: `未知错误: ${err.message || err}` }, format);
   }