maoda-commander-tt 0.0.12 → 0.0.16

package/dist/main.js

@@ -1823,7 +1823,7 @@ var PippitCommand = class extends BaseSubcommandHost {
 import { spawnSync } from "child_process";
 var GitBaseCommand = class extends BaseCommand {
   _configureArguments(cmd) {
-    cmd.argument("[msg]", "\u63D0\u4EA4\u6D88\u606F", "update");
+    cmd.argument("[msg]", "\u63D0\u4EA4\u6D88\u606F", "feat: update");
   }
   _configureOptions(cmd) {
     cmd.option("-n, --no-verify", "\u8DF3\u8FC7 git hook \u6821\u9A8C");
@@ -1854,7 +1854,10 @@ var GitBaseCommand = class extends BaseCommand {
       encoding: "utf8"
     });
     if (result.error) {
-      return makeError(1, `\u6267\u884C git ${args.join(" ")} \u5931\u8D25: ${result.error.message}`);
+      return makeError(
+        1,
+        `\u6267\u884C git ${args.join(" ")} \u5931\u8D25: ${result.error.message}`
+      );
     }
     if (result.status !== 0) {
       const signalText = result.signal ? `, signal: ${result.signal}` : "";
@@ -1936,10 +1939,7 @@ var GitBaseCommand = class extends BaseCommand {
     }
     if (result.status !== 0) {
       const signalText = result.signal ? `, signal: ${result.signal}` : "";
-      return this._makeError(
-        result.status ?? 1,
-        `\u6253\u5F00\u6D4F\u89C8\u5668\u5931\u8D25${signalText}`
-      );
+      return this._makeError(result.status ?? 1, `\u6253\u5F00\u6D4F\u89C8\u5668\u5931\u8D25${signalText}`);
     }
     return this._makeOk();
   }
@@ -2078,9 +2078,9 @@ var ShortcutBaseCommand = class extends BaseCommand {
       stdio: "inherit",
       shell: true
     });
-    return new Promise((resolve4) => {
+    return new Promise((resolve8) => {
       child.on("error", (error) => {
-        resolve4(
+        resolve8(
           this._makeError(
             1,
             `\u6267\u884C ${cmdLine} \u5931\u8D25: ${error.message}`
@@ -2089,11 +2089,11 @@ var ShortcutBaseCommand = class extends BaseCommand {
       });
       child.on("close", (code, signal) => {
         if (code === 0) {
-          resolve4(this._makeOk());
+          resolve8(this._makeOk());
           return;
         }
         const signalText = signal ? `, signal: ${signal}` : "";
-        resolve4(
+        resolve8(
           this._makeError(
             code ?? 1,
             `\u6267\u884C ${cmdLine} \u5931\u8D25${signalText}`
@@ -2170,9 +2170,9 @@ var AiBaseCommand = class extends BaseCommand {
       cwd: process.cwd(),
       stdio: "inherit"
     });
-    return new Promise((resolve4) => {
+    return new Promise((resolve8) => {
       child.on("error", (error) => {
-        resolve4(
+        resolve8(
           this._makeError(
             1,
             `\u6267\u884C ${command} ${args.join(" ")} \u5931\u8D25: ${error.message}`
@@ -2181,11 +2181,11 @@ var AiBaseCommand = class extends BaseCommand {
       });
       child.on("close", (code, signal) => {
         if (code === 0) {
-          resolve4(this._makeOk());
+          resolve8(this._makeOk());
           return;
         }
         const signalText = signal ? `, signal: ${signal}` : "";
-        resolve4(
+        resolve8(
           this._makeError(
             code ?? 1,
             `\u6267\u884C ${command} ${args.join(" ")} \u5931\u8D25${signalText}`
@@ -2196,6 +2196,10 @@ var AiBaseCommand = class extends BaseCommand {
   }
 };
 
+// src/constants/ak.ts
+var ARK_AK = "6990de07-83be-487d-930d-f5dd3b6d5993";
+var OPENROUTER_AK = "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";
+
 // src/commands/ai/ai-websearch-command.ts
 var AiWebSearchCommand = class extends AiBaseCommand {
   _meta() {
@@ -2213,7 +2217,7 @@ var AiWebSearchCommand = class extends AiBaseCommand {
       return this._makeError(1, "\u8BF7\u8F93\u5165\u641C\u7D22\u5185\u5BB9");
     }
     const url = "https://ark.cn-beijing.volces.com/api/v3/responses";
-    const token = "45442605-446b-4184-aac4-9d577aa1764c";
+    const token = ARK_AK;
     const response = await fetch(url, {
       method: "POST",
       headers: {
@@ -2423,7 +2427,7 @@ var AiRunCommand = class extends AiBaseCommand {
   }
   _createSystemReminder(referenceDir) {
     return `<system-reminder>
-\u53C2\u8003\u6587\u4EF6\u8DEF\u5F84 ${referenceDir} \u6587\u4EF6\u5939\u7684\u5185\u5BB9\uFF0C\u6267\u884C\u7528\u6237\u7684\u8981\u6C42\uFF0C\u82E5\u975E\u7528\u6237\u660E\u786E\u8981\u6C42\uFF0C\u4E0D\u8981\u5BF9\u8BE5\u6587\u4EF6\u5939\u7684\u5185\u5BB9\u8FDB\u884C\u4FEE\u6539\uFF0C\u800C\u662F\u67E5\u9605\u91CC\u9762\u7684\u5185\u5BB9\u4F5C\u4E3A\u4E0A\u4E0B\u6587\u8865\u5145\u6BD4\u5982\u4F5C\u4E3A\u4FE1\u606F\u53C2\u8003\uFF0C\u6216\u8005\u6267\u884C\u6307\u5F15\uFF1B
+\u53C2\u8003\u6587\u4EF6\u8DEF\u5F84 ${referenceDir} \u4E0B\uFF0C\u6587\u4EF6\u5939\u91CC\u7684\u5185\u5BB9\uFF0C\u6267\u884C\u7528\u6237\u7684\u8981\u6C42\uFF0C\u82E5\u975E\u7528\u6237\u660E\u786E\u8981\u6C42\uFF0C\u4E0D\u8981\u5BF9\u8BE5\u6587\u4EF6\u5939\u7684\u5185\u5BB9\u8FDB\u884C\u4FEE\u6539\uFF0C\u800C\u662F\u67E5\u9605\u91CC\u9762\u7684\u5185\u5BB9\u4F5C\u4E3A\u4E0A\u4E0B\u6587\u8865\u5145\u6BD4\u5982\u4F5C\u4E3A\u4FE1\u606F\u53C2\u8003\uFF0C\u6216\u8005\u6267\u884C\u6307\u5F15\uFF1B
 \u5982\u679C user_prompt \u91CC\uFF0C\u7ED9\u51FA\u4E00\u4E9B\u6587\u4EF6\u8DEF\u5F84\uFF0C\u9ED8\u8BA4\u662F\u5F53\u524D\u6267\u884C\u547D\u4EE4\u8DEF\u5F84 (cwd) \u4E0B\u7684\u6587\u4EF6\uFF0C\u63D0\u4F9B\u7684\u662F\u672C\u6B21\u8981\u6C42\u7684\u8BE6\u7EC6\u6307\u4EE4\u6216\u8005\u91CD\u8981\u7684\u53C2\u8003\u4FE1\u606F
 \u82E5\u7528\u6237\u672A\u63D0\u53CA\u4EFB\u4F55\u6587\u4EF6\u548C\u76EE\u5F55\uFF0C\u4F60\u65E0\u9700\u8BFB\u53D6\u547D\u4EE4\u6267\u884C\u76EE\u5F55\u4E0B\u7684\u4EFB\u4F55\u5185\u5BB9\uFF0C\u53EA\u9700\u5728\u53C2\u8003\u6587\u4EF6\u8DEF\u5F84\u4E0B\u641C\u7D22\u76F8\u5173\u7684\u4FE1\u606F\u5373\u53EF
 \u6700\u540E\u7ED9\u51FA\u7684\u7528\u6237\u56DE\u590D\uFF0C\u65E0\u9700\u5F15\u7528\u53C2\u8003\u6587\u4EF6\u76EE\u5F55\u4E0B\u7684\u5177\u4F53\u6587\u4EF6\uFF0C\u56E0\u4E3A\u7528\u6237\u4E0D\u4F1A\u53BB\u770B\u5BF9\u5E94\u7684\u6587\u4EF6\uFF0C\u800C\u4E14\u8FD9\u4E5F\u662F\u5185\u90E8\u79C1\u6709\u4FE1\u606F
@@ -2433,6 +2437,1210 @@ user_prompt:
   }
 };
 
+// src/commands/ai/ai-image-command.ts
+import * as fs6 from "fs/promises";
+import * as path7 from "path";
+import { Option as Option8 } from "commander";
+
+// src/commands/ai/ai-image-reference.ts
+import * as fs5 from "fs/promises";
+import * as os2 from "os";
+import * as path6 from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var MAX_REFERENCE_IMAGE_BYTES = 2 * 1024 * 1024;
+var MAX_REFERENCE_IMAGE_COUNT = 14;
+var API_SUPPORTED_MIME_TYPES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/webp",
+  "image/bmp",
+  "image/tiff",
+  "image/gif"
+]);
+async function prepareReferenceImages(filePaths) {
+  if (filePaths.length > MAX_REFERENCE_IMAGE_COUNT) {
+    return makeError(
+      1,
+      `\u53C2\u8003\u56FE\u6700\u591A\u652F\u6301 ${MAX_REFERENCE_IMAGE_COUNT} \u5F20\uFF0C\u5F53\u524D\u4F20\u5165 ${filePaths.length} \u5F20\u3002`
+    );
+  }
+  const preparedImages = [];
+  for (const filePath of filePaths) {
+    const prepared = await prepareReferenceImage(filePath);
+    if (!prepared.ok) {
+      return prepared;
+    }
+    preparedImages.push(prepared.value);
+  }
+  return makeOkWith(preparedImages);
+}
+async function prepareReferenceImage(filePath) {
+  const resolvedPath = path6.resolve(process.cwd(), filePath);
+  let stats;
+  try {
+    stats = await fs5.stat(resolvedPath);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return makeError(1, `\u8BFB\u53D6\u53C2\u8003\u56FE\u5931\u8D25: ${resolvedPath}: ${message}`);
+  }
+  if (!stats.isFile()) {
+    return makeError(1, `\u53C2\u8003\u56FE\u4E0D\u662F\u6587\u4EF6: ${resolvedPath}`);
+  }
+  let fileBytes;
+  try {
+    fileBytes = await fs5.readFile(resolvedPath);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return makeError(1, `\u8BFB\u53D6\u53C2\u8003\u56FE\u5185\u5BB9\u5931\u8D25: ${resolvedPath}: ${message}`);
+  }
+  const detectedType = detectMimeType(fileBytes, resolvedPath);
+  if (!detectedType) {
+    return makeError(1, `\u53C2\u8003\u56FE\u4E0D\u662F\u652F\u6301\u7684\u56FE\u7247\u683C\u5F0F: ${resolvedPath}`);
+  }
+  const needsTranscode = !API_SUPPORTED_MIME_TYPES.has(detectedType.mimeType) || fileBytes.byteLength > MAX_REFERENCE_IMAGE_BYTES;
+  if (!needsTranscode) {
+    return makeOkWith({
+      inputPath: filePath,
+      resolvedPath,
+      sourceMimeType: detectedType.mimeType,
+      requestMimeType: detectedType.mimeType,
+      originalBytes: fileBytes.byteLength,
+      finalBytes: fileBytes.byteLength,
+      compressed: false,
+      dataUrl: toDataUrl(detectedType.mimeType, fileBytes)
+    });
+  }
+  const compressed = await compressImageForReference(resolvedPath);
+  if (!compressed.ok) {
+    return compressed;
+  }
+  return makeOkWith({
+    inputPath: filePath,
+    resolvedPath,
+    sourceMimeType: detectedType.mimeType,
+    requestMimeType: compressed.value.mimeType,
+    originalBytes: fileBytes.byteLength,
+    finalBytes: compressed.value.bytes.byteLength,
+    compressed: true,
+    dataUrl: toDataUrl(compressed.value.mimeType, compressed.value.bytes)
+  });
+}
+function detectMimeType(fileBytes, filePath) {
+  if (fileBytes.length >= 3 && fileBytes[0] === 255 && fileBytes[1] === 216 && fileBytes[2] === 255) {
+    return { mimeType: "image/jpeg", extension: "jpeg" };
+  }
+  if (fileBytes.length >= 8 && fileBytes[0] === 137 && fileBytes[1] === 80 && fileBytes[2] === 78 && fileBytes[3] === 71 && fileBytes[4] === 13 && fileBytes[5] === 10 && fileBytes[6] === 26 && fileBytes[7] === 10) {
+    return { mimeType: "image/png", extension: "png" };
+  }
+  if (fileBytes.length >= 6) {
+    const gifHeader = fileBytes.subarray(0, 6).toString("ascii");
+    if (gifHeader === "GIF87a" || gifHeader === "GIF89a") {
+      return { mimeType: "image/gif", extension: "gif" };
+    }
+  }
+  if (fileBytes.length >= 12 && fileBytes.subarray(0, 4).toString("ascii") === "RIFF" && fileBytes.subarray(8, 12).toString("ascii") === "WEBP") {
+    return { mimeType: "image/webp", extension: "webp" };
+  }
+  if (fileBytes.length >= 2 && fileBytes.subarray(0, 2).toString("ascii") === "BM") {
+    return { mimeType: "image/bmp", extension: "bmp" };
+  }
+  if (fileBytes.length >= 4 && (fileBytes[0] === 73 && fileBytes[1] === 73 && fileBytes[2] === 42 && fileBytes[3] === 0 || fileBytes[0] === 77 && fileBytes[1] === 77 && fileBytes[2] === 0 && fileBytes[3] === 42)) {
+    return { mimeType: "image/tiff", extension: "tiff" };
+  }
+  if (fileBytes.length >= 12 && fileBytes.subarray(4, 8).toString("ascii") === "ftyp") {
+    const brand = fileBytes.subarray(8, 12).toString("ascii").trim();
+    if (brand.startsWith("avif") || brand === "avis") {
+      return { mimeType: "image/avif", extension: "avif" };
+    }
+    if (brand.startsWith("hei") || brand.startsWith("hev") || brand === "mif1" || brand === "msf1") {
+      return { mimeType: "image/heic", extension: "heic" };
+    }
+  }
+  const ext = path6.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".jpg":
+    case ".jpeg":
+      return { mimeType: "image/jpeg", extension: "jpeg" };
+    case ".png":
+      return { mimeType: "image/png", extension: "png" };
+    case ".gif":
+      return { mimeType: "image/gif", extension: "gif" };
+    case ".webp":
+      return { mimeType: "image/webp", extension: "webp" };
+    case ".bmp":
+      return { mimeType: "image/bmp", extension: "bmp" };
+    case ".tif":
+    case ".tiff":
+      return { mimeType: "image/tiff", extension: "tiff" };
+    case ".heic":
+    case ".heif":
+      return { mimeType: "image/heic", extension: "heic" };
+    case ".avif":
+      return { mimeType: "image/avif", extension: "avif" };
+    default:
+      return void 0;
+  }
+}
+async function compressImageForReference(sourcePath) {
+  if (process.platform !== "darwin") {
+    return makeError(
+      1,
+      `\u53C2\u8003\u56FE\u9700\u8981\u538B\u7F29\u6216\u8F6C\u7801\uFF0C\u4F46\u5F53\u524D\u5E73\u53F0 ${process.platform} \u672A\u5B9E\u73B0\u81EA\u52A8\u5904\u7406\u3002`
+    );
+  }
+  const tempDir = await fs5.mkdtemp(path6.join(os2.tmpdir(), "tt-ai-image-"));
+  try {
+    const dimensions = await readImageDimensions(sourcePath);
+    const maxDimension = Math.max(dimensions.width, dimensions.height);
+    const resizeLimits = uniqueNumbers([
+      maxDimension,
+      Math.floor(maxDimension * 0.85),
+      Math.floor(maxDimension * 0.7),
+      Math.floor(maxDimension * 0.55),
+      Math.floor(maxDimension * 0.4)
+    ]).filter((value) => value >= 64);
+    const qualityLevels = [85, 75, 65, 55, 45, 35];
+    let attemptIndex = 0;
+    for (const resizeLimit of resizeLimits) {
+      for (const quality of qualityLevels) {
+        const targetPath = path6.join(tempDir, `compressed-${attemptIndex}.jpeg`);
+        attemptIndex += 1;
+        await runSips([
+          "--setProperty",
+          "format",
+          "jpeg",
+          "--setProperty",
+          "formatOptions",
+          String(quality),
+          sourcePath,
+          "--out",
+          targetPath
+        ]);
+        if (resizeLimit < maxDimension) {
+          await runSips(["-Z", String(resizeLimit), targetPath]);
+        }
+        const compressedBytes = await fs5.readFile(targetPath);
+        if (compressedBytes.byteLength <= MAX_REFERENCE_IMAGE_BYTES) {
+          return makeOkWith({
+            mimeType: "image/jpeg",
+            bytes: compressedBytes
+          });
+        }
+      }
+    }
+    return makeError(1, `\u53C2\u8003\u56FE\u538B\u7F29\u5931\u8D25\uFF0C\u65E0\u6CD5\u538B\u7F29\u5230 2MB \u4EE5\u5185: ${sourcePath}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return makeError(1, `\u5904\u7406\u53C2\u8003\u56FE\u5931\u8D25: ${sourcePath}: ${message}`);
+  } finally {
+    await fs5.rm(tempDir, { recursive: true, force: true });
+  }
+}
+async function readImageDimensions(sourcePath) {
+  const { stdout } = await runSips([
+    "-g",
+    "pixelWidth",
+    "-g",
+    "pixelHeight",
+    sourcePath
+  ]);
+  const width = readSipsMetric(stdout, "pixelWidth");
+  const height = readSipsMetric(stdout, "pixelHeight");
+  if (!width || !height) {
+    throw new Error("\u65E0\u6CD5\u8BFB\u53D6\u56FE\u7247\u5C3A\u5BF8");
+  }
+  return { width, height };
+}
+async function runSips(args) {
+  return execFileAsync("/usr/bin/sips", [...args]);
+}
+function readSipsMetric(output, key) {
+  const matcher = new RegExp(`${key}:\\s*(\\d+)`);
+  const matched = output.match(matcher);
+  if (!matched) {
+    return void 0;
+  }
+  const value = Number.parseInt(matched[1], 10);
+  return Number.isFinite(value) ? value : void 0;
+}
+function uniqueNumbers(values) {
+  return [...new Set(values)];
+}
+function toDataUrl(mimeType, fileBytes) {
+  const suffix = mimeType.replace("image/", "");
+  return `data:image/${suffix};base64,${fileBytes.toString("base64")}`;
+}
+
+// src/commands/ai/ai-image-command.ts
+var IMAGE_GENERATION_URL = "https://ark.cn-beijing.volces.com/api/v3/images/generations";
+var IMAGE_MODEL = "doubao-seedream-5-0-260128";
+var AiImageCommand = class extends AiBaseCommand {
+  _meta() {
+    return {
+      name: "image",
+      description: "\u8C03\u7528\u8C46\u5305 Seedream \u6A21\u578B\u751F\u6210\u56FE\u7247\u5E76\u4E0B\u8F7D\u5230\u672C\u5730"
+    };
+  }
+  _configureOptions(cmd) {
+    cmd.addOption(
+      new Option8(
+        "-r, --reference <path>",
+        "\u53C2\u8003\u56FE\u8DEF\u5F84\uFF0C\u53EF\u91CD\u590D\u4F20\u5165\uFF0C\u4E5F\u652F\u6301\u7528\u82F1\u6587\u9017\u53F7\u5206\u9694\u591A\u4E2A\u8DEF\u5F84"
+      ).argParser(parseReferencePaths).default([])
+    );
+    cmd.addOption(
+      new Option8(
+        "-s, --size <size>",
+        "\u8F93\u51FA\u5C3A\u5BF8\uFF0C\u4F8B\u5982 1024x1024\u30012048x2048\u30012K"
+      ).default("2K")
+    );
+    cmd.addOption(
+      new Option8("--output-format <format>", "\u751F\u6210\u56FE\u7247\u7F16\u7801\u683C\u5F0F").choices(["jpeg", "png", "webp"]).default("jpeg")
+    );
+    cmd.addOption(
+      new Option8(
+        "-o, --output <path>",
+        "\u8F93\u51FA\u8DEF\u5F84\uFF0C\u53EF\u4F20\u6587\u4EF6\u8DEF\u5F84\u6216\u76EE\u5F55\u8DEF\u5F84\uFF1B\u672A\u4F20\u65F6\u9ED8\u8BA4\u5199\u5165\u5F53\u524D\u76EE\u5F55\u5E76\u81EA\u52A8\u547D\u540D"
+      )
+    );
+  }
+  _configureArguments(cmd) {
+    cmd.argument("[content...]", "\u751F\u56FE\u63D0\u793A\u8BCD");
+  }
+  async _execute(ctx) {
+    const prompt = this._readPrompt(ctx);
+    if (!prompt) {
+      this._outputJsonError(1, "\u8BF7\u8F93\u5165\u751F\u56FE\u63D0\u793A\u8BCD");
+      return this._makeOk();
+    }
+    const referenceResult = await prepareReferenceImages(ctx.options.reference);
+    if (!referenceResult.ok) {
+      this._outputJsonError(referenceResult.code, referenceResult.msg);
+      return this._makeOk();
+    }
+    const requestBody = {
+      model: IMAGE_MODEL,
+      prompt,
+      size: ctx.options.size ?? "2K",
+      response_format: "url",
+      output_format: ctx.options.outputFormat,
+      watermark: false,
+      ...referenceResult.value.length > 0 ? {
+        image: referenceResult.value.map((item) => item.dataUrl)
+      } : {}
+    };
+    const responseResult = await this._requestImage(requestBody);
+    if (!responseResult.ok) {
+      this._outputJsonError(responseResult.code, responseResult.msg);
+      return this._makeOk();
+    }
+    const payload = responseResult.value;
+    const remoteUrl = payload.data?.[0]?.url?.trim();
+    if (!remoteUrl) {
+      this._outputJsonError(1, "\u63A5\u53E3\u8C03\u7528\u6210\u529F\uFF0C\u4F46 data.[0].url \u4E3A\u7A7A");
+      return this._makeOk();
+    }
+    const outputTargetResult = await resolveOutputTarget(
+      ctx.options.output,
+      ctx.options.outputFormat
+    );
+    if (!outputTargetResult.ok) {
+      this._outputJsonError(outputTargetResult.code, outputTargetResult.msg);
+      return this._makeOk();
+    }
+    const saveResult = await downloadImageToFile(
+      remoteUrl,
+      outputTargetResult.value
+    );
+    if (!saveResult.ok) {
+      this._outputJsonError(saveResult.code, saveResult.msg);
+      return this._makeOk();
+    }
+    this._outputJsonOk({
+      image_path: saveResult.value
+    });
+    return this._makeOk();
+  }
+  async _requestImage(requestBody) {
+    const token = process.env.ARK_AK?.trim() || ARK_AK;
+    if (!token) {
+      return makeError(1, "\u7F3A\u5C11 ARK_AK\uFF0C\u8BF7\u5148\u914D\u7F6E\u53EF\u7528\u7684 API Key");
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 12e4);
+    try {
+      const response = await fetch(IMAGE_GENERATION_URL, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(requestBody),
+        signal: controller.signal
+      });
+      const bodyText = await response.text();
+      const payload = parseJsonSafely(bodyText);
+      if (!response.ok) {
+        const suffix = extractErrorMessage(payload) ?? bodyText.trim();
+        return makeError(
+          response.status,
+          suffix ? `\u751F\u56FE\u63A5\u53E3\u8BF7\u6C42\u5931\u8D25: HTTP ${response.status}: ${suffix}` : `\u751F\u56FE\u63A5\u53E3\u8BF7\u6C42\u5931\u8D25: HTTP ${response.status}`
+        );
+      }
+      if (!payload) {
+        return makeError(1, "\u751F\u56FE\u63A5\u53E3\u8FD4\u56DE\u975E JSON \u54CD\u5E94");
+      }
+      if (hasFailedCode(payload.code)) {
+        return makeError(
+          1,
+          extractErrorMessage(payload) ?? "\u751F\u56FE\u63A5\u53E3\u8FD4\u56DE\u9519\u8BEF"
+        );
+      }
+      return makeOkWith(payload);
+    } catch (error) {
+      const message = error instanceof Error && error.name === "AbortError" ? "\u8BF7\u6C42\u8D85\u65F6" : error instanceof Error ? error.message : String(error);
+      return makeError(1, `\u8C03\u7528\u751F\u56FE\u63A5\u53E3\u5931\u8D25: ${message}`);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+async function resolveOutputTarget(outputPath, outputFormat) {
+  if (!outputPath) {
+    const directoryPath = process.cwd();
+    const filePath = path7.join(directoryPath, buildAutoFileName(outputFormat));
+    return makeOkWith({
+      directoryPath,
+      filePath,
+      autoNamed: true
+    });
+  }
+  const resolvedPath = path7.resolve(process.cwd(), outputPath);
+  try {
+    const stats = await fs6.stat(resolvedPath);
+    if (stats.isDirectory()) {
+      return makeOkWith({
+        directoryPath: resolvedPath,
+        filePath: path7.join(resolvedPath, buildAutoFileName(outputFormat)),
+        autoNamed: true
+      });
+    }
+    return makeOkWith({
+      directoryPath: path7.dirname(resolvedPath),
+      filePath: resolvedPath,
+      autoNamed: false
+    });
+  } catch (error) {
+    const nodeError = error;
+    if (nodeError.code !== "ENOENT") {
+      const message = error instanceof Error ? error.message : String(error);
+      return makeError(1, `\u8BFB\u53D6\u8F93\u51FA\u8DEF\u5F84\u5931\u8D25: ${resolvedPath}: ${message}`);
+    }
+    if (path7.extname(resolvedPath)) {
+      return makeOkWith({
+        directoryPath: path7.dirname(resolvedPath),
+        filePath: resolvedPath,
+        autoNamed: false
+      });
+    }
+    return makeOkWith({
+      directoryPath: resolvedPath,
+      filePath: path7.join(resolvedPath, buildAutoFileName(outputFormat)),
+      autoNamed: true
+    });
+  }
+}
+async function downloadImageToFile(remoteUrl, target) {
+  try {
+    await fs6.mkdir(target.directoryPath, { recursive: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return makeError(
+      1,
+      `\u521B\u5EFA\u8F93\u51FA\u76EE\u5F55\u5931\u8D25: ${target.directoryPath}: ${message}`
+    );
+  }
+  let response;
+  try {
+    response = await fetch(remoteUrl);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return makeError(1, `\u4E0B\u8F7D\u56FE\u7247\u5931\u8D25: ${message}`);
+  }
+  if (!response.ok) {
+    return makeError(response.status, `\u4E0B\u8F7D\u56FE\u7247\u5931\u8D25: HTTP ${response.status}`);
+  }
+  const bytes = Buffer.from(await response.arrayBuffer());
+  const targetPath = target.autoNamed ? replaceFileExtension(
+    target.filePath,
+    inferImageExtension(remoteUrl, response)
+  ) : target.filePath;
+  try {
+    await fs6.writeFile(targetPath, bytes);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return makeError(1, `\u5199\u5165\u56FE\u7247\u5931\u8D25: ${targetPath}: ${message}`);
+  }
+  return makeOkWith(path7.resolve(targetPath));
+}
+function parseReferencePaths(value, previous) {
+  return previous.concat(
+    value.split(",").map((item) => item.trim()).filter((item) => item.length > 0)
+  );
+}
+function parseJsonSafely(text) {
+  if (!text.trim()) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function hasFailedCode(code) {
+  if (code === void 0 || code === null) {
+    return false;
+  }
+  if (typeof code === "number") {
+    return code !== 0;
+  }
+  const normalized = code.trim();
+  return normalized !== "0" && normalized !== "";
+}
+function extractErrorMessage(payload) {
+  if (!payload) {
+    return void 0;
+  }
+  const message = payload.msg?.trim() || payload.message?.trim();
+  return message || void 0;
+}
+function buildAutoFileName(outputFormat) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return `ai-image-${timestamp}.${outputFormat}`;
+}
+function replaceFileExtension(filePath, extension) {
+  const ext = path7.extname(filePath);
+  if (!ext) {
+    return `${filePath}.${extension}`;
+  }
+  return `${filePath.slice(0, -ext.length)}.${extension}`;
+}
+function inferImageExtension(remoteUrl, response) {
+  const contentType = response.headers.get("content-type")?.toLowerCase() ?? "";
+  if (contentType.includes("png")) {
+    return "png";
+  }
+  if (contentType.includes("webp")) {
+    return "webp";
+  }
+  if (contentType.includes("jpeg") || contentType.includes("jpg")) {
+    return "jpeg";
+  }
+  try {
+    const url = new URL(remoteUrl);
+    const ext = path7.extname(url.pathname).toLowerCase();
+    if (ext === ".png") {
+      return "png";
+    }
+    if (ext === ".webp") {
+      return "webp";
+    }
+    if (ext === ".jpg" || ext === ".jpeg") {
+      return "jpeg";
+    }
+  } catch {
+  }
+  return "jpeg";
+}
+
+// src/commands/ai/ai-video-command.ts
+import * as path8 from "path";
+import { Option as Option9 } from "commander";
+
+// src/bedrock/uuid/uuid.ts
+var generateUuid = (() => {
+  if (typeof crypto === "object" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID.bind(crypto);
+  }
+  let getRandomValues;
+  if (typeof crypto === "object" && typeof crypto.getRandomValues === "function") {
+    getRandomValues = crypto.getRandomValues.bind(crypto);
+  } else {
+    getRandomValues = function(bucket) {
+      for (let i = 0; i < bucket.length; i++) {
+        bucket[i] = Math.floor(Math.random() * 256);
+      }
+      return bucket;
+    };
+  }
+  const data = new Uint8Array(16);
+  const hex = [];
+  for (let i = 0; i < 256; i++) {
+    hex.push(i.toString(16).padStart(2, "0"));
+  }
+  return () => {
+    getRandomValues(data);
+    data[6] = data[6] & 15 | 64;
+    data[8] = data[8] & 63 | 128;
+    let i = 0;
+    let result = "";
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += "-";
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += "-";
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += "-";
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += "-";
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    return result;
+  };
+})();
+
+// src/commands/pippit/modules/submit-direct/submit-direct-cn.ts
+var SUBMIT_DIRECT_URL = "https://xyq.jianying.com/api/biz/v1/agent/submit_run";
+function normalizeToken4(token) {
+  const trimmed = token.trim();
+  const prefix = "sessionid_pippitcn_web=";
+  if (trimmed.startsWith(prefix)) {
+    return trimmed.slice(prefix.length).trim();
+  }
+  return trimmed;
+}
+function createCookieHeader3(token) {
+  return `sessionid_pippitcn_web=${normalizeToken4(token)}`;
+}
+function parseErrorCode2(ret) {
+  const parsed = typeof ret === "number" ? ret : typeof ret === "string" ? Number.parseInt(ret, 10) : Number.NaN;
+  return Number.isFinite(parsed) ? parsed : 1;
+}
+function createUserInfo() {
+  return readWebContext("cn" /* CN */).then((webContextResult) => {
+    if (!webContextResult.ok) {
+      return webContextResult;
+    }
+    const webContext = webContextResult.value;
+    if (!webContext.uid || !webContext.workspaceId || !webContext.spaceId) {
+      return missingWebContextError();
+    }
+    return makeOkWith({
+      uid: webContext.uid,
+      workspace_id: webContext.workspaceId,
+      space_id: webContext.spaceId
+    });
+  });
+}
+async function submitDirectCn(options) {
+  const userInfoResult = await createUserInfo();
+  if (!userInfoResult.ok) {
+    return userInfoResult;
+  }
+  const { durationSec, imageAssetIds, prompt } = options;
+  const tokenResult = await readWebToken("cn" /* CN */);
+  if (!tokenResult.ok) {
+    return tokenResult;
+  }
+  const token = tokenResult.value?.trim();
+  if (!token) {
+    return missingWebTokenError();
+  }
+  const threadId = generateUuid();
+  const runId = generateUuid();
+  let duration = 5;
+  if (durationSec && durationSec <= 8 && durationSec >= 2) {
+    duration = Math.round(durationSec);
+  }
+  const message = {
+    message_id: "",
+    role: "user",
+    thread_id: threadId,
+    run_id: runId,
+    created_at: Date.now(),
+    content: [
+      {
+        type: "data",
+        sub_type: "biz/x_data_direct_tool_call_req",
+        data: JSON.stringify({
+          param: JSON.stringify({
+            prompt,
+            images: [
+              imageAssetIds?.map((assetId) => ({
+                asset_id: assetId
+              }))
+            ],
+            duration_sec: duration,
+            language: "zh",
+            resolution: "720p",
+            imitation_videos: [],
+            videos: [],
+            audios: [],
+            model: "seedance2.0_vision"
+          }),
+          tool_name: "biz/x_tool_name_video_part"
+        }),
+        hidden: false,
+        is_thought: false
+      }
+    ]
+  };
+  const userInfo = {
+    app_id: "795647",
+    consumer_uid: userInfoResult.value.uid,
+    workspace_id: userInfoResult.value.workspace_id,
+    space_id: userInfoResult.value.space_id
+  };
+  const responseResult = await requestJson(
+    SUBMIT_DIRECT_URL,
+    {
+      method: "POST",
+      headers: {
+        accept: "application/json, text/plain, */*",
+        "content-type": "application/json",
+        cookie: createCookieHeader3(token),
+        Referer: "https://xyq.jianying.com/"
+      },
+      body: JSON.stringify({
+        user_info: userInfo,
+        message,
+        agent_name: "pippit_video_part_agent",
+        entrance_from: "web",
+        run_extra: "{}"
+      })
+    },
+    {
+      networkRequestFailed: (message2) => networkRequestFailedError3(message2),
+      responseParseFailed: (message2) => responseParseFailedError2(message2)
+    }
+  );
+  if (!responseResult.ok) {
+    return responseResult;
+  }
+  const response = responseResult.value;
+  console.log("=====response", response);
+  if (String(response.ret) !== "0") {
+    return makeError(
+      parseErrorCode2(response.ret),
+      response.errmsg?.trim() || "\u76F4\u63A5\u63D0\u4EA4\u5931\u8D25\u3002"
+    );
+  }
+  return makeOkWith(response.data);
+}
+
+// src/commands/ai/ai-video-command.ts
+var AiVideoCommand = class extends AiBaseCommand {
+  _meta() {
+    return {
+      name: "video",
+      description: "\u4E0A\u4F20\u53C2\u8003\u7D20\u6750\u5E76\u8C03\u7528\u89C6\u9891\u751F\u6210\u63A5\u53E3"
+    };
+  }
+  _configureOptions(cmd) {
+    cmd.addOption(
+      new Option9(
+        "-r, --reference <path>",
+        "\u53C2\u8003\u56FE\u7247\u6216\u89C6\u9891\u8DEF\u5F84\uFF0C\u53EF\u91CD\u590D\u4F20\u5165\uFF0C\u4E5F\u652F\u6301\u7528\u82F1\u6587\u9017\u53F7\u5206\u9694\u591A\u4E2A\u8DEF\u5F84"
+      ).argParser(parseReferencePaths2).default([])
+    );
+  }
+  _configureArguments(cmd) {
+    cmd.argument("[content...]", "\u89C6\u9891\u751F\u6210\u63D0\u793A\u8BCD");
+  }
+  async _execute(ctx) {
+    const prompt = this._readPrompt(ctx);
+    if (!prompt) {
+      this._outputJsonError(1, "\u8BF7\u8F93\u5165\u89C6\u9891\u751F\u6210\u63D0\u793A\u8BCD");
+      return this._makeOk();
+    }
+    const uploadResult = await this._uploadReferences(ctx.options.reference);
+    if (!uploadResult.ok) {
+      this._outputJsonError(uploadResult.code, uploadResult.msg);
+      return this._makeOk();
+    }
+    const generationResult = await this._requestVideoGeneration(
+      prompt,
+      uploadResult.value
+    );
+    if (!generationResult.ok) {
+      this._outputJsonError(generationResult.code, generationResult.msg);
+      return this._makeOk();
+    }
+    this._outputJsonOk({
+      prompt,
+      assets: uploadResult.value,
+      generation: generationResult.value
+    });
+    return this._makeOk();
+  }
+  async _uploadReferences(references) {
+    if (references.length === 0) {
+      return makeOkWith([]);
+    }
+    const uploadResults = await Promise.all(
+      references.map(async (referencePath) => {
+        const result = await uploadAsset({
+          filePath: referencePath,
+          region: "cn" /* CN */
+        });
+        if (!result.ok) {
+          return result;
+        }
+        return makeOkWith({
+          asset_id: result.value.assetId,
+          asset_type: result.value.fileInfo.assetType,
+          file_path: path8.resolve(process.cwd(), referencePath),
+          region: result.value.region
+        });
+      })
+    );
+    for (const result of uploadResults) {
+      if (!result.ok) {
+        return result;
+      }
+    }
+    return makeOkWith(uploadResults.map((result) => result.value));
+  }
+  async _requestVideoGeneration(prompt, assets) {
+    return submitDirectCn({
+      prompt,
+      imageAssetIds: assets.map((asset) => asset.asset_id),
+      durationSec: 5
+    });
+  }
+};
+function parseReferencePaths2(value, previous) {
+  return previous.concat(
+    value.split(",").map((item) => item.trim()).filter((item) => item.length > 0)
+  );
+}
+
+// src/commands/ai/ai-vid-command.ts
+import * as fs7 from "fs/promises";
+import * as path9 from "path";
+import { Option as Option10 } from "commander";
+var VIDEO_GENERATION_URL = "https://openrouter.ai/api/v1/videos";
+var VIDEO_MODEL = "bytedance/seedance-2.0";
+var POLLING_LOG_FILE_NAME = "ai-vid-polling.log";
+var POLL_INTERVAL_MS = 3e3;
+var POLL_STATUS_LOG_INTERVAL_MS = 1e4;
+var POLL_TIMEOUT_MS = 5 * 60 * 1e3;
+var SUBMIT_TIMEOUT_MS = 3e4;
+var AiVidCommand = class extends AiBaseCommand {
+  _meta() {
+    return {
+      name: "vid",
+      description: "\u901A\u8FC7 OpenRouter \u8C03\u7528 bytedance/seedance-2.0 \u751F\u6210\u89C6\u9891"
+    };
+  }
+  _configureOptions(cmd) {
+    cmd.addOption(
+      new Option10(
+        "-r, --reference <path>",
+        "\u53C2\u8003\u56FE\u7247\u672C\u5730\u8DEF\u5F84\uFF0C\u53EF\u91CD\u590D\u4F20\u5165\uFF0C\u4E5F\u652F\u6301\u7528\u82F1\u6587\u9017\u53F7\u5206\u9694\u591A\u4E2A\u8DEF\u5F84\uFF1B\u6700\u7EC8\u8F6C\u4E3A base64 data URL"
+      ).argParser(parseReferencePaths3).default([])
+    );
+    cmd.addOption(
+      new Option10("--resolution <resolution>", "\u89C6\u9891\u5206\u8FA8\u7387").choices(["480p", "720p"]).default("480p")
+    );
+    cmd.addOption(
+      new Option10(
+        "--aspect-ratio <ratio>",
+        "\u89C6\u9891\u957F\u5BBD\u6BD4\uFF0C\u4F8B\u5982 16:9\u30019:16\u30011:1\uFF0C\u7F3A\u7701\u4E0D\u6307\u5B9A"
+      )
+    );
+    cmd.addOption(
+      new Option10("--duration <seconds>", "\u89C6\u9891\u65F6\u957F\uFF08\u79D2\uFF09\uFF0C\u7F3A\u7701\u4E0D\u6307\u5B9A").argParser(
+        parseDuration
+      )
+    );
+    cmd.addOption(
+      new Option10(
+        "--polling-only",
+        "\u4EC5\u63D0\u4EA4\u5E76\u8FD4\u56DE polling_url\uFF0C\u4E0D\u5728\u672C\u5730\u8F6E\u8BE2\u7ED3\u679C"
+      ).default(false)
+    );
+    cmd.addOption(
+      new Option10(
+        "-o, --output <path>",
+        "\u89C6\u9891\u4E0B\u8F7D\u8F93\u51FA\u8DEF\u5F84\uFF0C\u53EF\u4F20\u6587\u4EF6\u8DEF\u5F84\u6216\u76EE\u5F55\u8DEF\u5F84\uFF1B\u672A\u4F20\u65F6\u9ED8\u8BA4\u5199\u5165\u5F53\u524D\u76EE\u5F55\u5E76\u81EA\u52A8\u547D\u540D"
+      )
+    );
+  }
+  _configureArguments(cmd) {
+    cmd.argument("[content...]", "\u89C6\u9891\u751F\u6210\u63D0\u793A\u8BCD");
+  }
+  async _execute(ctx) {
+    const prompt = this._readPrompt(ctx);
+    if (!prompt) {
+      this._outputJsonError(1, "\u8BF7\u8F93\u5165\u89C6\u9891\u751F\u6210\u63D0\u793A\u8BCD");
+      return this._makeOk();
+    }
+    const referenceResult = await prepareReferenceImages(ctx.options.reference);
+    if (!referenceResult.ok) {
+      this._outputJsonError(referenceResult.code, referenceResult.msg);
+      return this._makeOk();
+    }
+    const requestBody = {
+      model: VIDEO_MODEL,
+      prompt,
+      resolution: ctx.options.resolution
+    };
+    if (ctx.options.aspectRatio) {
+      requestBody.aspect_ratio = ctx.options.aspectRatio;
+    }
+    if (typeof ctx.options.duration === "number") {
+      requestBody.duration = ctx.options.duration;
+    }
+    if (referenceResult.value.length > 0) {
+      requestBody.input_references = referenceResult.value.map((item) => ({
+        type: "image_url",
+        image_url: { url: item.dataUrl }
+      }));
+    }
+    const submitResult = await this._submitGeneration(requestBody);
+    if (!submitResult.ok) {
+      this._outputJsonError(submitResult.code, submitResult.msg);
+      return this._makeOk();
+    }
+    const submitPayload = submitResult.value;
+    const pollingUrl = submitPayload.polling_url?.trim();
+    if (!pollingUrl) {
+      this._outputJsonError(1, "\u63D0\u4EA4\u6210\u529F\u4F46\u8FD4\u56DE\u6570\u636E\u7F3A\u5C11 polling_url");
+      return this._makeOk();
+    }
+    const logPathResult = await appendPollingUrl(pollingUrl, submitPayload.id);
+    const pollingLogPath = logPathResult.ok ? logPathResult.value : void 0;
+    if (!logPathResult.ok) {
+      this._debug(`\u8BB0\u5F55 polling_url \u5931\u8D25: ${logPathResult.msg}`);
+    }
+    if (ctx.options.pollingOnly) {
+      this._outputJsonOk({
+        polling_url: pollingUrl,
+        generation_id: submitPayload.id,
+        polling_log_path: pollingLogPath
+      });
+      return this._makeOk();
+    }
+    const pollResult = await this._pollUntilComplete(pollingUrl);
+    if (!pollResult.ok) {
+      this._outputJsonError(pollResult.code, pollResult.msg);
+      return this._makeOk();
+    }
+    const videoUrl = pollResult.value.unsigned_urls?.[0];
+    if (!videoUrl) {
+      this._outputJsonError(1, "\u89C6\u9891\u751F\u6210\u5B8C\u6210\uFF0C\u4F46\u672A\u62FF\u5230 unsigned_urls[0]");
+      return this._makeOk();
+    }
+    const outputTargetResult = await resolveOutputTarget2(ctx.options.output);
+    if (!outputTargetResult.ok) {
+      this._outputJsonError(outputTargetResult.code, outputTargetResult.msg);
+      return this._makeOk();
+    }
+    const downloadResult = await downloadVideoToFile(
+      videoUrl,
+      outputTargetResult.value
+    );
+    if (!downloadResult.ok) {
+      this._outputJsonError(downloadResult.code, downloadResult.msg);
+      return this._makeOk();
+    }
+    this._outputJsonOk({
+      video_path: downloadResult.value,
+      video_url: videoUrl,
+      polling_url: pollingUrl,
+      generation_id: submitPayload.id,
+      polling_log_path: pollingLogPath
+    });
+    return this._makeOk();
+  }
+  async _submitGeneration(requestBody) {
+    const token = process.env.OPENROUTER_AK?.trim() || OPENROUTER_AK;
+    if (!token) {
+      return makeError(1, "\u7F3A\u5C11 OPENROUTER_AK\uFF0C\u8BF7\u5148\u914D\u7F6E\u53EF\u7528\u7684 API Key");
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), SUBMIT_TIMEOUT_MS);
+    let response;
+    try {
+      response = await fetch(VIDEO_GENERATION_URL, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(requestBody),
+        signal: controller.signal
+      });
+    } catch (error) {
+      const message = error instanceof Error && error.name === "AbortError" ? "\u8BF7\u6C42\u8D85\u65F6" : error instanceof Error ? error.message : String(error);
+      return makeError(1, `\u63D0\u4EA4\u89C6\u9891\u751F\u6210\u8BF7\u6C42\u5931\u8D25: ${message}`);
+    } finally {
+      clearTimeout(timer);
+    }
+    const bodyText = await response.text().catch(() => "");
+    const payload = parseJsonSafely2(bodyText);
+    if (!response.ok) {
+      const detail = extractErrorText(payload) ?? bodyText.trim();
+      const suffix = detail ? `: ${detail}` : "";
+      return makeError(
+        response.status,
+        `\u89C6\u9891\u751F\u6210\u8BF7\u6C42\u5931\u8D25: HTTP ${response.status}${suffix}`
+      );
+    }
+    if (!payload) {
+      return makeError(1, "\u89C6\u9891\u751F\u6210\u63A5\u53E3\u8FD4\u56DE\u975E JSON \u54CD\u5E94");
+    }
+    if (payload.error) {
+      return makeError(1, `\u89C6\u9891\u751F\u6210\u8BF7\u6C42\u88AB\u62D2\u7EDD: ${payload.error}`);
+    }
+    if (!payload.id || !payload.polling_url) {
+      return makeError(
+        1,
+        `\u89C6\u9891\u751F\u6210\u63A5\u53E3\u8FD4\u56DE\u6570\u636E\u5F02\u5E38: ${bodyText.slice(0, 500)}`
+      );
+    }
+    return makeOkWith(payload);
+  }
+  async _pollUntilComplete(pollingUrl) {
+    const token = process.env.OPENROUTER_AK?.trim() || OPENROUTER_AK;
+    const startedAt = Date.now();
+    let lastStatusLogAt = 0;
+    while (true) {
+      const elapsed = Date.now() - startedAt;
+      if (elapsed >= POLL_TIMEOUT_MS) {
+        return makeError(
+          1,
+          `\u8F6E\u8BE2\u8D85\u65F6\uFF0C\u8D85\u8FC7 ${Math.round(POLL_TIMEOUT_MS / 1e3)}s \u4ECD\u672A\u5B8C\u6210\uFF0C\u53EF\u4F7F\u7528 --polling-only \u62FF\u5230 polling_url \u540E\u7A0D\u540E\u91CD\u8BD5`
+        );
+      }
+      let response;
+      try {
+        response = await fetch(pollingUrl, {
+          headers: { Authorization: `Bearer ${token}` }
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this._debug(`\u8F6E\u8BE2\u8BF7\u6C42\u5931\u8D25\uFF0C\u5C06\u91CD\u8BD5: ${message}`);
+        await delay(POLL_INTERVAL_MS);
+        continue;
+      }
+      const bodyText = await response.text().catch(() => "");
+      const payload = parseJsonSafely2(bodyText);
+      if (!response.ok) {
+        const detail = extractErrorText(payload) ?? bodyText.trim();
+        return makeError(
+          response.status,
+          `\u8F6E\u8BE2\u8BF7\u6C42\u5931\u8D25: HTTP ${response.status}${detail ? `: ${detail}` : ""}`
+        );
+      }
+      if (!payload) {
+        this._debug("\u8F6E\u8BE2\u8FD4\u56DE\u975E JSON \u6570\u636E\uFF0C\u5C06\u91CD\u8BD5");
+        await delay(POLL_INTERVAL_MS);
+        continue;
+      }
+      const status = payload.status;
+      if (status === "completed") {
+        return makeOkWith(payload);
+      }
+      if (status === "failed" || status === "cancelled" || status === "expired") {
+        const errorText = payload.error?.trim() || `\u89C6\u9891\u751F\u6210\u7ED3\u675F\u4E8E\u72B6\u6001 ${status}`;
+        return makeError(1, errorText);
+      }
+      const now = Date.now();
+      if (now - lastStatusLogAt >= POLL_STATUS_LOG_INTERVAL_MS) {
+        this._debug(
+          `\u89C6\u9891\u751F\u6210\u72B6\u6001: ${status ?? "unknown"} (\u5DF2\u7B49\u5F85 ${Math.round(elapsed / 1e3)}s)`
+        );
+        lastStatusLogAt = now;
+      }
+      await delay(POLL_INTERVAL_MS);
+    }
+  }
+};
+function parseReferencePaths3(value, previous) {
+  return previous.concat(
+    value.split(",").map((item) => item.trim()).filter((item) => item.length > 0)
+  );
+}
+function parseDuration(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`duration \u9700\u8981\u662F\u6B63\u6574\u6570\uFF0C\u6536\u5230: ${value}`);
+  }
+  return parsed;
+}
+function parseJsonSafely2(text) {
+  if (!text.trim()) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function extractErrorText(payload) {
+  if (!payload || typeof payload !== "object") {
+    return void 0;
+  }
+  const record = payload;
+  if (typeof record.error === "string" && record.error.trim().length > 0) {
+    return record.error.trim();
+  }
+  if (record.error && typeof record.error === "object") {
+    const inner = record.error;
+    if (typeof inner.message === "string" && inner.message.trim().length > 0) {
+      return inner.message.trim();
+    }
+  }
+  if (typeof record.message === "string" && record.message.trim().length > 0) {
+    return record.message.trim();
+  }
+  return void 0;
+}
+function delay(ms) {
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
+}
+async function appendPollingUrl(pollingUrl, generationId) {
+  const locationResult = await resolveConfigLocation();
+  if (!locationResult.ok) {
+    return locationResult;
+  }
+  const logFilePath = path9.join(
+    locationResult.value.configDir,
+    POLLING_LOG_FILE_NAME
+  );
+  try {
+    await fs7.mkdir(locationResult.value.configDir, { recursive: true });
+    const line = `${(/* @__PURE__ */ new Date()).toISOString()}	${generationId}	${pollingUrl}
+`;
+    await fs7.appendFile(logFilePath, line, "utf8");
+    return makeOkWith(logFilePath);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return makeError(1, `\u5199\u5165 polling \u65E5\u5FD7\u5931\u8D25 ${logFilePath}: ${message}`);
+  }
+}
+async function resolveOutputTarget2(outputPath) {
+  if (!outputPath) {
+    const directoryPath = process.cwd();
+    return makeOkWith({
+      directoryPath,
+      filePath: path9.join(directoryPath, buildAutoFileName2()),
+      autoNamed: true
+    });
+  }
+  const resolvedPath = path9.resolve(process.cwd(), outputPath);
+  try {
+    const stats = await fs7.stat(resolvedPath);
+    if (stats.isDirectory()) {
+      return makeOkWith({
+        directoryPath: resolvedPath,
+        filePath: path9.join(resolvedPath, buildAutoFileName2()),
+        autoNamed: true
+      });
+    }
+    return makeOkWith({
+      directoryPath: path9.dirname(resolvedPath),
+      filePath: resolvedPath,
+      autoNamed: false
+    });
+  } catch (error) {
+    const nodeError = error;
+    if (nodeError.code !== "ENOENT") {
+      const message = error instanceof Error ? error.message : String(error);
+      return makeError(1, `\u8BFB\u53D6\u8F93\u51FA\u8DEF\u5F84\u5931\u8D25: ${resolvedPath}: ${message}`);
+    }
+    if (path9.extname(resolvedPath)) {
+      return makeOkWith({
+        directoryPath: path9.dirname(resolvedPath),
+        filePath: resolvedPath,
+        autoNamed: false
+      });
+    }
+    return makeOkWith({
+      directoryPath: resolvedPath,
+      filePath: path9.join(resolvedPath, buildAutoFileName2()),
+      autoNamed: true
+    });
+  }
+}
+async function downloadVideoToFile(remoteUrl, target) {
+  try {
+    await fs7.mkdir(target.directoryPath, { recursive: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return makeError(
+      1,
+      `\u521B\u5EFA\u8F93\u51FA\u76EE\u5F55\u5931\u8D25: ${target.directoryPath}: ${message}`
+    );
+  }
+  let response;
+  try {
+    response = await fetch(remoteUrl);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return makeError(1, `\u4E0B\u8F7D\u89C6\u9891\u5931\u8D25: ${message}`);
+  }
+  if (!response.ok) {
+    return makeError(response.status, `\u4E0B\u8F7D\u89C6\u9891\u5931\u8D25: HTTP ${response.status}`);
+  }
+  const bytes = Buffer.from(await response.arrayBuffer());
+  const targetPath = target.autoNamed ? replaceFileExtension2(target.filePath, inferVideoExtension(remoteUrl, response)) : target.filePath;
+  try {
+    await fs7.writeFile(targetPath, bytes);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return makeError(1, `\u5199\u5165\u89C6\u9891\u5931\u8D25: ${targetPath}: ${message}`);
+  }
+  return makeOkWith(path9.resolve(targetPath));
+}
+function buildAutoFileName2() {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return `ai-vid-${timestamp}.mp4`;
+}
+function replaceFileExtension2(filePath, extension) {
+  const ext = path9.extname(filePath);
+  if (!ext) {
+    return `${filePath}.${extension}`;
+  }
+  return `${filePath.slice(0, -ext.length)}.${extension}`;
+}
+function inferVideoExtension(remoteUrl, response) {
+  const contentType = response.headers.get("content-type")?.toLowerCase() ?? "";
+  if (contentType.includes("mp4")) {
+    return "mp4";
+  }
+  if (contentType.includes("webm")) {
+    return "webm";
+  }
+  if (contentType.includes("quicktime") || contentType.includes("mov")) {
+    return "mov";
+  }
+  try {
+    const url = new URL(remoteUrl);
+    const ext = path9.extname(url.pathname).toLowerCase();
+    if (ext === ".mp4" || ext === ".webm" || ext === ".mov") {
+      return ext.slice(1);
+    }
+  } catch {
+  }
+  return "mp4";
+}
+
 // src/commands/ai/ai-command.ts
 var AiCommand = class extends BaseSubcommandHost {
   _meta() {
@@ -2446,6 +3654,9 @@ var AiCommand = class extends BaseSubcommandHost {
     this._addSubcommand(new AiCursorCommand());
     this._addSubcommand(new AiCodexCommand());
     this._addSubcommand(new AiRunCommand());
+    this._addSubcommand(new AiImageCommand());
+    this._addSubcommand(new AiVideoCommand());
+    this._addSubcommand(new AiVidCommand());
   }
 };