maoda-commander-tt 0.0.14 → 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((resolve6) => {
+    return new Promise((resolve8) => {
       child.on("error", (error) => {
-        resolve6(
+        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) {
-          resolve6(this._makeOk());
+          resolve8(this._makeOk());
           return;
         }
         const signalText = signal ? `, signal: ${signal}` : "";
-        resolve6(
+        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((resolve6) => {
+    return new Promise((resolve8) => {
       child.on("error", (error) => {
-        resolve6(
+        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) {
-          resolve6(this._makeOk());
+          resolve8(this._makeOk());
           return;
         }
         const signalText = signal ? `, signal: ${signal}` : "";
-        resolve6(
+        resolve8(
           this._makeError(
             code ?? 1,
             `\u6267\u884C ${command} ${args.join(" ")} \u5931\u8D25${signalText}`
@@ -2198,6 +2198,7 @@ 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 {
@@ -2955,6 +2956,691 @@ function inferImageExtension(remoteUrl, response) {
   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() {
@@ -2969,6 +3655,8 @@ var AiCommand = class extends BaseSubcommandHost {
     this._addSubcommand(new AiCodexCommand());
     this._addSubcommand(new AiRunCommand());
     this._addSubcommand(new AiImageCommand());
+    this._addSubcommand(new AiVideoCommand());
+    this._addSubcommand(new AiVidCommand());
   }
 };