maoda-commander-tt 0.0.12 → 0.0.14

package/dist/main.js

@@ -2078,9 +2078,9 @@ var ShortcutBaseCommand = class extends BaseCommand {
       stdio: "inherit",
       shell: true
     });
-    return new Promise((resolve4) => {
+    return new Promise((resolve6) => {
       child.on("error", (error) => {
-        resolve4(
+        resolve6(
           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());
+          resolve6(this._makeOk());
           return;
         }
         const signalText = signal ? `, signal: ${signal}` : "";
-        resolve4(
+        resolve6(
           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((resolve6) => {
       child.on("error", (error) => {
-        resolve4(
+        resolve6(
           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());
+          resolve6(this._makeOk());
           return;
         }
         const signalText = signal ? `, signal: ${signal}` : "";
-        resolve4(
+        resolve6(
           this._makeError(
             code ?? 1,
             `\u6267\u884C ${command} ${args.join(" ")} \u5931\u8D25${signalText}`
@@ -2196,6 +2196,9 @@ var AiBaseCommand = class extends BaseCommand {
   }
 };
 
+// src/constants/ak.ts
+var ARK_AK = "6990de07-83be-487d-930d-f5dd3b6d5993";
+
 // src/commands/ai/ai-websearch-command.ts
 var AiWebSearchCommand = class extends AiBaseCommand {
   _meta() {
@@ -2213,7 +2216,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 +2426,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 +2436,525 @@ 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-command.ts
 var AiCommand = class extends BaseSubcommandHost {
   _meta() {
@@ -2446,6 +2968,7 @@ var AiCommand = class extends BaseSubcommandHost {
     this._addSubcommand(new AiCursorCommand());
     this._addSubcommand(new AiCodexCommand());
     this._addSubcommand(new AiRunCommand());
+    this._addSubcommand(new AiImageCommand());
   }
 };