maoda-commander-tt 0.0.19 → 0.0.20

package/dist/main.js

@@ -2455,277 +2455,26 @@ 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
+// src/commands/ai/ai-image-command-v2.ts
+import { spawn as spawn3 } from "child_process";
 import * as fs5 from "fs/promises";
-import * as os2 from "os";
+import { homedir as homedir7 } 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 {
+var GENERATED_IMAGES_DIR = path6.join(homedir7(), ".codex", "generated_images");
+var CODEX_EMPTY_WORKDIR = path6.join(homedir7(), ".codex-empty");
+var CREATED_AT_TOLERANCE_MS = 1e3;
+var AiImageCommandV2 = 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"
+      description: "\u901A\u8FC7 codex exec \u751F\u6210\u56FE\u7247\uFF0C\u5E76\u8FD4\u56DE\u672C\u5730\u751F\u6210\u56FE\u7247\u8DEF\u5F84"
     };
   }
-  _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");
+    cmd.argument(
+      "[prompt...]",
+      "\u751F\u56FE\u63D0\u793A\u8BCD\uFF1B\u5982\u6709\u53C2\u8003\u56FE\uFF0C\u9700\u5728 prompt \u4E2D\u7ED9\u51FA\u53C2\u8003\u56FE\u7684\u7EDD\u5BF9\u5730\u5740"
+    );
   }
   async _execute(ctx) {
     const prompt = this._readPrompt(ctx);
@@ -2733,250 +2482,162 @@ var AiImageCommand = class extends AiBaseCommand {
       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);
+    const startedAt = Date.now();
+    const runResult = await this._runCodexImagePrompt(prompt);
+    if (!runResult.ok) {
+      this._outputJsonError(runResult.code, runResult.msg);
       return this._makeOk();
     }
-    const saveResult = await downloadImageToFile(
-      remoteUrl,
-      outputTargetResult.value
-    );
-    if (!saveResult.ok) {
-      this._outputJsonError(saveResult.code, saveResult.msg);
+    const imagePathResult = await findLatestGeneratedImageFile(startedAt);
+    if (!imagePathResult.ok) {
+      this._outputJsonError(imagePathResult.code, imagePathResult.msg);
       return this._makeOk();
     }
     this._outputJsonOk({
-      image_path: saveResult.value
+      image_path: imagePathResult.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);
+  async _runCodexImagePrompt(prompt) {
     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);
+      await fs5.mkdir(CODEX_EMPTY_WORKDIR, { recursive: true });
     } 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);
+      const message = error instanceof Error ? error.message : String(error);
+      return this._makeError(
+        1,
+        `\u521B\u5EFA codex \u7A7A\u5DE5\u4F5C\u76EE\u5F55\u5931\u8D25: ${CODEX_EMPTY_WORKDIR}: ${message}`
+      );
     }
-  }
-};
-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 codexPrompt = `\u751F\u6210\u56FE\u7247
+  ${prompt}`;
+    const args = [
+      "exec",
+      "-C",
+      CODEX_EMPTY_WORKDIR,
+      "--skip-git-repo-check",
+      "--ephemeral",
+      "--dangerously-bypass-approvals-and-sandbox",
+      codexPrompt
+    ];
+    const child = spawn3("codex", args, {
+      cwd: process.cwd(),
+      stdio: "ignore"
     });
-  }
-  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 new Promise((resolve8) => {
+      child.on("error", (error) => {
+        resolve8(
+          this._makeError(
+            1,
+            `\u6267\u884C codex ${args.join(" ")} \u5931\u8D25: ${error.message}`
+          )
+        );
       });
-    }
-    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
+      child.on("close", (code, signal) => {
+        if (code === 0) {
+          resolve8(this._makeOk());
+          return;
+        }
+        const signalText = signal ? `, signal: ${signal}` : "";
+        resolve8(
+          this._makeError(
+            code ?? 1,
+            `\u6267\u884C codex ${args.join(" ")} \u5931\u8D25${signalText}`
+          )
+        );
       });
-    }
-    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)
+};
+async function findLatestGeneratedImageFile(minCreatedAt) {
+  const latestDirectoryResult = await findLatestCreatedDirectory(
+    GENERATED_IMAGES_DIR,
+    minCreatedAt
   );
+  if (!latestDirectoryResult.ok) {
+    return latestDirectoryResult;
+  }
+  return findLatestCreatedFile(latestDirectoryResult.value);
 }
-function parseJsonSafely(text) {
-  if (!text.trim()) {
-    return void 0;
+async function findLatestCreatedDirectory(directoryPath, minCreatedAt) {
+  const entriesResult = await readDirectoryEntries(directoryPath);
+  if (!entriesResult.ok) {
+    return entriesResult;
   }
-  try {
-    return JSON.parse(text);
-  } catch {
-    return void 0;
+  const directories = await collectCreatedEntries(
+    directoryPath,
+    entriesResult.value.filter((entry) => entry.isDirectory()).map((entry) => entry.name)
+  );
+  if (!directories.ok) {
+    return directories;
+  }
+  const latest = directories.value.filter(
+    (entry) => entry.createdAt >= minCreatedAt - CREATED_AT_TOLERANCE_MS
+  ).sort(compareCreatedEntryDesc)[0];
+  if (!latest) {
+    return makeErrorForPath(
+      1,
+      "\u672A\u627E\u5230\u672C\u6B21 codex \u751F\u56FE\u8F93\u51FA\u5B50\u76EE\u5F55",
+      directoryPath
+    );
   }
+  return makeOkWith(latest.filePath);
 }
-function hasFailedCode(code) {
-  if (code === void 0 || code === null) {
-    return false;
+async function findLatestCreatedFile(directoryPath) {
+  const entriesResult = await readDirectoryEntries(directoryPath);
+  if (!entriesResult.ok) {
+    return entriesResult;
   }
-  if (typeof code === "number") {
-    return code !== 0;
+  const files = await collectCreatedEntries(
+    directoryPath,
+    entriesResult.value.filter((entry) => entry.isFile()).map((entry) => entry.name)
+  );
+  if (!files.ok) {
+    return files;
   }
-  const normalized = code.trim();
-  return normalized !== "0" && normalized !== "";
-}
-function extractErrorMessage(payload) {
-  if (!payload) {
-    return void 0;
+  const latest = files.value.sort(compareCreatedEntryDesc)[0];
+  if (!latest) {
+    return makeErrorForPath(1, "\u6700\u65B0\u751F\u56FE\u8F93\u51FA\u76EE\u5F55\u4E2D\u672A\u627E\u5230\u6587\u4EF6", directoryPath);
   }
-  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}`;
+  return makeOkWith(path6.resolve(latest.filePath));
 }
-function replaceFileExtension(filePath, extension) {
-  const ext = path7.extname(filePath);
-  if (!ext) {
-    return `${filePath}.${extension}`;
+async function readDirectoryEntries(directoryPath) {
+  try {
+    return makeOkWith(await fs5.readdir(directoryPath, { withFileTypes: true }));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return makeErrorForPath(1, `\u8BFB\u53D6\u76EE\u5F55\u5931\u8D25: ${message}`, directoryPath);
   }
-  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";
+async function collectCreatedEntries(parentPath, names) {
+  const entries = [];
+  for (const name of names) {
+    const filePath = path6.join(parentPath, name);
+    try {
+      const stats = await fs5.stat(filePath);
+      entries.push({
+        filePath,
+        createdAt: getCreatedAt(stats)
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return makeErrorForPath(1, `\u8BFB\u53D6\u8DEF\u5F84\u72B6\u6001\u5931\u8D25: ${message}`, filePath);
     }
-  } catch {
   }
-  return "jpeg";
+  return makeOkWith(entries);
+}
+function getCreatedAt(stats) {
+  return stats.birthtimeMs || stats.ctimeMs || stats.mtimeMs;
+}
+function compareCreatedEntryDesc(a, b) {
+  return b.createdAt - a.createdAt || b.filePath.localeCompare(a.filePath);
+}
+function makeErrorForPath(code, message, filePath) {
+  return makeError(code, `${message}: ${filePath}`);
 }
 
 // src/commands/ai/ai-video-command.ts
-import * as path8 from "path";
-import { Option as Option9 } from "commander";
+import * as path7 from "path";
+import { Option as Option8 } from "commander";
 
 // src/bedrock/uuid/uuid.ts
 var generateUuid = (() => {
@@ -3168,10 +2829,10 @@ var AiVideoCommand = class extends AiBaseCommand {
   }
   _configureOptions(cmd) {
     cmd.addOption(
-      new Option9(
+      new Option8(
         "-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([])
+      ).argParser(parseReferencePaths).default([])
     );
   }
   _configureArguments(cmd) {
@@ -3219,7 +2880,7 @@ var AiVideoCommand = class extends AiBaseCommand {
         return makeOkWith({
           asset_id: result.value.assetId,
           asset_type: result.value.fileInfo.assetType,
-          file_path: path8.resolve(process.cwd(), referencePath),
+          file_path: path7.resolve(process.cwd(), referencePath),
           region: result.value.region
         });
       })
@@ -3239,7 +2900,7 @@ var AiVideoCommand = class extends AiBaseCommand {
     });
   }
 };
-function parseReferencePaths2(value, previous) {
+function parseReferencePaths(value, previous) {
   return previous.concat(
     value.split(",").map((item) => item.trim()).filter((item) => item.length > 0)
   );
@@ -3248,7 +2909,240 @@ function parseReferencePaths2(value, previous) {
 // src/commands/ai/ai-vid-command.ts
 import * as fs7 from "fs/promises";
 import * as path9 from "path";
-import { Option as Option10 } from "commander";
+import { Option as Option9 } from "commander";
+
+// src/commands/ai/ai-image-reference.ts
+import * as fs6 from "fs/promises";
+import * as os2 from "os";
+import * as path8 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 = path8.resolve(process.cwd(), filePath);
+  let stats;
+  try {
+    stats = await fs6.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 fs6.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 = path8.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 fs6.mkdtemp(path8.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 = path8.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 fs6.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 fs6.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-vid-command.ts
 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";
@@ -3266,34 +3160,34 @@ var AiVidCommand = class extends AiBaseCommand {
   }
   _configureOptions(cmd) {
     cmd.addOption(
-      new Option10(
+      new Option9(
         "-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([])
+      ).argParser(parseReferencePaths2).default([])
     );
     cmd.addOption(
-      new Option10("--resolution <resolution>", "\u89C6\u9891\u5206\u8FA8\u7387").choices(["480p", "720p"]).default("480p")
+      new Option9("--resolution <resolution>", "\u89C6\u9891\u5206\u8FA8\u7387").choices(["480p", "720p"]).default("480p")
     );
     cmd.addOption(
-      new Option10(
+      new Option9(
         "--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(
+      new Option9(
         "--duration <seconds>",
         "\u89C6\u9891\u65F6\u957F\uFF08\u79D2\uFF09\uFF0C\u7F3A\u7701\u4E0D\u6307\u5B9A"
       ).argParser(parseDuration)
     );
     cmd.addOption(
-      new Option10(
+      new Option9(
         "--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(
+      new Option9(
         "-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"
       )
@@ -3369,7 +3263,7 @@ var AiVidCommand = class extends AiBaseCommand {
       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);
+    const outputTargetResult = await resolveOutputTarget(ctx.options.output);
     if (!outputTargetResult.ok) {
       this._outputJsonError(outputTargetResult.code, outputTargetResult.msg);
       return this._makeOk();
@@ -3413,7 +3307,7 @@ var AiVidCommand = class extends AiBaseCommand {
       clearTimeout(timer);
     }
     const bodyText = await response.text().catch(() => "");
-    const payload = parseJsonSafely2(bodyText);
+    const payload = parseJsonSafely(bodyText);
     if (!response.ok) {
       const detail = extractErrorText(payload) ?? bodyText.trim();
       const suffix = detail ? `: ${detail}` : "";
@@ -3459,7 +3353,7 @@ var AiVidCommand = class extends AiBaseCommand {
         continue;
       }
       const bodyText = await response.text().catch(() => "");
-      const payload = parseJsonSafely2(bodyText);
+      const payload = parseJsonSafely(bodyText);
       if (!response.ok) {
         const detail = extractErrorText(payload) ?? bodyText.trim();
         return makeError(
@@ -3494,7 +3388,7 @@ var AiVidCommand = class extends AiBaseCommand {
 function resolveOpenRouterToken() {
   return process.env.OPENROUTER_AK?.trim() || OPENROUTER_AK;
 }
-function parseReferencePaths3(value, previous) {
+function parseReferencePaths2(value, previous) {
   return previous.concat(
     value.split(",").map((item) => item.trim()).filter((item) => item.length > 0)
   );
@@ -3506,7 +3400,7 @@ function parseDuration(value) {
   }
   return parsed;
 }
-function parseJsonSafely2(text) {
+function parseJsonSafely(text) {
   if (!text.trim()) {
     return void 0;
   }
@@ -3558,12 +3452,12 @@ async function appendPollingUrl(pollingUrl, generationId) {
     return makeError(1, `\u5199\u5165 polling \u65E5\u5FD7\u5931\u8D25 ${logFilePath}: ${message}`);
   }
 }
-async function resolveOutputTarget2(outputPath) {
+async function resolveOutputTarget(outputPath) {
   if (!outputPath) {
     const directoryPath = process.cwd();
     return makeOkWith({
       directoryPath,
-      filePath: path9.join(directoryPath, buildAutoFileName2()),
+      filePath: path9.join(directoryPath, buildAutoFileName()),
       autoNamed: true
     });
   }
@@ -3573,7 +3467,7 @@ async function resolveOutputTarget2(outputPath) {
     if (stats.isDirectory()) {
       return makeOkWith({
         directoryPath: resolvedPath,
-        filePath: path9.join(resolvedPath, buildAutoFileName2()),
+        filePath: path9.join(resolvedPath, buildAutoFileName()),
         autoNamed: true
       });
     }
@@ -3597,7 +3491,7 @@ async function resolveOutputTarget2(outputPath) {
     }
     return makeOkWith({
       directoryPath: resolvedPath,
-      filePath: path9.join(resolvedPath, buildAutoFileName2()),
+      filePath: path9.join(resolvedPath, buildAutoFileName()),
       autoNamed: true
     });
   }
@@ -3635,7 +3529,7 @@ async function downloadVideoToFile(remoteUrl, target, token) {
     );
   }
   const bytes = Buffer.from(await response.arrayBuffer());
-  const targetPath = target.autoNamed ? replaceFileExtension2(
+  const targetPath = target.autoNamed ? replaceFileExtension(
     target.filePath,
     inferVideoExtension(remoteUrl, response)
   ) : target.filePath;
@@ -3647,11 +3541,11 @@ async function downloadVideoToFile(remoteUrl, target, token) {
   }
   return makeOkWith(path9.resolve(targetPath));
 }
-function buildAutoFileName2() {
+function buildAutoFileName() {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   return `ai-vid-${timestamp}.mp4`;
 }
-function replaceFileExtension2(filePath, extension) {
+function replaceFileExtension(filePath, extension) {
   const ext = path9.extname(filePath);
   if (!ext) {
     return `${filePath}.${extension}`;
@@ -3681,7 +3575,7 @@ function inferVideoExtension(remoteUrl, response) {
 }
 
 // src/commands/ai/ai-querytask-command.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 var BIN = "xx";
 var PPE_ENV = "ppe_new_login_cli";
 var POLL_INTERVAL_MS2 = 5e3;
@@ -3738,7 +3632,7 @@ var AiQueryTaskCommand = class extends AiBaseCommand {
       "--json"
     ];
     return new Promise((resolve8) => {
-      const child = spawn3(BIN, args, { cwd: process.cwd() });
+      const child = spawn4(BIN, args, { cwd: process.cwd() });
       let stdout = "";
       let stderr = "";
       child.stdout.on("data", (chunk) => {
@@ -3819,7 +3713,7 @@ var AiCommand = class extends BaseSubcommandHost {
     this._addSubcommand(new AiCursorCommand());
     this._addSubcommand(new AiCodexCommand());
     this._addSubcommand(new AiRunCommand());
-    this._addSubcommand(new AiImageCommand());
+    this._addSubcommand(new AiImageCommandV2());
     this._addSubcommand(new AiVideoCommand());
     this._addSubcommand(new AiVidCommand());
     this._addSubcommand(new AiQueryTaskCommand());