jimeng-cli 0.2.0 → 0.3.0

package/dist/cli/index.js

@@ -5,6 +5,7 @@ import {
   generateImageComposition,
   generateImages,
   generateVideo,
+  getAssetList,
   getCredit,
   getLiveModels,
   getTaskResponse,
@@ -12,9 +13,11 @@ import {
   logger_default,
   parseRegionCode,
   receiveCredit,
+  refreshAllTokenModels,
   session_pool_default,
+  upscaleImage,
   waitForTaskResponse
-} from "../chunk-JZY62VNI.js";
+} from "../chunk-2IIK4X7C.js";
 
 // src/cli/app.ts
 import process2 from "process";
@@ -495,6 +498,34 @@ function printTaskInfo(task, deps) {
   }
 }
 function createQueryCommandHandlers(deps) {
+  const handleModelsRefresh = async (argv) => {
+    const args = minimist2(argv, {
+      boolean: ["help", "json"]
+    });
+    if (args.help) {
+      console.log(deps.usageModelsRefresh());
+      return;
+    }
+    await deps.ensureTokenPoolReady();
+    const results = await refreshAllTokenModels();
+    const isJson = Boolean(args.json);
+    if (isJson) {
+      deps.printCommandJson("models.refresh", results);
+      return;
+    }
+    if (results.length === 0) {
+      console.log("No enabled+live tokens found in pool. Nothing to refresh.");
+      return;
+    }
+    console.log(`Refreshed ${results.length} token(s).`);
+    console.log("");
+    console.log("token		region	imageModels	videoModels	capabilityTags	error");
+    for (const r of results) {
+      const tags = r.capabilityTags.length > 0 ? r.capabilityTags.join(",") : "-";
+      const err = r.error ? r.error.slice(0, 60) : "-";
+      console.log(`${r.token}	${r.region}	${r.imageModels}		${r.videoModels}		${tags}	${err}`);
+    }
+  };
   const handleModelsList = async (argv) => {
     const args = minimist2(argv, {
       string: ["region", "token"],
@@ -638,10 +669,62 @@ ${deps.usageTaskWait()}`);
     if (isJson) deps.printCommandJson("task.wait", taskInfo);
     else printTaskInfo(taskInfo, deps);
   };
+  const handleTaskList = async (argv) => {
+    const args = minimist2(argv, {
+      string: ["token", "region", "type", "count"],
+      boolean: ["help", "json"]
+    });
+    if (args.help) {
+      console.log(deps.usageTaskList());
+      return;
+    }
+    const token = deps.getSingleString(args, "token");
+    const region = deps.getRegionWithDefault(args);
+    const type = deps.getSingleString(args, "type");
+    const countRaw = deps.getSingleString(args, "count");
+    const count = countRaw ? Number(countRaw) : 20;
+    const isJson = Boolean(args.json);
+    if (type && type !== "image" && type !== "video" && type !== "all") {
+      deps.fail(`Invalid --type: ${type}. Use image, video, or all.`);
+    }
+    const pick = await deps.pickDirectTokenForTask(token, region);
+    const result = await getAssetList(
+      pick.token,
+      buildRegionInfo(pick.region),
+      {
+        count: Number.isFinite(count) && count > 0 ? count : 20,
+        type
+      }
+    );
+    if (isJson) {
+      deps.printCommandJson("task.list", {
+        has_more: result.hasMore,
+        next_offset: result.nextOffset,
+        total: result.items.length,
+        items: result.items
+      });
+      return;
+    }
+    console.log(`Total: ${result.items.length} items${result.hasMore ? " (more available)" : ""}
+`);
+    for (const item of result.items) {
+      const typeLabel = item.type === 1 ? "IMG" : "VID";
+      const statusLabel = item.status === 144 || item.status === 10 ? "DONE" : item.status === 30 ? "FAIL" : "PROC";
+      const time = item.createdTime > 0 ? new Date(item.createdTime * 1e3).toLocaleString() : "-";
+      const modelShort = item.modelName || item.modelReqKey || "-";
+      const promptShort = item.prompt.length > 50 ? item.prompt.slice(0, 50) + "..." : item.prompt;
+      console.log(`${item.id}  ${typeLabel}  ${statusLabel.padEnd(4)}  ${time}  ${modelShort.padEnd(20)}  ${promptShort}`);
+      if (item.imageUrl) {
+        console.log(`         ${item.imageUrl}`);
+      }
+    }
+  };
   return {
     handleModelsList,
+    handleModelsRefresh,
     handleTaskGet,
     handleTaskWait,
+    handleTaskList,
     printTaskInfo: (task) => {
       const normalized = collectTaskInfo(task, deps);
       if (!normalized) {
@@ -1187,13 +1270,257 @@ function createMediaCommandHandlers(deps) {
       deps.printDownloadSummary("video", [filePath]);
     }
   };
+  const handleImageUpscale = async (argv) => {
+    const args = minimist3(argv, {
+      string: [
+        "token",
+        "region",
+        "image",
+        "model",
+        "resolution",
+        "output-dir",
+        "wait-timeout-seconds",
+        "poll-interval-ms"
+      ],
+      boolean: ["help", "wait", "json"],
+      default: { wait: true }
+    });
+    if (args.help) {
+      console.log(deps.usageImageUpscale());
+      return;
+    }
+    const token = deps.getSingleString(args, "token");
+    const region = deps.getRegionWithDefault(args);
+    const imageSource = deps.getSingleString(args, "image");
+    if (!imageSource) deps.failWithUsage("Missing required --image.", deps.usageImageUpscale());
+    const outputDir = deps.getSingleString(args, "output-dir") || "./pic/cli-image-upscale";
+    const model = deps.getSingleString(args, "model") || "jimeng-5.0";
+    const resolution = deps.getSingleString(args, "resolution") || "4k";
+    const wait = Boolean(args.wait);
+    const isJson = Boolean(args.json);
+    const pick = await deps.pickDirectTokenForGeneration(token, region, model, "image");
+    let image;
+    if (isHttpUrl(imageSource)) {
+      image = imageSource;
+    } else {
+      const imagePath = path3.resolve(imageSource);
+      if (!await pathExists2(imagePath)) deps.fail(`Image file not found: ${imagePath}`);
+      image = await readFile2(imagePath);
+    }
+    const result = await upscaleImage(
+      model,
+      image,
+      {
+        resolution,
+        wait,
+        waitTimeoutSeconds: parsePositiveNumberOption2(args, "wait-timeout-seconds", deps),
+        pollIntervalMs: parsePositiveNumberOption2(args, "poll-interval-ms", deps)
+      },
+      pick.token,
+      buildRegionInfo(pick.region)
+    );
+    if (!Array.isArray(result)) {
+      if (isJson) deps.printCommandJson("image.upscale", result, { wait });
+      else deps.printTaskInfo(result);
+      return;
+    }
+    const urls = result;
+    if (urls.length === 0) deps.fail("No image URL found in response.");
+    const savedFiles = await downloadImages(urls, outputDir, "jimeng-image-upscale", deps);
+    if (isJson) {
+      deps.printCommandJson(
+        "image.upscale",
+        { data: urls.map((url) => ({ url })), files: savedFiles },
+        { wait, resolution }
+      );
+    } else {
+      deps.printDownloadSummary("image", savedFiles);
+    }
+  };
   return {
     handleImageGenerate,
     handleImageEdit,
+    handleImageUpscale,
     handleVideoGenerate
   };
 }
 
+// src/cli/login.ts
+import { execSync, spawn } from "child_process";
+import { existsSync } from "fs";
+import path4 from "path";
+import os from "os";
+import minimist4 from "minimist";
+var LOGIN_SCRIPT = path4.join(__dirname, "..", "..", "scripts", "jimeng_login_helper.py");
+function createLoginCommandHandler(deps) {
+  return async (argv) => {
+    const args = minimist4(argv, {
+      string: ["region", "sessionid", "debug-port"],
+      boolean: ["help", "headless", "json"]
+    });
+    if (args.help) {
+      console.log(usageLogin());
+      return;
+    }
+    const region = deps.getRegionWithDefault(args);
+    const parsedRegion = deps.parseRegionOrFail(region);
+    const isJson = Boolean(args.json);
+    const sessionid = deps.getSingleString(args, "sessionid");
+    const debugPort = deps.getSingleString(args, "debug-port") || "9333";
+    const headless = Boolean(args.headless);
+    if (sessionid) {
+      await addSessionToPool(sessionid, parsedRegion || "cn", deps, isJson);
+      return;
+    }
+    const pythonLoginResult = await tryPythonLogin(debugPort, headless);
+    if (pythonLoginResult) {
+      await addSessionToPool(pythonLoginResult, parsedRegion || "cn", deps, isJson);
+      return;
+    }
+    console.log("");
+    console.log("Auto login not available. Please provide your sessionid manually.");
+    console.log("You can get it from:");
+    console.log("  1. Login at https://jimeng.jianying.com/ai-tool/home/");
+    console.log("  2. Open DevTools > Application > Cookies > sessionid");
+    console.log("");
+    console.log("Then run: jimeng login --sessionid <your_sessionid> --region cn");
+    console.log("");
+    console.log("Or install Python 3 to use the automatic browser login.");
+  };
+}
+async function tryPythonLogin(debugPort, headless) {
+  const loginScript = findLoginScript();
+  if (!loginScript) {
+    return null;
+  }
+  console.log(`Launching browser login (debug port: ${debugPort})...`);
+  console.log("Please complete login in the Chrome window.\n");
+  try {
+    const cmdArgs = [loginScript, "--debug-port", debugPort];
+    if (headless) cmdArgs.push("--headless");
+    const result = await runPythonScript(cmdArgs);
+    const output = result.stdout.trim();
+    const match = output.match(/sessionid:\s*(\S+)/);
+    if (match) {
+      return match[1];
+    }
+    console.log("Login script completed but sessionid not found in output.");
+    return null;
+  } catch (error) {
+    console.log(`Auto login failed: ${error.message}`);
+    return null;
+  }
+}
+function findLoginScript() {
+  if (existsSync(LOGIN_SCRIPT)) {
+    return LOGIN_SCRIPT;
+  }
+  const candidates = [
+    path4.join(process.cwd(), "jimeng_login.py"),
+    path4.join(os.homedir(), ".jimeng_login.py")
+  ];
+  try {
+    const whichResult = execSync("which jimeng_login.py 2>/dev/null || echo ''", { encoding: "utf-8" }).trim();
+    if (whichResult) return whichResult;
+  } catch {
+  }
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function runPythonScript(args) {
+  return new Promise((resolve, reject) => {
+    var _a, _b;
+    const pythonCmd = process.platform === "win32" ? "python" : "python3";
+    const proc = spawn(pythonCmd, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+    let stdout = "";
+    let stderr = "";
+    (_a = proc.stdout) == null ? void 0 : _a.on("data", (data) => {
+      stdout += data.toString();
+      const lines = data.toString().split("\n").filter(Boolean);
+      for (const line of lines) {
+        console.log(line);
+      }
+    });
+    (_b = proc.stderr) == null ? void 0 : _b.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve({ stdout, stderr });
+      } else {
+        reject(new Error(`Login script exited with code ${code}: ${stderr.slice(-200)}`));
+      }
+    });
+    proc.on("error", (error) => {
+      reject(new Error(`Failed to run login script: ${error.message}`));
+    });
+  });
+}
+async function addSessionToPool(sessionid, region, deps, isJson) {
+  await deps.ensureTokenPoolReady();
+  const { added, total } = await session_pool_default.addTokens([sessionid], { defaultRegion: region });
+  if (added > 0) {
+    const masked = sessionid.length > 10 ? `${sessionid.slice(0, 4)}...${sessionid.slice(-4)}` : "***";
+    let creditInfo = "";
+    try {
+      const { totalCredit } = await getCredit(sessionid, buildRegionInfo(region));
+      creditInfo = ` (credits: ${totalCredit})`;
+    } catch {
+      creditInfo = " (credit check failed)";
+    }
+    if (isJson) {
+      deps.printCommandJson("login", {
+        token: masked,
+        region,
+        added: true,
+        total,
+        creditCheck: creditInfo.trim()
+      });
+    } else {
+      console.log(`
+Login successful!`);
+      console.log(`  Token: ${masked}`);
+      console.log(`  Region: ${region}${creditInfo}`);
+      console.log(`  Pool size: ${total} token(s)`);
+    }
+  } else {
+    if (isJson) {
+      deps.printCommandJson("login", {
+        added: false,
+        total,
+        reason: "token already exists in pool"
+      });
+    } else {
+      console.log(`Token already exists in pool. Pool size: ${total} token(s)`);
+    }
+  }
+}
+function usageLogin() {
+  return [
+    "Usage:",
+    "  jimeng login [options]",
+    "",
+    "Options:",
+    "  --region <region>        Region for the token (default cn)",
+    "  --sessionid <token>      Add sessionid directly (skip browser login)",
+    "  --debug-port <port>      Chrome debug port (default 9333)",
+    "  --headless              Run Chrome in headless mode",
+    "  --json                   Output structured JSON",
+    "  --help                   Show help",
+    "",
+    "Notes:",
+    "  - Without --sessionid, launches Chrome for browser login (requires Python 3).",
+    "  - With --sessionid, directly adds the token to the pool.",
+    "  - After login, the token is automatically added to the token pool.",
+    "  - Token is validated by checking credit balance."
+  ].join("\n");
+}
+
 // src/cli/app.ts
 var JSON_OPTION = "  --json                   Output structured JSON";
 var HELP_OPTION = "  --help                   Show help";
@@ -1234,6 +1561,21 @@ function usageModelsList() {
     HELP_OPTION
   ]);
 }
+function usageModelsRefresh() {
+  return buildUsageText("  jimeng models refresh [options]", [
+    "  --json                   Output structured JSON",
+    HELP_OPTION
+  ], [
+    {
+      title: "Notes:",
+      lines: [
+        "  - Refreshes dynamicCapabilities (imageModels, videoModels, capabilityTags) for",
+        "    all enabled+live tokens in the token pool.",
+        "  - Results are persisted to token-pool.json automatically."
+      ]
+    }
+  ]);
+}
 function usageTokenSubcommand(name) {
   const subcommand = TOKEN_SUBCOMMANDS_BY_NAME[name];
   return buildUsageText(subcommand.usageLine, subcommand.options, subcommand.sections);
@@ -1300,6 +1642,34 @@ function usageImageEdit() {
     ]
   );
 }
+function usageImageUpscale() {
+  return buildUsageText(
+    "  jimeng image upscale --image <path_or_url> [options]",
+    [
+      "  --token <token>          Optional, override token-pool selection",
+      "  --region <region>        X-Region header, default cn (cn/us/hk/jp/sg)",
+      "  --image <path_or_url>    Required, local file or URL",
+      "  --model <model>          Default jimeng-5.0",
+      "  --resolution <res>       Default 4k (target resolution)",
+      "  --wait / --no-wait       Default wait; --no-wait returns task only",
+      "  --wait-timeout-seconds   Optional wait timeout override",
+      "  --poll-interval-ms       Optional poll interval override",
+      JSON_OPTION,
+      "  --output-dir <dir>       Default ./pic/cli-image-upscale",
+      HELP_OPTION
+    ],
+    [
+      {
+        title: "Notes:",
+        lines: [
+          "  - Upscales an existing image to higher resolution using super_resolution.",
+          "  - Supports 2k and 4k target resolutions.",
+          "  - Image source can be a local file path or HTTP URL."
+        ]
+      }
+    ]
+  );
+}
 function usageVideoGenerate() {
   return buildUsageText("  jimeng video generate --prompt <text> [options]", [
     "  --token <token>          Optional, override token-pool selection",
@@ -1369,6 +1739,16 @@ function usageTaskWait() {
     HELP_OPTION
   ]);
 }
+function usageTaskList() {
+  return buildUsageText("  jimeng task list [options]", [
+    "  --token <token>          Optional, override token-pool selection",
+    "  --region <region>        X-Region header, default cn (cn/us/hk/jp/sg)",
+    "  --type <type>            Filter by type: image, video, or all (default all)",
+    "  --count <num>            Number of items per page (default 20)",
+    JSON_OPTION,
+    HELP_OPTION
+  ]);
+}
 function configureCliLogging(command) {
   if (process2.env.JIMENG_CLI_VERBOSE_LOGS === "true") {
     process2.env.JIMENG_CLI_SILENT_LOGS = "false";
@@ -1502,8 +1882,10 @@ var TOKEN_SUBCOMMANDS = createTokenSubcommands({
 });
 var queryHandlers = createQueryCommandHandlers({
   usageModelsList,
+  usageModelsRefresh,
   usageTaskGet,
   usageTaskWait,
+  usageTaskList,
   getSingleString,
   getRegionWithDefault,
   parseRegionOrFail,
@@ -1517,6 +1899,7 @@ var queryHandlers = createQueryCommandHandlers({
 var mediaHandlers = createMediaCommandHandlers({
   usageImageGenerate,
   usageImageEdit,
+  usageImageUpscale,
   usageVideoGenerate,
   getSingleString,
   getRegionWithDefault,
@@ -1535,10 +1918,26 @@ function buildHandlersMap(subcommands) {
   return Object.fromEntries(subcommands.map((item) => [item.name, item.handler]));
 }
 var COMMAND_SPECS = [
+  {
+    name: "login",
+    description: "Login and add session to token pool",
+    handler: createLoginCommandHandler({
+      getSingleString,
+      getRegionWithDefault,
+      parseRegionOrFail,
+      ensureTokenPoolReady,
+      fail,
+      printJson,
+      printCommandJson
+    })
+  },
   {
     name: "models",
     description: "Model commands",
-    subcommands: [{ name: "list", description: "List available models", handler: queryHandlers.handleModelsList }],
+    subcommands: [
+      { name: "list", description: "List available models", handler: queryHandlers.handleModelsList },
+      { name: "refresh", description: "Refresh token dynamic capabilities (model list)", handler: queryHandlers.handleModelsRefresh }
+    ],
     usage: usageRoot
   },
   {
@@ -1546,7 +1945,8 @@ var COMMAND_SPECS = [
     description: "Image commands",
     subcommands: [
       { name: "generate", description: "Generate image from text", handler: mediaHandlers.handleImageGenerate },
-      { name: "edit", description: "Edit image(s) with prompt", handler: mediaHandlers.handleImageEdit }
+      { name: "edit", description: "Edit image(s) with prompt", handler: mediaHandlers.handleImageEdit },
+      { name: "upscale", description: "Upscale image to higher resolution", handler: mediaHandlers.handleImageUpscale }
     ],
     usage: usageRoot
   },
@@ -1567,7 +1967,8 @@ var COMMAND_SPECS = [
     description: "Task commands",
     subcommands: [
       { name: "get", description: "Get task status", handler: queryHandlers.handleTaskGet },
-      { name: "wait", description: "Wait until task completion", handler: queryHandlers.handleTaskWait }
+      { name: "wait", description: "Wait until task completion", handler: queryHandlers.handleTaskWait },
+      { name: "list", description: "List task history", handler: queryHandlers.handleTaskList }
     ],
     usage: usageRoot
   },
@@ -1629,7 +2030,7 @@ async function run() {
     failWithUsage(`Unknown command: ${[command, subcommand].filter(Boolean).join(" ")}`, usageRoot());
   }
   if (spec.handler) {
-    await spec.handler(rest);
+    await spec.handler(subcommand ? [subcommand, ...rest] : rest);
     return;
   }
   if (spec.subcommands) {