apkpub-cli 0.0.1-alpha.0

package/dist/apkpub.js

@@ -0,0 +1,2527 @@
+#!/usr/bin/env node
+
+// src/bin/apkpub.ts
+import { Command } from "commander";
+
+// src/cli/init.ts
+import { input, confirm, checkbox } from "@inquirer/prompts";
+
+// src/config/store.ts
+import { mkdir, readFile, readdir, writeFile, chmod, access } from "fs/promises";
+import path from "path";
+import os from "os";
+
+// src/errors/ApkpubError.ts
+var ApkpubError = class extends Error {
+  code;
+  channel;
+  step;
+  retryable;
+  cause;
+  constructor(options) {
+    super(options.message);
+    this.name = "ApkpubError";
+    this.code = options.code;
+    this.channel = options.channel;
+    this.step = options.step;
+    this.retryable = options.retryable ?? isRetryableCode(options.code);
+    this.cause = options.cause;
+  }
+};
+function isRetryableCode(code) {
+  return ["NETWORK_ERROR" /* NETWORK_ERROR */, "TIMEOUT" /* TIMEOUT */, "CHANNEL_UPLOAD_FAILED" /* CHANNEL_UPLOAD_FAILED */].includes(code);
+}
+
+// src/config/schema.ts
+import { z } from "zod";
+var CURRENT_SCHEMA_VERSION = 1;
+var channelParamSchema = z.object({
+  name: z.string(),
+  value: z.string().default("")
+});
+var marketChannelConfigSchema = z.object({
+  name: z.string(),
+  type: z.literal("market").default("market"),
+  enable: z.boolean().default(true),
+  params: z.array(channelParamSchema).default([])
+});
+var ossAuthSchema = z.discriminatedUnion("mode", [
+  z.object({
+    mode: z.literal("ak"),
+    accessKeyId: z.string(),
+    accessKeySecret: z.string()
+  }),
+  z.object({
+    mode: z.literal("sts"),
+    stsTokenUrl: z.string().url(),
+    signKey: z.string(),
+    contextB: z.string().default("{}")
+  })
+]);
+var customChannelConfigSchema = z.object({
+  name: z.string(),
+  type: z.literal("custom"),
+  enable: z.boolean().default(true),
+  uploadType: z.enum(["oss", "http"]),
+  fileNameIdentify: z.string().optional(),
+  endpoint: z.string().optional(),
+  bucket: z.string().optional(),
+  auth: ossAuthSchema.optional(),
+  uploadUrl: z.string().optional(),
+  method: z.enum(["PUT", "POST"]).optional(),
+  headers: z.record(z.string()).optional(),
+  formField: z.string().optional(),
+  objectKeyTemplate: z.string(),
+  downloadUrlTemplate: z.string(),
+  params: z.array(channelParamSchema).default([])
+});
+var channelConfigSchema = z.union([marketChannelConfigSchema, customChannelConfigSchema]);
+var extensionSchema = z.object({
+  updateDesc: z.string().optional(),
+  apkDir: z.string().optional(),
+  urls: z.record(z.string()).optional(),
+  lastVersionCode: z.record(z.number()).optional(),
+  lastVersionName: z.record(z.string()).optional()
+});
+var appConfigSchema = z.object({
+  schemaVersion: z.number().default(CURRENT_SCHEMA_VERSION),
+  name: z.string(),
+  applicationId: z.string(),
+  createTime: z.number(),
+  enableChannel: z.boolean().default(true),
+  channels: z.array(channelConfigSchema).default([]),
+  extension: extensionSchema.default({})
+});
+function paramsToRecord(params) {
+  const record = {};
+  for (const p of params) {
+    record[p.name] = p.value;
+  }
+  return record;
+}
+function migrateConfig(raw) {
+  const obj = raw;
+  if (!obj.schemaVersion) {
+    obj.schemaVersion = 1;
+  }
+  return appConfigSchema.parse(obj);
+}
+function stripSecrets(config) {
+  const sensitiveKeys = [
+    "client_secret",
+    "privateKey",
+    "access_key_secret",
+    "accessKeySecret",
+    "signKey",
+    "password"
+  ];
+  const stripped = structuredClone(config);
+  for (const ch of stripped.channels) {
+    if ("params" in ch) {
+      for (const p of ch.params) {
+        if (sensitiveKeys.some((k) => p.name.toLowerCase().includes(k.toLowerCase()))) {
+          p.value = "";
+        }
+      }
+    }
+    if (ch.type === "custom" && ch.auth) {
+      if (ch.auth.mode === "ak") {
+        ch.auth.accessKeyId = "";
+        ch.auth.accessKeySecret = "";
+      } else {
+        ch.auth.signKey = "";
+      }
+    }
+  }
+  return stripped;
+}
+
+// src/utils/logger.ts
+import pc from "picocolors";
+
+// src/utils/redaction.ts
+function redactMessage(message) {
+  return message.replace(/(client_secret|access_key_secret|privateKey|password|signKey)=[^&\s]+/gi, "$1=***").replace(/Bearer\s+[A-Za-z0-9._-]+/gi, "Bearer ***");
+}
+
+// src/utils/logger.ts
+var jsonMode = false;
+var debugMode = false;
+function setJsonMode(enabled) {
+  jsonMode = enabled;
+}
+function formatMessage(level, tag, message) {
+  const time = (/* @__PURE__ */ new Date()).toISOString();
+  const levelColors = {
+    debug: pc.gray,
+    info: pc.blue,
+    warn: pc.yellow,
+    error: pc.red
+  };
+  return `${pc.dim(time)} ${levelColors[level](level.toUpperCase())} [${tag}] ${redactMessage(message)}`;
+}
+function log(level, tag, message) {
+  if (jsonMode && level !== "error") return;
+  if (level === "debug" && !debugMode) return;
+  const stream = level === "error" ? process.stderr : process.stderr;
+  stream.write(formatMessage(level, tag, message) + "\n");
+}
+var logger = {
+  debug: (tag, message) => log("debug", tag, message),
+  info: (tag, message) => log("info", tag, message),
+  warn: (tag, message) => log("warn", tag, message),
+  error: (tag, message) => log("error", tag, message)
+};
+
+// src/config/store.ts
+var CONFIG_DIR_NAME = ".apkpub";
+function getConfigRoot(debug = false) {
+  const base = path.join(os.homedir(), CONFIG_DIR_NAME);
+  return debug ? path.join(base, "debug") : base;
+}
+function getAppsDir(debug = false) {
+  return path.join(getConfigRoot(debug), "apps");
+}
+function getLogsDir(debug = false) {
+  return path.join(getConfigRoot(debug), "logs");
+}
+async function ensureConfigDirs(debug = false) {
+  const root = getConfigRoot(debug);
+  const apps = getAppsDir(debug);
+  const logs = getLogsDir(debug);
+  await mkdir(apps, { recursive: true, mode: 448 });
+  await mkdir(logs, { recursive: true, mode: 448 });
+  try {
+    await chmod(root, 448);
+  } catch {
+  }
+  await checkPermissions(root);
+}
+async function checkPermissions(dir) {
+  try {
+    const { statSync } = await import("fs");
+    const mode = statSync(dir).mode & 511;
+    if (mode > 448) {
+      logger.warn("config", `\u914D\u7F6E\u76EE\u5F55\u6743\u9650\u8FC7\u5BBD (${mode.toString(8)})\uFF0C\u5EFA\u8BAE chmod 700 ${dir}`);
+    }
+  } catch {
+  }
+}
+function configPath(applicationId, debug = false) {
+  const safe = applicationId.replace(/[^a-zA-Z0-9._-]/g, "_");
+  return path.join(getAppsDir(debug), `${safe}.json`);
+}
+async function saveConfig(config, debug = false) {
+  await ensureConfigDirs(debug);
+  const filePath = configPath(config.applicationId, debug);
+  const content = JSON.stringify(config, null, 2);
+  await writeFile(filePath, content, { mode: 384 });
+  logger.debug("config", `\u5DF2\u4FDD\u5B58\u914D\u7F6E: ${filePath}`);
+}
+async function loadConfig(applicationId, debug = false) {
+  const filePath = configPath(applicationId, debug);
+  try {
+    await access(filePath);
+  } catch {
+    throw new ApkpubError({
+      code: "CONFIG_NOT_FOUND" /* CONFIG_NOT_FOUND */,
+      message: `\u672A\u627E\u5230\u5E94\u7528\u914D\u7F6E: ${applicationId}`,
+      retryable: false
+    });
+  }
+  const content = await readFile(filePath, "utf8");
+  const raw = JSON.parse(content);
+  return migrateConfig(raw);
+}
+async function listConfigs(debug = false) {
+  await ensureConfigDirs(debug);
+  const dir = getAppsDir(debug);
+  let files;
+  try {
+    files = await readdir(dir);
+  } catch {
+    return [];
+  }
+  const configs = [];
+  for (const file of files) {
+    if (!file.endsWith(".json")) continue;
+    try {
+      const content = await readFile(path.join(dir, file), "utf8");
+      configs.push(migrateConfig(JSON.parse(content)));
+    } catch (err) {
+      logger.warn("config", `\u8DF3\u8FC7\u65E0\u6548\u914D\u7F6E ${file}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return configs;
+}
+async function importConfig(filePath, debug = false) {
+  const content = await readFile(filePath, "utf8");
+  const raw = JSON.parse(content);
+  const config = migrateConfig(raw);
+  await saveConfig(config, debug);
+  return config;
+}
+async function exportConfig(applicationId, options = {}) {
+  const config = await loadConfig(applicationId, options.debug);
+  const output = options.includeSecrets ? config : stripSecrets(config);
+  return JSON.stringify(output, null, 2);
+}
+async function writeAuditLog(entry, debug = false) {
+  await ensureConfigDirs(debug);
+  const logFile = path.join(getLogsDir(debug), "audit.log");
+  const line = JSON.stringify({ ...entry, timestamp: (/* @__PURE__ */ new Date()).toISOString() }) + "\n";
+  const { appendFile } = await import("fs/promises");
+  await appendFile(logFile, line, { mode: 384 });
+}
+
+// src/channels/huawei/index.ts
+import { z as z2 } from "zod";
+import { createReadStream } from "fs";
+import path2 from "path";
+
+// src/utils/http.ts
+import axios from "axios";
+var PRIVATE_IP_PATTERNS = [
+  /^localhost$/i,
+  /^127\./,
+  /^10\./,
+  /^172\.(1[6-9]|2\d|3[01])\./,
+  /^192\.168\./,
+  /^0\.0\.0\.0$/,
+  /^\[::1\]$/,
+  /^169\.254\./
+];
+function assertSafeUrl(url, label = "URL") {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new ApkpubError({
+      code: "INVALID_ARGUMENT" /* INVALID_ARGUMENT */,
+      message: `\u65E0\u6548\u7684 ${label}: ${url}`,
+      retryable: false
+    });
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    throw new ApkpubError({
+      code: "SSRF_BLOCKED" /* SSRF_BLOCKED */,
+      message: `${label} \u4EC5\u652F\u6301 http/https \u534F\u8BAE`,
+      retryable: false
+    });
+  }
+  const host = parsed.hostname;
+  if (PRIVATE_IP_PATTERNS.some((p) => p.test(host))) {
+    throw new ApkpubError({
+      code: "SSRF_BLOCKED" /* SSRF_BLOCKED */,
+      message: `${label} \u4E0D\u5141\u8BB8\u6307\u5411\u5185\u7F51\u5730\u5740: ${host}`,
+      retryable: false
+    });
+  }
+}
+function createHttpClient(options) {
+  return axios.create({
+    timeout: options?.timeout ?? 6e4,
+    validateStatus: () => true
+  });
+}
+async function withRetry(fn, options = {}) {
+  const retries = options.retries ?? 3;
+  const delayMs = options.delayMs ?? 1e3;
+  let lastError;
+  for (let i = 0; i <= retries; i++) {
+    if (options.signal?.aborted) {
+      throw new ApkpubError({ code: "TIMEOUT" /* TIMEOUT */, message: "\u64CD\u4F5C\u5DF2\u53D6\u6D88", retryable: false });
+    }
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      const retryable = err instanceof ApkpubError ? err.retryable : true;
+      if (!retryable || i === retries) break;
+      await sleep(delayMs * Math.pow(2, i), options.signal);
+    }
+  }
+  throw lastError;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      reject(new ApkpubError({ code: "TIMEOUT" /* TIMEOUT */, message: "\u64CD\u4F5C\u5DF2\u53D6\u6D88", retryable: false }));
+    });
+  });
+}
+
+// src/channels/huawei/index.ts
+var BASE_URL = "https://connect-api.cloud.huawei.com";
+var credSchema = z2.object({
+  client_id: z2.string().min(1),
+  client_secret: z2.string().min(1)
+});
+async function getToken(clientId, clientSecret) {
+  const client = createHttpClient();
+  const resp = await client.post(`${BASE_URL}/api/oauth2/v1/token`, {
+    client_id: clientId,
+    client_secret: clientSecret,
+    grant_type: "client_credentials"
+  });
+  if (resp.data?.access_token) return resp.data.access_token;
+  throw new ApkpubError({
+    code: "CHANNEL_AUTH_FAILED" /* CHANNEL_AUTH_FAILED */,
+    channel: "huawei",
+    step: "getToken",
+    message: `\u83B7\u53D6 token \u5931\u8D25: ${JSON.stringify(resp.data)}`,
+    retryable: false
+  });
+}
+async function getAppId(clientId, token, packageName) {
+  const client = createHttpClient();
+  const resp = await client.get(`${BASE_URL}/api/publish/v2/appid-list`, {
+    headers: { client_id: clientId, Authorization: `Bearer ${token}` },
+    params: { packageName }
+  });
+  const list = resp.data?.appids ?? resp.data?.list ?? [];
+  if (!list.length) {
+    throw new ApkpubError({
+      code: "CHANNEL_STATE_FAILED" /* CHANNEL_STATE_FAILED */,
+      channel: "huawei",
+      step: "getAppId",
+      message: `\u672A\u627E\u5230\u5305\u540D ${packageName} \u5BF9\u5E94\u7684\u5E94\u7528`,
+      retryable: false
+    });
+  }
+  return list[0].value ?? list[0].id ?? list[0].appId;
+}
+async function getUploadUrl(clientId, token, appId, fileName, contentLength) {
+  const client = createHttpClient();
+  const resp = await client.get(`${BASE_URL}/api/publish/v2/upload-url/for-obs`, {
+    headers: { client_id: clientId, Authorization: `Bearer ${token}` },
+    params: { appId, fileName, contentLength }
+  });
+  const urlInfo = resp.data?.urlInfo ?? resp.data?.url;
+  if (!urlInfo?.url) {
+    throw new ApkpubError({
+      code: "CHANNEL_UPLOAD_FAILED" /* CHANNEL_UPLOAD_FAILED */,
+      channel: "huawei",
+      step: "getUploadUrl",
+      message: `\u83B7\u53D6\u4E0A\u4F20\u5730\u5740\u5931\u8D25: ${JSON.stringify(resp.data)}`,
+      retryable: true
+    });
+  }
+  const headers = {};
+  if (urlInfo.headers) {
+    for (const h of urlInfo.headers) {
+      headers[h.key ?? h.name] = h.value;
+    }
+  }
+  return { url: urlInfo.url, objectId: urlInfo.objectId, headers };
+}
+async function uploadFile(uploadUrl, headers, filePath, onProgress) {
+  const client = createHttpClient({ timeout: 6e5 });
+  const stream = createReadStream(filePath);
+  const resp = await client.put(uploadUrl, stream, {
+    headers: { ...headers, "Content-Type": "application/octet-stream" },
+    maxBodyLength: Infinity,
+    onUploadProgress: (e) => {
+      if (e.total) onProgress(Math.round(e.loaded / e.total * 100));
+    }
+  });
+  if (resp.status < 200 || resp.status >= 300) {
+    throw new ApkpubError({
+      code: "CHANNEL_UPLOAD_FAILED" /* CHANNEL_UPLOAD_FAILED */,
+      channel: "huawei",
+      step: "uploadFile",
+      message: `\u4E0A\u4F20\u5931\u8D25 HTTP ${resp.status}`,
+      retryable: resp.status >= 500
+    });
+  }
+}
+async function bindApk(clientId, token, appId, fileName, objectId) {
+  const client = createHttpClient();
+  const resp = await client.put(
+    `${BASE_URL}/api/publish/v2/app-file-info`,
+    { fileType: 5, files: [{ fileName, fileDestUrl: objectId }] },
+    { headers: { client_id: clientId, Authorization: `Bearer ${token}` }, params: { appId } }
+  );
+  const pkgId = resp.data?.pkgVersion?.[0]?.pkgId ?? resp.data?.pkgId;
+  if (!pkgId) {
+    throw new ApkpubError({
+      code: "CHANNEL_UPLOAD_FAILED" /* CHANNEL_UPLOAD_FAILED */,
+      channel: "huawei",
+      step: "bindApk",
+      message: `\u7ED1\u5B9A APK \u5931\u8D25: ${JSON.stringify(resp.data)}`,
+      retryable: false
+    });
+  }
+  return { pkgId };
+}
+async function waitApkReady(clientId, token, appId, pkgId, signal) {
+  const client = createHttpClient();
+  const start = Date.now();
+  const timeout = 3 * 60 * 1e3;
+  while (Date.now() - start < timeout) {
+    if (signal.aborted) throw new ApkpubError({ code: "TIMEOUT" /* TIMEOUT */, message: "\u7B49\u5F85\u7F16\u8BD1\u8D85\u65F6", retryable: false });
+    await new Promise((r) => setTimeout(r, 1e4));
+    const resp = await client.get(`${BASE_URL}/api/publish/v2/package/compile/status`, {
+      headers: { client_id: clientId, Authorization: `Bearer ${token}` },
+      params: { appId, pkgIds: pkgId }
+    });
+    const state = resp.data?.pkgStateList?.[0]?.pkgState ?? resp.data?.compileStatus;
+    if (state === 0 || state === "COMPILE_SUCCESS") return;
+  }
+  throw new ApkpubError({
+    code: "TIMEOUT" /* TIMEOUT */,
+    channel: "huawei",
+    step: "waitApkReady",
+    message: "\u7B49\u5F85 APK \u7F16\u8BD1\u8D85\u65F6",
+    retryable: true
+  });
+}
+var huaweiChannel = {
+  name: "huawei",
+  label: "\u534E\u4E3A",
+  type: "market",
+  fileNameIdentify: "HUAWEI",
+  credentialSchema: credSchema,
+  async getMarketState(appId, config) {
+    const creds = credSchema.parse(config);
+    const token = await getToken(creds.client_id, creds.client_secret);
+    const hwAppId = await getAppId(creds.client_id, token, appId);
+    const client = createHttpClient();
+    const resp = await client.get(`${BASE_URL}/api/publish/v2/app-info`, {
+      headers: { client_id: creds.client_id, Authorization: `Bearer ${token}` },
+      params: { appId: hwAppId }
+    });
+    const info = resp.data?.appInfo ?? resp.data;
+    const reviewState = mapReviewState(info?.releaseState ?? info?.status);
+    return {
+      reviewState,
+      enableSubmit: reviewState === "online" || reviewState === "rejected",
+      lastVersionCode: Number(info?.versionCode ?? 0),
+      lastVersionName: String(info?.versionNumber ?? info?.onShelfVersionNumber ?? info?.versionName ?? "0")
+    };
+  },
+  async validateCredentials(config) {
+    const creds = credSchema.parse(config);
+    await getToken(creds.client_id, creds.client_secret);
+  },
+  async upload(ctx) {
+    const creds = credSchema.parse(ctx.config);
+    const fileName = path2.basename(ctx.filePath);
+    ctx.onProgress({ step: "getToken" });
+    const token = await withRetry(() => getToken(creds.client_id, creds.client_secret));
+    ctx.onProgress({ step: "getAppId" });
+    const appId = await getAppId(creds.client_id, token, ctx.apkInfo.applicationId);
+    ctx.onProgress({ step: "getUploadUrl" });
+    const uploadInfo = await getUploadUrl(creds.client_id, token, appId, fileName, ctx.apkInfo.size);
+    ctx.onProgress({ step: "uploading", percent: 0 });
+    await uploadFile(
+      uploadInfo.url,
+      uploadInfo.headers,
+      ctx.filePath,
+      (p) => ctx.onProgress({ step: "uploading", percent: p })
+    );
+    ctx.onProgress({ step: "bindApk" });
+    const bind = await bindApk(creds.client_id, token, appId, fileName, uploadInfo.objectId);
+    ctx.onProgress({ step: "waitCompile" });
+    await waitApkReady(creds.client_id, token, appId, bind.pkgId, ctx.signal);
+    ctx.onProgress({ step: "updateDesc" });
+    const client = createHttpClient();
+    await client.put(
+      `${BASE_URL}/api/publish/v2/app-language-info`,
+      { lang: "zh-CN", appDesc: ctx.desc },
+      { headers: { client_id: creds.client_id, Authorization: `Bearer ${token}` }, params: { appId } }
+    );
+    ctx.onProgress({ step: "submit" });
+    await client.post(`${BASE_URL}/api/publish/v2/app-submit`, null, {
+      headers: { client_id: creds.client_id, Authorization: `Bearer ${token}` },
+      params: { appId }
+    });
+    ctx.onProgress({ step: "done", percent: 100 });
+    return { message: "\u63D0\u4EA4\u5BA1\u6838\u6210\u529F" };
+  }
+};
+function mapReviewState(state) {
+  const s = Number(state);
+  if (s === 0 || s === 7) return "online";
+  if (s === 4 || s === 5) return "reviewing";
+  if (s === 1 || s === 8 || s === 9) return "rejected";
+  return "unknown";
+}
+
+// src/channels/honor/index.ts
+import { z as z3 } from "zod";
+import { createReadStream as createReadStream3 } from "fs";
+import path4 from "path";
+import FormData from "form-data";
+
+// src/utils/files.ts
+import { createHash } from "crypto";
+import { createReadStream as createReadStream2 } from "fs";
+import { readdir as readdir2, stat } from "fs/promises";
+import path3 from "path";
+async function fileMd5(filePath) {
+  return hashFile(filePath, "md5");
+}
+async function fileSha256(filePath) {
+  return hashFile(filePath, "sha256");
+}
+async function hashFile(filePath, algorithm) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash(algorithm);
+    const stream = createReadStream2(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+}
+async function listApkFiles(dir) {
+  const entries = await readdir2(dir);
+  const apks = [];
+  for (const entry of entries) {
+    const full = path3.join(dir, entry);
+    const info = await stat(full);
+    if (info.isFile() && entry.toLowerCase().endsWith(".apk")) {
+      apks.push(full);
+    }
+  }
+  return apks;
+}
+async function fileSize(filePath) {
+  const info = await stat(filePath);
+  return info.size;
+}
+
+// src/channels/honor/index.ts
+var BASE_URL2 = "https://appmarket-openapi-drcn.cloud.honor.com";
+var TOKEN_URL = "https://iam.developer.honor.com/auth/token";
+var credSchema2 = z3.object({
+  client_id: z3.string().min(1),
+  client_secret: z3.string().min(1)
+});
+async function getToken2(clientId, clientSecret) {
+  const client = createHttpClient();
+  const resp = await client.post(
+    TOKEN_URL,
+    new URLSearchParams({
+      client_id: clientId,
+      client_secret: clientSecret,
+      grant_type: "client_credentials"
+    }).toString(),
+    { headers: { "content-type": "application/x-www-form-urlencoded" } }
+  );
+  if (resp.data?.access_token) return resp.data.access_token;
+  throw new ApkpubError({
+    code: "CHANNEL_AUTH_FAILED" /* CHANNEL_AUTH_FAILED */,
+    channel: "honor",
+    step: "getToken",
+    message: `\u83B7\u53D6 token \u5931\u8D25`,
+    retryable: false
+  });
+}
+async function getAppId2(token, packageName) {
+  const client = createHttpClient();
+  const resp = await client.get(`${BASE_URL2}/openapi/v1/publish/get-app-id`, {
+    headers: { Authorization: `Bearer ${token}` },
+    params: { pkgName: packageName }
+  });
+  checkHonorResult(resp.data, "getAppId");
+  const list = resp.data.data ?? [];
+  if (!list.length) {
+    throw new ApkpubError({
+      code: "CHANNEL_STATE_FAILED" /* CHANNEL_STATE_FAILED */,
+      channel: "honor",
+      message: `\u672A\u627E\u5230\u5305\u540D ${packageName}`,
+      retryable: false
+    });
+  }
+  return list[0].appId;
+}
+function checkHonorResult(data, action) {
+  if (data.code !== 0) {
+    throw new ApkpubError({
+      code: "CHANNEL_UPLOAD_FAILED" /* CHANNEL_UPLOAD_FAILED */,
+      channel: "honor",
+      step: action,
+      message: data.message ?? `\u8363\u8000 API \u5931\u8D25: code=${data.code}`,
+      retryable: false
+    });
+  }
+}
+var honorChannel = {
+  name: "honor",
+  label: "\u8363\u8000",
+  type: "market",
+  fileNameIdentify: "HONOR",
+  credentialSchema: credSchema2,
+  async getMarketState(appId, config) {
+    const creds = credSchema2.parse(config);
+    const token = await getToken2(creds.client_id, creds.client_secret);
+    const honorAppId = await getAppId2(token, appId);
+    const client = createHttpClient();
+    const resp = await client.get(`${BASE_URL2}/openapi/v1/publish/get-app-current-release`, {
+      headers: { Authorization: `Bearer ${token}` },
+      params: { appId: honorAppId }
+    });
+    checkHonorResult(resp.data, "getReviewState");
+    const data = resp.data.data;
+    return {
+      reviewState: data?.auditStatus === 1 ? "online" : data?.auditStatus === 2 ? "reviewing" : "unknown",
+      enableSubmit: true,
+      lastVersionCode: Number(data?.versionCode ?? 0),
+      lastVersionName: String(data?.versionName ?? "0")
+    };
+  },
+  async validateCredentials(config) {
+    const creds = credSchema2.parse(config);
+    await getToken2(creds.client_id, creds.client_secret);
+  },
+  async upload(ctx) {
+    const creds = credSchema2.parse(ctx.config);
+    const fileName = path4.basename(ctx.filePath);
+    ctx.onProgress({ step: "getToken" });
+    const token = await getToken2(creds.client_id, creds.client_secret);
+    const auth = `Bearer ${token}`;
+    ctx.onProgress({ step: "getAppId" });
+    const appId = await getAppId2(token, ctx.apkInfo.applicationId);
+    const client = createHttpClient();
+    ctx.onProgress({ step: "getAppInfo" });
+    const appInfoResp = await client.get(`${BASE_URL2}/openapi/v1/publish/get-app-detail`, {
+      headers: { Authorization: auth },
+      params: { appId }
+    });
+    checkHonorResult(appInfoResp.data, "getAppInfo");
+    const langInfo = appInfoResp.data.data?.languageInfo?.[0] ?? {};
+    ctx.onProgress({ step: "getUploadUrl" });
+    const sha256 = await fileSha256(ctx.filePath);
+    const uploadUrlResp = await client.post(
+      `${BASE_URL2}/openapi/v1/publish/get-file-upload-url`,
+      [{ fileName, fileType: 100, fileSize: ctx.apkInfo.size, fileSha256: sha256 }],
+      { headers: { Authorization: auth }, params: { appId } }
+    );
+    checkHonorResult(uploadUrlResp.data, "getUploadUrl");
+    const uploadInfo = uploadUrlResp.data.data[0];
+    ctx.onProgress({ step: "uploading", percent: 0 });
+    const form = new FormData();
+    form.append("file", createReadStream3(ctx.filePath), { filename: fileName });
+    const uploadResp = await client.post(uploadInfo.url, form, {
+      headers: { Authorization: auth, ...form.getHeaders() },
+      maxBodyLength: Infinity,
+      onUploadProgress: (e) => {
+        if (e.total) ctx.onProgress({ step: "uploading", percent: Math.round(e.loaded / e.total * 100) });
+      }
+    });
+    if (uploadResp.data?.code !== 0 && uploadResp.status >= 400) {
+      throw new ApkpubError({
+        code: "CHANNEL_UPLOAD_FAILED" /* CHANNEL_UPLOAD_FAILED */,
+        channel: "honor",
+        step: "uploadFile",
+        message: "\u4E0A\u4F20\u6587\u4EF6\u5931\u8D25",
+        retryable: true
+      });
+    }
+    ctx.onProgress({ step: "bindApk" });
+    await client.post(
+      `${BASE_URL2}/openapi/v1/publish/update-file-info`,
+      { fileInfoList: [{ objectId: uploadInfo.objectId }] },
+      { headers: { Authorization: auth }, params: { appId } }
+    );
+    ctx.onProgress({ step: "updateDesc" });
+    await client.post(
+      `${BASE_URL2}/openapi/v1/publish/update-language-info`,
+      {
+        languageInfoList: [{
+          appName: langInfo.appName,
+          intro: langInfo.intro,
+          desc: ctx.desc,
+          briefIntro: langInfo.briefIntro
+        }]
+      },
+      { headers: { Authorization: auth }, params: { appId } }
+    );
+    ctx.onProgress({ step: "submit" });
+    await client.post(`${BASE_URL2}/openapi/v1/publish/submit-audit`, { releaseType: 1 }, {
+      headers: { Authorization: auth },
+      params: { appId }
+    });
+    ctx.onProgress({ step: "done", percent: 100 });
+    return { message: "\u63D0\u4EA4\u5BA1\u6838\u6210\u529F" };
+  }
+};
+
+// src/channels/mi/index.ts
+import { z as z4 } from "zod";
+import { createReadStream as createReadStream4 } from "fs";
+import FormData2 from "form-data";
+
+// src/signers/rsa.ts
+import { createPublicKey, publicEncrypt, constants } from "crypto";
+var GROUP_SIZE = 128;
+var ENCRYPT_GROUP_SIZE = GROUP_SIZE - 11;
+function rsaEncrypt(content, publicKeyPem) {
+  const pem = normalizePublicKey(publicKeyPem);
+  const publicKey = createPublicKey(pem);
+  const data = Buffer.from(content, "utf8");
+  const chunks = [];
+  let offset = 0;
+  while (offset < data.length) {
+    const remain = data.length - offset;
+    const segSize = Math.min(remain, ENCRYPT_GROUP_SIZE);
+    const segment = data.subarray(offset, offset + segSize);
+    const encrypted = publicEncrypt(
+      { key: publicKey, padding: constants.RSA_PKCS1_PADDING },
+      segment
+    );
+    chunks.push(encrypted);
+    offset += segSize;
+  }
+  return Buffer.concat(chunks).toString("hex");
+}
+function normalizePublicKey(key) {
+  const trimmed = key.trim();
+  if (trimmed.includes("BEGIN CERTIFICATE")) {
+    return trimmed;
+  }
+  if (trimmed.includes("BEGIN PUBLIC KEY")) {
+    return trimmed;
+  }
+  return `-----BEGIN CERTIFICATE-----
+${trimmed}
+-----END CERTIFICATE-----`;
+}
+
+// src/signers/md5.ts
+import { createHash as createHash2 } from "crypto";
+function md5Hex(input2) {
+  return createHash2("md5").update(input2, "utf8").digest("hex");
+}
+function md5Sign(data, signKey) {
+  return md5Hex(data + signKey);
+}
+
+// src/channels/mi/index.ts
+var DOMAIN = "https://api.developer.xiaomi.com/devupload";
+var QUERY_URL = `${DOMAIN}/dev/query`;
+var PUSH_URL = `${DOMAIN}/dev/push`;
+var credSchema3 = z4.object({
+  account: z4.string().min(1),
+  publicKey: z4.string().min(1),
+  privateKey: z4.string().min(1)
+});
+function buildSig(privateKey, hashes) {
+  const sig = JSON.stringify({
+    password: privateKey,
+    sig: hashes.map((h) => ({ name: h.name, hash: h.hash }))
+  });
+  return sig;
+}
+var miChannel = {
+  name: "mi",
+  label: "\u5C0F\u7C73",
+  type: "market",
+  fileNameIdentify: "MI",
+  credentialSchema: credSchema3,
+  async getMarketState(appId, config) {
+    const creds = credSchema3.parse(config);
+    const requestData = JSON.stringify({ userName: creds.account, packageName: appId });
+    const sigData = buildSig(creds.privateKey, [{ name: "RequestData", hash: md5Hex(requestData) }]);
+    const client = createHttpClient();
+    const form = new URLSearchParams();
+    form.set("RequestData", requestData);
+    form.set("SIG", rsaEncrypt(sigData, creds.publicKey));
+    const resp = await client.post(QUERY_URL, form.toString(), {
+      headers: { "content-type": "application/x-www-form-urlencoded" }
+    });
+    checkMiResult(resp.data, "\u83B7\u53D6App\u4FE1\u606F");
+    const info = resp.data.packageInfo ?? resp.data;
+    return {
+      reviewState: "online",
+      enableSubmit: true,
+      lastVersionCode: Number(info?.versionCode ?? 0),
+      lastVersionName: String(info?.versionName ?? "0")
+    };
+  },
+  async validateCredentials(config) {
+    credSchema3.parse(config);
+  },
+  async upload(ctx) {
+    const creds = credSchema3.parse(ctx.config);
+    ctx.onProgress({ step: "getAppInfo" });
+    const marketState = await miChannel.getMarketState(ctx.apkInfo.applicationId, ctx.config);
+    const requestData = JSON.stringify({
+      userName: creds.account,
+      synchroType: 1,
+      appInfo: {
+        appName: marketState?.lastVersionName ?? ctx.apkInfo.versionName,
+        packageName: ctx.apkInfo.applicationId,
+        updateDesc: ctx.desc
+      }
+    });
+    const apkHash = await fileMd5(ctx.filePath);
+    const sigData = buildSig(creds.privateKey, [
+      { name: "RequestData", hash: md5Hex(requestData) },
+      { name: "apk", hash: apkHash }
+    ]);
+    ctx.onProgress({ step: "uploading", percent: 0 });
+    const form = new FormData2();
+    form.append("apk", createReadStream4(ctx.filePath), { filename: "app.apk" });
+    form.append("RequestData", requestData);
+    form.append("SIG", rsaEncrypt(sigData, creds.publicKey));
+    const client = createHttpClient({ timeout: 6e5 });
+    const resp = await client.post(PUSH_URL, form, {
+      headers: form.getHeaders(),
+      maxBodyLength: Infinity,
+      onUploadProgress: (e) => {
+        if (e.total) ctx.onProgress({ step: "uploading", percent: Math.round(e.loaded / e.total * 100) });
+      }
+    });
+    checkMiResult(resp.data, "\u4E0A\u4F20Apk");
+    ctx.onProgress({ step: "done", percent: 100 });
+    return { message: "\u63D0\u4EA4\u6210\u529F" };
+  }
+};
+function checkMiResult(data, action) {
+  if (data.result !== 0) {
+    throw new ApkpubError({
+      code: "CHANNEL_UPLOAD_FAILED" /* CHANNEL_UPLOAD_FAILED */,
+      channel: "mi",
+      message: `${action}\u5931\u8D25: ${data.message ?? "\u672A\u77E5\u9519\u8BEF"}`,
+      retryable: false
+    });
+  }
+}
+
+// src/channels/oppo/index.ts
+import { z as z5 } from "zod";
+import { createReadStream as createReadStream5 } from "fs";
+import FormData3 from "form-data";
+
+// src/signers/hmac.ts
+import { createHmac } from "crypto";
+function hmacSha256(data, secret) {
+  return createHmac("sha256", secret).update(data, "utf8").digest("hex");
+}
+function signSortedParams(params, secret) {
+  const keys = Object.keys(params).sort();
+  const pairs = keys.filter((k) => params[k] !== void 0 && params[k] !== null).map((k) => `${k}=${params[k]}`);
+  return hmacSha256(pairs.join("&"), secret);
+}
+function vivoSignParams(accessKey, accessSecret, method, originParams) {
+  const params = { ...originParams };
+  params.access_key = accessKey;
+  params.timestamp = String(Date.now());
+  params.method = method;
+  params.v = "1.0";
+  params.sign_method = "HMAC-SHA256";
+  params.format = "json";
+  params.target_app_key = "developer";
+  const keys = Object.keys(params).sort();
+  const data = keys.map((k) => `${k}=${params[k]}`).join("&");
+  params.sign = hmacSha256(data, accessSecret);
+  return params;
+}
+
+// src/channels/oppo/index.ts
+var DOMAIN2 = "https://oop-openapi-cn.heytapmobi.com";
+var credSchema4 = z5.object({
+  client_id: z5.string().min(1),
+  client_secret: z5.string().min(1)
+});
+function buildSignedUrl(originUrl, params, token, clientSecret, appendQuery) {
+  const timestamp = String(Math.floor(Date.now() / 1e3));
+  const allParams = { ...params, access_token: token, timestamp };
+  const url = new URL(originUrl);
+  if (appendQuery) {
+    for (const [k, v] of Object.entries(allParams)) {
+      url.searchParams.set(k, v);
+    }
+  }
+  url.searchParams.set("access_token", token);
+  url.searchParams.set("timestamp", timestamp);
+  url.searchParams.set("api_sign", signSortedParams(allParams, clientSecret));
+  return url.toString();
+}
+var oppoChannel = {
+  name: "oppo",
+  label: "OPPO",
+  type: "market",
+  fileNameIdentify: "OPPO",
+  credentialSchema: credSchema4,
+  async getMarketState(appId, config) {
+    const creds = credSchema4.parse(config);
+    const token = await getToken3(creds);
+    const client = createHttpClient();
+    const url = buildSignedUrl(`${DOMAIN2}/resource/v1/app/info`, { pkg_name: appId }, token, creds.client_secret, true);
+    const resp = await client.get(url);
+    checkOppoResult(resp.data, "\u83B7\u53D6App\u4FE1\u606F");
+    const data = resp.data.data;
+    return {
+      reviewState: "online",
+      enableSubmit: true,
+      lastVersionCode: Number(data?.version_code ?? 0),
+      lastVersionName: String(data?.version_name ?? "0")
+    };
+  },
+  async validateCredentials(config) {
+    const creds = credSchema4.parse(config);
+    await getToken3(creds);
+  },
+  async upload(ctx) {
+    const creds = credSchema4.parse(ctx.config);
+    ctx.onProgress({ step: "getToken" });
+    const token = await getToken3(creds);
+    const client = createHttpClient();
+    ctx.onProgress({ step: "getAppInfo" });
+    const appInfoUrl = buildSignedUrl(
+      `${DOMAIN2}/resource/v1/app/info`,
+      { pkg_name: ctx.apkInfo.applicationId },
+      token,
+      creds.client_secret,
+      true
+    );
+    const appInfoResp = await client.get(appInfoUrl);
+    checkOppoResult(appInfoResp.data, "\u83B7\u53D6App\u4FE1\u606F");
+    const appInfo = appInfoResp.data.data;
+    ctx.onProgress({ step: "getUploadUrl" });
+    const uploadUrlResp = await client.get(
+      buildSignedUrl(`${DOMAIN2}/resource/v1/upload/get-upload-url`, {}, token, creds.client_secret, true)
+    );
+    checkOppoResult(uploadUrlResp.data, "\u83B7\u53D6\u4E0A\u4F20url");
+    const { upload_url: rawUploadUrl, sign } = uploadUrlResp.data.data;
+    ctx.onProgress({ step: "uploading", percent: 0 });
+    const signedUploadUrl = buildSignedUrl(
+      rawUploadUrl,
+      { type: "apk", sign },
+      token,
+      creds.client_secret,
+      false
+    );
+    const form = new FormData3();
+    form.append("file", createReadStream5(ctx.filePath), { filename: "app.apk" });
+    form.append("type", "apk");
+    form.append("sign", sign);
+    const uploadResp = await client.post(signedUploadUrl, form, {
+      headers: form.getHeaders(),
+      maxBodyLength: Infinity,
+      onUploadProgress: (e) => {
+        if (e.total) ctx.onProgress({ step: "uploading", percent: Math.round(e.loaded / e.total * 100) });
+      }
+    });
+    checkOppoResult(uploadResp.data, "\u4E0A\u4F20Apk");
+    const apkResult = uploadResp.data.data;
+    ctx.onProgress({ step: "submit" });
+    const apkUrl = JSON.stringify([{ url: apkResult.url, md5: apkResult.md5, cpu_code: 0 }]);
+    const submitParams = {
+      pkg_name: ctx.apkInfo.applicationId,
+      version_code: String(ctx.apkInfo.versionCode),
+      apk_url: apkUrl,
+      update_desc: ctx.desc,
+      online_type: "1",
+      second_category_id: String(appInfo.second_category_id ?? appInfo.secondCategory ?? ""),
+      third_category_id: String(appInfo.third_category_id ?? appInfo.thirdCategory ?? ""),
+      summary: appInfo.summary ?? "",
+      detail_desc: appInfo.detail_desc ?? appInfo.detailDesc ?? "",
+      privacy_source_url: appInfo.privacy_source_url ?? appInfo.privacyUrl ?? "",
+      icon_url: appInfo.icon_url ?? appInfo.iconUrl ?? "",
+      pic_url: appInfo.pic_url ?? appInfo.picUrl ?? "",
+      test_desc: appInfo.test_desc ?? appInfo.testDesc ?? "",
+      business_username: appInfo.business_username ?? appInfo.businessUsername ?? "",
+      business_email: appInfo.business_email ?? appInfo.businessEmail ?? "",
+      business_mobile: appInfo.business_mobile ?? appInfo.businessMobile ?? "",
+      copyright_url: appInfo.copyright_url ?? appInfo.copyrightUrl ?? ""
+    };
+    const submitUrl = buildSignedUrl(`${DOMAIN2}/resource/v1/app/upd`, submitParams, token, creds.client_secret, false);
+    const submitForm = new URLSearchParams(submitParams);
+    const submitResp = await client.post(submitUrl, submitForm.toString(), {
+      headers: { "content-type": "application/x-www-form-urlencoded" }
+    });
+    checkOppoResult(submitResp.data, "\u63D0\u4EA4\u7248\u672C");
+    ctx.onProgress({ step: "done", percent: 100 });
+    return { message: "\u63D0\u4EA4\u6210\u529F" };
+  }
+};
+async function getToken3(creds) {
+  const client = createHttpClient();
+  const resp = await client.get(`${DOMAIN2}/developer/v1/token`, {
+    params: { client_id: creds.client_id, client_secret: creds.client_secret }
+  });
+  checkOppoResult(resp.data, "\u83B7\u53D6token");
+  return resp.data.data.access_token;
+}
+function checkOppoResult(data, action) {
+  if (data.errno !== 0) {
+    throw new ApkpubError({
+      code: "CHANNEL_UPLOAD_FAILED" /* CHANNEL_UPLOAD_FAILED */,
+      channel: "oppo",
+      message: `${action}\u5931\u8D25: ${data.data?.message ?? "\u672A\u77E5\u9519\u8BEF"}`,
+      retryable: false
+    });
+  }
+}
+
+// src/channels/vivo/index.ts
+import { z as z6 } from "zod";
+import { createReadStream as createReadStream6 } from "fs";
+import FormData4 from "form-data";
+var DOMAIN3 = "https://developer-api.vivo.com.cn/router/rest";
+var credSchema5 = z6.object({
+  access_key: z6.string().min(1),
+  access_secret: z6.string().min(1)
+});
+function buildUrl(method, params, accessKey, accessSecret) {
+  const signed = vivoSignParams(accessKey, accessSecret, method, params);
+  const url = new URL(DOMAIN3);
+  for (const [k, v] of Object.entries(signed)) {
+    url.searchParams.set(k, v);
+  }
+  return url.toString();
+}
+var vivoChannel = {
+  name: "vivo",
+  label: "VIVO",
+  type: "market",
+  fileNameIdentify: "VIVO",
+  credentialSchema: credSchema5,
+  async getMarketState(appId, config) {
+    const creds = credSchema5.parse(config);
+    const client = createHttpClient();
+    const url = buildUrl("app.query.details", { packageName: appId }, creds.access_key, creds.access_secret);
+    const resp = await client.get(url);
+    checkVivoResult(resp.data, "\u67E5\u8BE2\u5E94\u7528\u8BE6\u60C5");
+    const data = resp.data.data;
+    return {
+      reviewState: "online",
+      enableSubmit: true,
+      lastVersionCode: Number(data?.versionCode ?? 0),
+      lastVersionName: String(data?.versionName ?? "0")
+    };
+  },
+  async validateCredentials(config) {
+    credSchema5.parse(config);
+  },
+  async upload(ctx) {
+    const creds = credSchema5.parse(ctx.config);
+    const client = createHttpClient({ timeout: 6e5 });
+    ctx.onProgress({ step: "getAppInfo" });
+    const appInfoUrl = buildUrl(
+      "app.query.details",
+      { packageName: ctx.apkInfo.applicationId },
+      creds.access_key,
+      creds.access_secret
+    );
+    const appInfoResp = await client.get(appInfoUrl);
+    checkVivoResult(appInfoResp.data, "\u67E5\u8BE2\u5E94\u7528\u8BE6\u60C5");
+    const appInfo = appInfoResp.data.data;
+    ctx.onProgress({ step: "uploading", percent: 0 });
+    const fileMd5Hash = await fileMd5(ctx.filePath);
+    const uploadUrl = buildUrl(
+      "app.upload.apk.app",
+      { packageName: ctx.apkInfo.applicationId, fileMd5: fileMd5Hash },
+      creds.access_key,
+      creds.access_secret
+    );
+    const form = new FormData4();
+    form.append("file", createReadStream6(ctx.filePath), { filename: "app.apk" });
+    const uploadResp = await client.post(uploadUrl, form, {
+      headers: form.getHeaders(),
+      maxBodyLength: Infinity,
+      onUploadProgress: (e) => {
+        if (e.total) ctx.onProgress({ step: "uploading", percent: Math.round(e.loaded / e.total * 100) });
+      }
+    });
+    checkVivoResult(uploadResp.data, "\u4E0A\u4F20apk");
+    const apkResult = uploadResp.data.data;
+    ctx.onProgress({ step: "submit" });
+    const submitUrl = buildUrl(
+      "app.sync.update.app",
+      {
+        packageName: apkResult.packageName,
+        versionCode: String(apkResult.versionCode),
+        apk: apkResult.serialnumber,
+        fileMd5: apkResult.fileMd5,
+        onlineType: String(appInfo.onlineType ?? 1),
+        updateDesc: ctx.desc
+      },
+      creds.access_key,
+      creds.access_secret
+    );
+    const submitResp = await client.get(submitUrl);
+    checkVivoResult(submitResp.data, "\u63D0\u4EA4\u66F4\u65B0");
+    ctx.onProgress({ step: "done", percent: 100 });
+    return { message: "\u63D0\u4EA4\u6210\u529F" };
+  }
+};
+function checkVivoResult(data, action) {
+  const subCode = Number(data.subCode ?? -1);
+  if (data.code !== 0 || subCode !== 0) {
+    throw new ApkpubError({
+      code: "CHANNEL_UPLOAD_FAILED" /* CHANNEL_UPLOAD_FAILED */,
+      channel: "vivo",
+      message: `${action}\u5931\u8D25: ${data.msg ?? "\u672A\u77E5\u9519\u8BEF"}`,
+      retryable: false
+    });
+  }
+}
+
+// src/channels/custom/oss.ts
+import OSS from "ali-oss";
+import path5 from "path";
+
+// src/utils/template.ts
+var PLACEHOLDER_RE = /\{(\w+)\}/g;
+function renderTemplate(template, ctx) {
+  const rendered = template.replace(PLACEHOLDER_RE, (_, key) => {
+    const map = {
+      appId: ctx.appId,
+      versionName: ctx.versionName,
+      versionCode: ctx.versionCode,
+      fileName: ctx.fileName,
+      objectKey: ctx.objectKey ?? ""
+    };
+    const value = map[key];
+    if (value === void 0) return `{${key}}`;
+    return String(value);
+  });
+  return sanitizePath(rendered);
+}
+function sanitizePath(path8) {
+  const normalized = path8.replace(/\\/g, "/");
+  if (normalized.includes("..") || normalized.startsWith("/")) {
+    throw new ApkpubError({
+      code: "INVALID_ARGUMENT" /* INVALID_ARGUMENT */,
+      message: `\u8DEF\u5F84\u6A21\u677F\u5305\u542B\u975E\u6CD5\u5B57\u7B26: ${path8}`,
+      retryable: false
+    });
+  }
+  return normalized.replace(/^\/+/, "");
+}
+
+// src/channels/custom/oss.ts
+async function fetchStsToken(stsTokenUrl, signKey, contextB) {
+  assertSafeUrl(stsTokenUrl, "STS Token URL");
+  const sign = md5Sign(contextB, signKey);
+  const client = createHttpClient();
+  const response = await client.post(
+    stsTokenUrl,
+    new URLSearchParams({ c: JSON.stringify({ mode: "text" }), b: contextB, sign }).toString(),
+    { headers: { "content-type": "application/x-www-form-urlencoded" } }
+  );
+  if (response.status !== 200) {
+    throw new ApkpubError({
+      code: "CHANNEL_AUTH_FAILED" /* CHANNEL_AUTH_FAILED */,
+      message: `\u83B7\u53D6 STS Token \u5931\u8D25: HTTP ${response.status}`,
+      retryable: response.status >= 500
+    });
+  }
+  const data = response.data?.data;
+  if (!data?.AccessKeyId) {
+    throw new ApkpubError({
+      code: "CHANNEL_AUTH_FAILED" /* CHANNEL_AUTH_FAILED */,
+      message: "STS Token \u54CD\u5E94\u683C\u5F0F\u65E0\u6548",
+      retryable: false
+    });
+  }
+  return {
+    accessKeyId: data.AccessKeyId,
+    accessKeySecret: data.AccessKeySecret,
+    securityToken: data.SecurityToken,
+    expiration: data.Expiration
+  };
+}
+async function createOssClient(config) {
+  if (!config.endpoint || !config.bucket) {
+    throw new ApkpubError({
+      code: "CONFIG_INVALID" /* CONFIG_INVALID */,
+      message: "OSS \u6E20\u9053\u9700\u8981\u914D\u7F6E endpoint \u548C bucket",
+      retryable: false
+    });
+  }
+  assertSafeUrl(config.endpoint.startsWith("http") ? config.endpoint : `https://${config.endpoint}`, "OSS endpoint");
+  if (!config.auth) {
+    throw new ApkpubError({
+      code: "CONFIG_INVALID" /* CONFIG_INVALID */,
+      message: "OSS \u6E20\u9053\u9700\u8981\u914D\u7F6E auth",
+      retryable: false
+    });
+  }
+  if (config.auth.mode === "ak") {
+    return new OSS({
+      region: extractRegion(config.endpoint),
+      accessKeyId: config.auth.accessKeyId,
+      accessKeySecret: config.auth.accessKeySecret,
+      bucket: config.bucket,
+      endpoint: config.endpoint
+    });
+  }
+  const sts = await fetchStsToken(config.auth.stsTokenUrl, config.auth.signKey, config.auth.contextB);
+  return new OSS({
+    region: extractRegion(config.endpoint),
+    accessKeyId: sts.accessKeyId,
+    accessKeySecret: sts.accessKeySecret,
+    stsToken: sts.securityToken,
+    bucket: config.bucket,
+    endpoint: config.endpoint,
+    refreshSTSToken: async () => {
+      const auth = config.auth;
+      if (!auth || auth.mode !== "sts") {
+        throw new ApkpubError({ code: "CHANNEL_AUTH_FAILED" /* CHANNEL_AUTH_FAILED */, message: "STS \u914D\u7F6E\u65E0\u6548", retryable: false });
+      }
+      const refreshed = await fetchStsToken(auth.stsTokenUrl, auth.signKey, auth.contextB);
+      return {
+        accessKeyId: refreshed.accessKeyId,
+        accessKeySecret: refreshed.accessKeySecret,
+        stsToken: refreshed.securityToken
+      };
+    }
+  });
+}
+function extractRegion(endpoint) {
+  const match = endpoint.match(/oss-([a-z0-9-]+)\./);
+  return match?.[1] ?? "cn-beijing";
+}
+async function uploadToOss(ctx, config) {
+  ctx.onProgress({ step: "connecting" });
+  const fileName = path5.basename(ctx.filePath);
+  const objectKey = renderTemplate(config.objectKeyTemplate, {
+    appId: ctx.apkInfo.applicationId,
+    versionName: ctx.apkInfo.versionName,
+    versionCode: ctx.apkInfo.versionCode,
+    fileName
+  });
+  const client = await createOssClient(config);
+  ctx.onProgress({ step: "uploading", percent: 0 });
+  await client.multipartUpload(objectKey, ctx.filePath, {
+    progress: (p) => {
+      ctx.onProgress({ step: "uploading", percent: Math.round(p * 100) });
+    }
+  });
+  const downloadUrl = renderTemplate(config.downloadUrlTemplate, {
+    appId: ctx.apkInfo.applicationId,
+    versionName: ctx.apkInfo.versionName,
+    versionCode: ctx.apkInfo.versionCode,
+    fileName,
+    objectKey
+  });
+  ctx.onProgress({ step: "done", percent: 100 });
+  return { downloadUrl, message: "\u4E0A\u4F20\u6210\u529F" };
+}
+
+// src/channels/custom/http.ts
+import { createReadStream as createReadStream7 } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import path6 from "path";
+import FormData5 from "form-data";
+async function uploadToHttp(ctx, config) {
+  if (!config.uploadUrl) {
+    throw new ApkpubError({
+      code: "CONFIG_INVALID" /* CONFIG_INVALID */,
+      message: "HTTP \u6E20\u9053\u9700\u8981\u914D\u7F6E uploadUrl",
+      retryable: false
+    });
+  }
+  const fileName = path6.basename(ctx.filePath);
+  const objectKey = renderTemplate(config.objectKeyTemplate, {
+    appId: ctx.apkInfo.applicationId,
+    versionName: ctx.apkInfo.versionName,
+    versionCode: ctx.apkInfo.versionCode,
+    fileName
+  });
+  const uploadUrl = renderTemplate(config.uploadUrl, {
+    appId: ctx.apkInfo.applicationId,
+    versionName: ctx.apkInfo.versionName,
+    versionCode: ctx.apkInfo.versionCode,
+    fileName,
+    objectKey
+  });
+  assertSafeUrl(uploadUrl, "\u4E0A\u4F20\u5730\u5740");
+  const client = createHttpClient({ timeout: 3e5 });
+  const method = config.method ?? "PUT";
+  ctx.onProgress({ step: "uploading", percent: 0 });
+  if (method === "PUT") {
+    const data = await readFile2(ctx.filePath);
+    const response = await client.request({
+      method: "PUT",
+      url: uploadUrl,
+      data,
+      headers: {
+        "Content-Type": "application/vnd.android.package-archive",
+        ...config.headers
+      },
+      maxBodyLength: Infinity,
+      signal: ctx.signal,
+      onUploadProgress: (e) => {
+        if (e.total) ctx.onProgress({ step: "uploading", percent: Math.round(e.loaded / e.total * 100) });
+      }
+    });
+    if (response.status < 200 || response.status >= 300) {
+      throw new ApkpubError({
+        code: "CHANNEL_UPLOAD_FAILED" /* CHANNEL_UPLOAD_FAILED */,
+        message: `HTTP \u4E0A\u4F20\u5931\u8D25: ${response.status}`,
+        retryable: response.status >= 500
+      });
+    }
+  } else {
+    const form = new FormData5();
+    const field = config.formField ?? "file";
+    form.append(field, createReadStream7(ctx.filePath), { filename: fileName });
+    const response = await client.post(uploadUrl, form, {
+      headers: { ...form.getHeaders(), ...config.headers },
+      maxBodyLength: Infinity,
+      signal: ctx.signal,
+      onUploadProgress: (e) => {
+        if (e.total) ctx.onProgress({ step: "uploading", percent: Math.round(e.loaded / e.total * 100) });
+      }
+    });
+    if (response.status < 200 || response.status >= 300) {
+      throw new ApkpubError({
+        code: "CHANNEL_UPLOAD_FAILED" /* CHANNEL_UPLOAD_FAILED */,
+        message: `HTTP \u4E0A\u4F20\u5931\u8D25: ${response.status}`,
+        retryable: response.status >= 500
+      });
+    }
+  }
+  const downloadUrl = renderTemplate(config.downloadUrlTemplate, {
+    appId: ctx.apkInfo.applicationId,
+    versionName: ctx.apkInfo.versionName,
+    versionCode: ctx.apkInfo.versionCode,
+    fileName,
+    objectKey
+  });
+  ctx.onProgress({ step: "done", percent: 100 });
+  return { downloadUrl, message: "\u4E0A\u4F20\u6210\u529F" };
+}
+
+// src/channels/custom/index.ts
+function createCustomChannel(config) {
+  return {
+    name: config.name,
+    label: config.name,
+    type: "custom",
+    fileNameIdentify: config.fileNameIdentify ?? config.name,
+    credentialSchema: customChannelConfigSchema,
+    async upload(ctx) {
+      if (config.uploadType === "oss") {
+        return uploadToOss(ctx, config);
+      }
+      return uploadToHttp(ctx, config);
+    },
+    async validateCredentials() {
+      customChannelConfigSchema.parse(config);
+    }
+  };
+}
+
+// src/channels/registry.ts
+var BUILTIN_MARKET_CHANNELS = [
+  huaweiChannel,
+  honorChannel,
+  miChannel,
+  oppoChannel,
+  vivoChannel
+];
+function loadChannelsFromConfig(appConfig) {
+  const channels = [];
+  const builtinNames = new Set(BUILTIN_MARKET_CHANNELS.map((c) => c.name));
+  for (const chConfig of appConfig.channels) {
+    if (!chConfig.enable) continue;
+    if (chConfig.type === "custom") {
+      channels.push(createCustomChannel(chConfig));
+    } else if (builtinNames.has(chConfig.name)) {
+      const builtin = BUILTIN_MARKET_CHANNELS.find((c) => c.name === chConfig.name);
+      if (builtin) channels.push(builtin);
+    }
+  }
+  return channels;
+}
+function resolveChannels(appConfig, channelNames) {
+  const all = loadChannelsFromConfig(appConfig);
+  if (!channelNames || channelNames.length === 0) {
+    return all;
+  }
+  const resolved = [];
+  for (const name of channelNames) {
+    const ch = all.find((c) => c.name === name);
+    if (!ch) {
+      throw new ApkpubError({
+        code: "CHANNEL_NOT_FOUND" /* CHANNEL_NOT_FOUND */,
+        message: `\u6E20\u9053 "${name}" \u672A\u5728\u914D\u7F6E\u4E2D\u542F\u7528\u6216\u4E0D\u5B58\u5728`,
+        retryable: false
+      });
+    }
+    resolved.push(ch);
+  }
+  return resolved;
+}
+var MARKET_CREDENTIALS = {
+  huawei: [
+    { name: "client_id", required: true, description: "\u534E\u4E3A Connect API \u5BA2\u6237\u7AEF ID" },
+    { name: "client_secret", required: true, description: "\u534E\u4E3A Connect API \u5BC6\u94A5" }
+  ],
+  honor: [
+    { name: "client_id", required: true, description: "\u8363\u8000\u5F00\u53D1\u8005\u51ED\u8BC1 ID" },
+    { name: "client_secret", required: true, description: "\u8363\u8000\u5F00\u53D1\u8005\u51ED\u8BC1\u5BC6\u94A5" }
+  ],
+  mi: [
+    { name: "account", required: true, description: "\u5C0F\u7C73\u5F00\u53D1\u8005\u8D26\u53F7\uFF08\u90AE\u7BB1\uFF09" },
+    { name: "publicKey", required: true, description: "\u516C\u94A5\u8BC1\u4E66\u5185\u5BB9" },
+    { name: "privateKey", required: true, description: "\u79C1\u94A5" }
+  ],
+  oppo: [
+    { name: "client_id", required: true, description: "OPPO \u670D\u52A1\u7AEF\u5E94\u7528 ID" },
+    { name: "client_secret", required: true, description: "OPPO \u670D\u52A1\u7AEF\u5E94\u7528\u5BC6\u94A5" }
+  ],
+  vivo: [
+    { name: "access_key", required: true, description: "VIVO API Access Key" },
+    { name: "access_secret", required: true, description: "VIVO API Access Secret" }
+  ]
+};
+function getChannelMetas() {
+  return BUILTIN_MARKET_CHANNELS.map((ch) => ({
+    name: ch.name,
+    label: ch.label,
+    type: ch.type,
+    fileNameIdentify: ch.fileNameIdentify,
+    credentialFields: [
+      ...MARKET_CREDENTIALS[ch.name] ?? [],
+      { name: "fileNameIdentify", required: false, description: "\u591A\u6E20\u9053\u5305\u6587\u4EF6\u540D\u5339\u914D\u6807\u8BC6" }
+    ]
+  }));
+}
+
+// src/utils/output.ts
+import Table from "cli-table3";
+import pc2 from "picocolors";
+function printJson(data) {
+  process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+}
+function printPublishResult(result) {
+  const table = new Table({
+    head: ["\u6E20\u9053", "\u72B6\u6001", "\u4E0B\u8F7D\u94FE\u63A5", "\u9519\u8BEF"],
+    colWidths: [12, 10, 40, 30]
+  });
+  for (const r of result.results) {
+    const statusColor = r.status === "success" ? pc2.green : r.status === "failed" ? pc2.red : r.status === "dry_run" ? pc2.yellow : pc2.gray;
+    table.push([
+      r.label,
+      statusColor(r.status),
+      r.downloadUrl ?? "-",
+      r.error?.message ?? "-"
+    ]);
+  }
+  process.stderr.write("\n" + table.toString() + "\n");
+  const { summary } = result;
+  process.stderr.write(
+    pc2.dim(`
+\u603B\u8BA1: ${summary.total} | \u6210\u529F: ${pc2.green(String(summary.success))} | \u5931\u8D25: ${pc2.red(String(summary.failed))} | \u8DF3\u8FC7: ${summary.skipped}
+`)
+  );
+}
+function printStatusResults(results) {
+  const table = new Table({
+    head: ["\u6E20\u9053", "\u5BA1\u6838\u72B6\u6001", "\u7248\u672C\u53F7", "\u7248\u672C\u540D", "\u5907\u6CE8"]
+  });
+  for (const r of results) {
+    table.push([r.label, r.state ?? "-", r.versionCode ?? "-", r.versionName ?? "-", r.error ?? "-"]);
+  }
+  process.stderr.write("\n" + table.toString() + "\n");
+}
+function isInteractive() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+
+// src/core/result.ts
+function aggregateResults(results, dryRun = false) {
+  const success = results.filter((r) => r.status === "success" || r.status === "dry_run").length;
+  const failed = results.filter((r) => r.status === "failed").length;
+  const skipped = results.filter((r) => r.status === "skipped").length;
+  const ok = failed === 0;
+  return {
+    ok,
+    dryRun,
+    results,
+    summary: { total: results.length, success, failed, skipped }
+  };
+}
+function getExitCode(result) {
+  if (result.ok) return 0 /* SUCCESS */;
+  const { success, failed } = result.summary;
+  if (failed > 0 && success > 0) return 4 /* PARTIAL_FAILURE */;
+  if (failed > 0 && success === 0) {
+    const versionErrors = result.results.some((r) => r.error?.code === "VERSION_TOO_LOW" /* VERSION_TOO_LOW */);
+    if (versionErrors && failed === result.results.length) return 3 /* VERSION_CHECK_FAILED */;
+    return 5 /* ALL_FAILED */;
+  }
+  return 1 /* INTERNAL */;
+}
+function channelResultFromError(name, label, err) {
+  const apkErr = err instanceof ApkpubError ? err : new ApkpubError({ code: "INTERNAL" /* INTERNAL */, message: String(err) });
+  return {
+    name,
+    label,
+    status: "failed",
+    retryable: apkErr.retryable,
+    error: {
+      code: apkErr.code,
+      message: apkErr.message,
+      step: apkErr.step,
+      retryable: apkErr.retryable
+    }
+  };
+}
+
+// src/cli/init.ts
+function registerInitCommand(program2) {
+  program2.command("init").description("\u521B\u5EFA\u5E94\u7528\u914D\u7F6E").option("--name <name>", "\u5E94\u7528\u663E\u793A\u540D\u79F0").option("--app <id>", "\u5E94\u7528\u5305\u540D").option("--channels <names>", "\u542F\u7528\u7684\u5E02\u573A\u6E20\u9053\uFF0C\u9017\u53F7\u5206\u9694").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (options) => {
+    try {
+      await ensureConfigDirs();
+      let name = options.name;
+      let applicationId = options.app;
+      let selectedChannels = options.channels?.split(",").map((s) => s.trim()) ?? [];
+      if (isInteractive() && !options.name) {
+        name = await input({ message: "\u5E94\u7528\u663E\u793A\u540D\u79F0:" });
+        applicationId = await input({ message: "\u5E94\u7528\u5305\u540D (applicationId):" });
+        const metas2 = getChannelMetas();
+        selectedChannels = await checkbox({
+          message: "\u9009\u62E9\u8981\u542F\u7528\u7684\u5E02\u573A\u6E20\u9053:",
+          choices: metas2.map((m) => ({ name: m.label, value: m.name }))
+        });
+      }
+      if (!name || !applicationId) {
+        throw new ApkpubError({
+          code: "INVALID_ARGUMENT" /* INVALID_ARGUMENT */,
+          message: "\u8BF7\u63D0\u4F9B --name \u548C --app\uFF0C\u6216\u5728\u4EA4\u4E92\u6A21\u5F0F\u4E0B\u8FD0\u884C",
+          retryable: false
+        });
+      }
+      const metas = getChannelMetas();
+      const channels = [];
+      for (const meta of metas) {
+        const enabled = selectedChannels.length === 0 || selectedChannels.includes(meta.name);
+        if (!enabled && selectedChannels.length > 0) continue;
+        if (selectedChannels.length > 0 && !selectedChannels.includes(meta.name)) continue;
+        if (isInteractive() && (selectedChannels.length === 0 || selectedChannels.includes(meta.name))) {
+          const enable = selectedChannels.length > 0 ? true : await confirm({ message: `\u542F\u7528 ${meta.label} \u6E20\u9053?`, default: false });
+          if (!enable) continue;
+          const params = [];
+          for (const field of meta.credentialFields) {
+            if (field.name === "fileNameIdentify") continue;
+            const value = await input({
+              message: `${meta.label} - ${field.name}${field.description ? ` (${field.description})` : ""}:`
+            });
+            params.push({ name: field.name, value });
+          }
+          params.push({ name: "fileNameIdentify", value: meta.fileNameIdentify });
+          channels.push({ name: meta.name, type: "market", enable: true, params });
+        } else if (selectedChannels.includes(meta.name)) {
+          channels.push({
+            name: meta.name,
+            type: "market",
+            enable: true,
+            params: meta.credentialFields.filter((f) => f.name !== "fileNameIdentify").map((f) => ({ name: f.name, value: `\${${meta.name.toUpperCase()}_${f.name.toUpperCase()}}` }))
+          });
+        }
+      }
+      const config = {
+        schemaVersion: CURRENT_SCHEMA_VERSION,
+        name,
+        applicationId,
+        createTime: Date.now(),
+        enableChannel: true,
+        channels,
+        extension: {}
+      };
+      await saveConfig(config);
+      if (options.json) {
+        printJson({ ok: true, config: { applicationId, name, channels: channels.map((c) => c.name) } });
+      } else {
+        process.stderr.write(`\u5DF2\u521B\u5EFA\u5E94\u7528\u914D\u7F6E: ${applicationId}
+`);
+        process.stderr.write(`\u914D\u7F6E\u6587\u4EF6: ~/.apkpub/apps/${applicationId}.json
+`);
+      }
+      process.exit(0 /* SUCCESS */);
+    } catch (err) {
+      const message = err instanceof ApkpubError ? err.message : String(err);
+      if (options.json) {
+        printJson({ ok: false, error: { message } });
+      } else {
+        process.stderr.write(`\u9519\u8BEF: ${message}
+`);
+      }
+      process.exit(2 /* INVALID_ARGUMENT */);
+    }
+  });
+}
+
+// src/cli/config.ts
+import { writeFile as writeFile2 } from "fs/promises";
+function registerConfigCommand(program2) {
+  const config = program2.command("config").description("\u914D\u7F6E\u7BA1\u7406");
+  config.command("list").description("\u5217\u51FA\u6240\u6709\u5E94\u7528\u914D\u7F6E").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (options) => {
+    const configs = await listConfigs();
+    if (options.json) {
+      printJson({ apps: configs.map((c) => ({ name: c.name, applicationId: c.applicationId })) });
+    } else {
+      for (const c of configs) {
+        process.stderr.write(`${c.applicationId} - ${c.name}
+`);
+      }
+    }
+    process.exit(0 /* SUCCESS */);
+  });
+  config.command("get <appId>").description("\u83B7\u53D6\u5E94\u7528\u914D\u7F6E").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (appId, options) => {
+    try {
+      const cfg = await loadConfig(appId);
+      if (options.json) {
+        printJson(stripSecrets(cfg));
+      } else {
+        process.stderr.write(JSON.stringify(stripSecrets(cfg), null, 2) + "\n");
+      }
+      process.exit(0 /* SUCCESS */);
+    } catch (err) {
+      handleError(err, options.json);
+    }
+  });
+  config.command("export <appId>").description("\u5BFC\u51FA\u5E94\u7528\u914D\u7F6E\uFF08\u9ED8\u8BA4\u5265\u79BB\u5BC6\u94A5\uFF09").option("--include-secrets", "\u5305\u542B\u5BC6\u94A5\uFF08\u4E0D\u63A8\u8350\uFF09").option("-o, --output <file>", "\u8F93\u51FA\u6587\u4EF6\u8DEF\u5F84").action(async (appId, options) => {
+    try {
+      const content = await exportConfig(appId, { includeSecrets: options.includeSecrets });
+      if (options.output) {
+        await writeFile2(options.output, content, { mode: 384 });
+        process.stderr.write(`\u5DF2\u5BFC\u51FA\u5230 ${options.output}
+`);
+      } else {
+        process.stdout.write(content + "\n");
+      }
+      process.exit(0 /* SUCCESS */);
+    } catch (err) {
+      handleError(err, false);
+    }
+  });
+  config.command("import <file>").description("\u5BFC\u5165\u5E94\u7528\u914D\u7F6E").action(async (file) => {
+    try {
+      const cfg = await importConfig(file);
+      process.stderr.write(`\u5DF2\u5BFC\u5165: ${cfg.applicationId}
+`);
+      process.exit(0 /* SUCCESS */);
+    } catch (err) {
+      handleError(err, false);
+    }
+  });
+}
+function handleError(err, json) {
+  const message = err instanceof ApkpubError ? err.message : String(err);
+  if (json) {
+    printJson({ ok: false, error: { message } });
+  } else {
+    process.stderr.write(`\u9519\u8BEF: ${message}
+`);
+  }
+  process.exit(2 /* INVALID_ARGUMENT */);
+}
+
+// src/apk/ApkParser.ts
+import AppInfoParser from "app-info-parser";
+async function parseApk(filePath) {
+  try {
+    const parser = new AppInfoParser(filePath);
+    const result = await parser.parse();
+    const packageName = result.package;
+    const versionCode = Number(result.versionCode);
+    const versionName = String(result.versionName ?? "");
+    if (!packageName) {
+      throw new ApkpubError({
+        code: "APK_PARSE_FAILED" /* APK_PARSE_FAILED */,
+        message: "\u65E0\u6CD5\u4ECE APK \u4E2D\u8BFB\u53D6\u5305\u540D",
+        retryable: false
+      });
+    }
+    const size = await fileSize(filePath);
+    return {
+      filePath,
+      applicationId: packageName,
+      versionCode,
+      versionName,
+      size
+    };
+  } catch (err) {
+    if (err instanceof ApkpubError) throw err;
+    throw new ApkpubError({
+      code: "APK_PARSE_FAILED" /* APK_PARSE_FAILED */,
+      message: `APK \u89E3\u6790\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`,
+      retryable: false,
+      cause: err
+    });
+  }
+}
+
+// src/cli/info.ts
+function registerInfoCommand(program2) {
+  program2.command("info <apk>").description("\u89E3\u6790 APK\uFF0C\u8F93\u51FA\u5305\u540D\u3001\u7248\u672C\u53F7\u7B49\u4FE1\u606F").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (apk, options) => {
+    try {
+      const info = await parseApk(apk);
+      const output = {
+        filePath: info.filePath,
+        applicationId: info.applicationId,
+        versionCode: info.versionCode,
+        versionName: info.versionName,
+        size: info.size,
+        sizeMB: (info.size / 1024 / 1024).toFixed(2)
+      };
+      if (options.json) {
+        printJson(output);
+      } else {
+        process.stderr.write(`\u5305\u540D: ${info.applicationId}
+`);
+        process.stderr.write(`\u7248\u672C\u53F7: ${info.versionCode}
+`);
+        process.stderr.write(`\u7248\u672C\u540D: ${info.versionName}
+`);
+        process.stderr.write(`\u5927\u5C0F: ${output.sizeMB} MB
+`);
+      }
+      process.exit(0 /* SUCCESS */);
+    } catch (err) {
+      const message = err instanceof ApkpubError ? err.message : String(err);
+      if (options.json) {
+        printJson({ ok: false, error: { message, code: err instanceof ApkpubError ? err.code : "INTERNAL" /* INTERNAL */ } });
+      } else {
+        process.stderr.write(`\u9519\u8BEF: ${message}
+`);
+      }
+      process.exit(2 /* INVALID_ARGUMENT */);
+    }
+  });
+}
+
+// src/core/Dispatcher.ts
+import pLimit from "p-limit";
+
+// src/secrets/resolver.ts
+import { createCipheriv, createDecipheriv, createHash as createHash3, randomBytes, scryptSync } from "crypto";
+var ENV_PLACEHOLDER_RE = /^\$\{([A-Z_][A-Z0-9_]*)\}$/;
+async function resolveSecret(value, options = {}) {
+  const envMatch = value.match(ENV_PLACEHOLDER_RE);
+  if (envMatch) {
+    const envVal = process.env[envMatch[1]];
+    if (!envVal) {
+      throw new ApkpubError({
+        code: "SECRET_RESOLVE_FAILED" /* SECRET_RESOLVE_FAILED */,
+        message: `\u73AF\u5883\u53D8\u91CF ${envMatch[1]} \u672A\u8BBE\u7F6E`,
+        retryable: false
+      });
+    }
+    return { value: envVal, source: "env" };
+  }
+  if (value.startsWith("keychain:")) {
+    const key = value.slice("keychain:".length);
+    const resolved = await resolveFromKeychain(options.service ?? "apkpub-cli", key);
+    return { value: resolved, source: "keychain" };
+  }
+  if (value.startsWith("enc:")) {
+    const resolved = await decryptValue(value.slice("enc:".length));
+    return { value: resolved, source: "encrypted" };
+  }
+  if (looksLikeSecret(value)) {
+    logger.warn("secrets", "\u68C0\u6D4B\u5230\u660E\u6587\u5BC6\u94A5\uFF0C\u5EFA\u8BAE\u8FC1\u79FB\u5230\u73AF\u5883\u53D8\u91CF\u6216 keychain");
+  }
+  return { value, source: "plain" };
+}
+async function resolveConfigSecrets(params, options = {}) {
+  const result = {};
+  for (const [key, val] of Object.entries(params)) {
+    if (typeof val === "string" && val.length > 0) {
+      const resolved = await resolveSecret(val, { ...options, account: key });
+      result[key] = resolved.value;
+    } else {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+async function resolveFromKeychain(service, account) {
+  try {
+    const keytar = await import("keytar");
+    const password = await keytar.getPassword(service, account);
+    if (!password) {
+      throw new ApkpubError({
+        code: "SECRET_RESOLVE_FAILED" /* SECRET_RESOLVE_FAILED */,
+        message: `keychain \u4E2D\u672A\u627E\u5230 ${service}/${account}`,
+        retryable: false
+      });
+    }
+    return password;
+  } catch (err) {
+    if (err instanceof ApkpubError) throw err;
+    throw new ApkpubError({
+      code: "SECRET_RESOLVE_FAILED" /* SECRET_RESOLVE_FAILED */,
+      message: `keychain \u4E0D\u53EF\u7528\uFF0C\u8BF7\u5B89\u88C5 keytar \u6216\u6539\u7528\u73AF\u5883\u53D8\u91CF: ${err instanceof Error ? err.message : String(err)}`,
+      retryable: false,
+      cause: err
+    });
+  }
+}
+async function decryptValue(encrypted) {
+  const masterKey = process.env.APKPUB_MASTER_KEY;
+  if (!masterKey) {
+    throw new ApkpubError({
+      code: "SECRET_RESOLVE_FAILED" /* SECRET_RESOLVE_FAILED */,
+      message: "\u89E3\u5BC6\u9700\u8981\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF APKPUB_MASTER_KEY",
+      retryable: false
+    });
+  }
+  const [ivHex, authTagHex, cipherHex] = encrypted.split(":");
+  if (!ivHex || !authTagHex || !cipherHex) {
+    throw new ApkpubError({
+      code: "SECRET_RESOLVE_FAILED" /* SECRET_RESOLVE_FAILED */,
+      message: "\u52A0\u5BC6\u503C\u683C\u5F0F\u65E0\u6548",
+      retryable: false
+    });
+  }
+  const key = scryptSync(masterKey, "apkpub-salt", 32);
+  const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(ivHex, "hex"));
+  decipher.setAuthTag(Buffer.from(authTagHex, "hex"));
+  const decrypted = Buffer.concat([
+    decipher.update(Buffer.from(cipherHex, "hex")),
+    decipher.final()
+  ]);
+  return decrypted.toString("utf8");
+}
+function looksLikeSecret(value) {
+  if (value.length < 16) return false;
+  return /secret|key|token|password/i.test(value) === false && /^[A-Za-z0-9+/=_-]{16,}$/.test(value);
+}
+
+// src/core/versionCheck.ts
+function checkVersion(apkInfo, marketInfo, channelName) {
+  if (!marketInfo) return;
+  if (apkInfo.versionCode <= marketInfo.lastVersionCode) {
+    throw new ApkpubError({
+      code: "VERSION_TOO_LOW" /* VERSION_TOO_LOW */,
+      channel: channelName,
+      message: `\u8981\u63D0\u4EA4\u7684 APK \u7248\u672C\u53F7(${apkInfo.versionCode})\u9700\u5927\u4E8E\u7EBF\u4E0A\u6700\u65B0\u7248\u672C\u53F7(${marketInfo.lastVersionCode})`,
+      retryable: false
+    });
+  }
+}
+function checkPackageMatch(apkInfo, expectedAppId) {
+  if (apkInfo.applicationId !== expectedAppId) {
+    throw new ApkpubError({
+      code: "INVALID_ARGUMENT" /* INVALID_ARGUMENT */,
+      message: `APK \u5305\u540D(${apkInfo.applicationId})\u4E0E\u914D\u7F6E(${expectedAppId})\u4E0D\u5339\u914D`,
+      retryable: false
+    });
+  }
+}
+
+// src/core/TaskLauncher.ts
+import path7 from "path";
+import { stat as stat2 } from "fs/promises";
+var TaskLauncher = class {
+  channel;
+  channelConfig;
+  apkPath;
+  enableChannel;
+  resolvedFile;
+  apkInfo;
+  config = {};
+  constructor(options) {
+    this.channel = options.channel;
+    this.channelConfig = options.channelConfig;
+    this.apkPath = options.apkPath;
+    this.enableChannel = options.enableChannel;
+  }
+  /** 注入渠道配置参数 */
+  injectConfig(resolvedParams) {
+    if (this.channelConfig.type === "custom") {
+      this.config = { ...this.channelConfig, ...resolvedParams };
+    } else {
+      this.config = { ...resolvedParams };
+      const fileId = resolvedParams.fileNameIdentify ?? this.channel.fileNameIdentify;
+      this.config.fileNameIdentify = fileId;
+    }
+  }
+  /** 匹配并选择 APK 文件 */
+  async selectFile() {
+    const info = await stat2(this.apkPath);
+    if (info.isFile()) {
+      this.resolvedFile = this.apkPath;
+      return this.resolvedFile;
+    }
+    if (!this.enableChannel) {
+      throw new ApkpubError({
+        code: "APK_NOT_FOUND" /* APK_NOT_FOUND */,
+        channel: this.channel.name,
+        message: "\u591A\u6E20\u9053\u6A21\u5F0F\u672A\u542F\u7528\uFF0C\u8BF7\u6307\u5B9A\u5355\u4E2A APK \u6587\u4EF6",
+        retryable: false
+      });
+    }
+    const fileId = String(this.config.fileNameIdentify ?? this.channel.fileNameIdentify);
+    const apks = await listApkFiles(this.apkPath);
+    const matches = apks.filter((f) => path7.basename(f).toLowerCase().includes(fileId.toLowerCase()));
+    if (matches.length === 0) {
+      throw new ApkpubError({
+        code: "APK_NOT_FOUND" /* APK_NOT_FOUND */,
+        channel: this.channel.name,
+        message: `\u627E\u4E0D\u5230\u6587\u4EF6\u540D\u4E2D\u5305\u542B "${fileId}" \u7684 APK \u6587\u4EF6`,
+        retryable: false
+      });
+    }
+    if (matches.length > 1) {
+      throw new ApkpubError({
+        code: "APK_AMBIGUOUS" /* APK_AMBIGUOUS */,
+        channel: this.channel.name,
+        message: `\u5339\u914D\u5230\u591A\u4E2A APK \u6587\u4EF6\uFF0C\u8BF7\u786E\u4FDD\u552F\u4E00: ${matches.map((f) => path7.basename(f)).join(", ")}`,
+        retryable: false
+      });
+    }
+    this.resolvedFile = matches[0];
+    return this.resolvedFile;
+  }
+  /** 解析 APK 信息 */
+  async prepare() {
+    const file = this.resolvedFile ?? await this.selectFile();
+    this.apkInfo = await parseApk(file);
+    return this.apkInfo;
+  }
+  getFilePath() {
+    if (!this.resolvedFile) {
+      throw new ApkpubError({
+        code: "APK_NOT_FOUND" /* APK_NOT_FOUND */,
+        message: "\u5C1A\u672A\u9009\u62E9 APK \u6587\u4EF6",
+        retryable: false
+      });
+    }
+    return this.resolvedFile;
+  }
+  getApkInfo() {
+    if (!this.apkInfo) {
+      throw new ApkpubError({
+        code: "APK_PARSE_FAILED" /* APK_PARSE_FAILED */,
+        message: "\u5C1A\u672A\u89E3\u6790 APK",
+        retryable: false
+      });
+    }
+    return this.apkInfo;
+  }
+  getConfig() {
+    return this.config;
+  }
+  /** 从渠道配置提取原始参数 */
+  static getRawParams(channelConfig) {
+    if (channelConfig.type === "custom") {
+      return paramsToRecord(channelConfig.params ?? []);
+    }
+    return paramsToRecord(channelConfig.params);
+  }
+};
+
+// src/core/Dispatcher.ts
+var Dispatcher = class {
+  async dispatch(options) {
+    const { appConfig, channels, apkPath, updateDesc, dryRun, parallel = 1, signal } = options;
+    const limit = pLimit(Math.max(1, parallel));
+    const tasks = channels.map((channel) => {
+      const chConfig = appConfig.channels.find((c) => c.name === channel.name);
+      if (!chConfig || !chConfig.enable) {
+        return async () => ({
+          name: channel.name,
+          label: channel.label,
+          status: "skipped"
+        });
+      }
+      return async () => {
+        const launcher = new TaskLauncher({
+          channel,
+          channelConfig: chConfig,
+          apkPath,
+          enableChannel: appConfig.enableChannel
+        });
+        try {
+          const rawParams = TaskLauncher.getRawParams(chConfig);
+          const resolved = await resolveConfigSecrets(rawParams, {
+            service: "apkpub-cli",
+            account: `${appConfig.applicationId}/${channel.name}`
+          });
+          launcher.injectConfig(resolved);
+          await launcher.selectFile();
+          const apkInfo = await launcher.prepare();
+          checkPackageMatch(apkInfo, appConfig.applicationId);
+          if (channel.getMarketState) {
+            const marketState = await channel.getMarketState(appConfig.applicationId, launcher.getConfig());
+            checkVersion(apkInfo, marketState, channel.name);
+          }
+          if (dryRun) {
+            logger.info(channel.name, `[dry-run] \u9884\u68C0\u901A\u8FC7\uFF0C\u5C06\u4E0A\u4F20 ${apkInfo.versionName}(${apkInfo.versionCode})`);
+            return { name: channel.name, label: channel.label, status: "dry_run" };
+          }
+          const result = await channel.upload({
+            apkInfo,
+            filePath: launcher.getFilePath(),
+            desc: updateDesc,
+            config: launcher.getConfig(),
+            onProgress: ({ step, percent }) => {
+              options.onChannelProgress?.(channel.name, step, percent);
+            },
+            signal: signal ?? new AbortController().signal
+          });
+          await writeAuditLog({
+            action: "publish",
+            appId: appConfig.applicationId,
+            channels: [channel.name],
+            versionCode: apkInfo.versionCode,
+            result: "success"
+          });
+          return {
+            name: channel.name,
+            label: channel.label,
+            status: "success",
+            downloadUrl: result.downloadUrl
+          };
+        } catch (err) {
+          logger.error(channel.name, err instanceof Error ? err.message : String(err));
+          await writeAuditLog({
+            action: "publish",
+            appId: appConfig.applicationId,
+            channels: [channel.name],
+            result: "failed"
+          }).catch(() => {
+          });
+          return channelResultFromError(channel.name, channel.label, err);
+        }
+      };
+    });
+    const results = await Promise.all(tasks.map((task) => limit(task)));
+    return aggregateResults(results, dryRun);
+  }
+};
+
+// src/cli/publish.ts
+function registerPublishCommand(program2) {
+  program2.command("publish").description("\u53D1\u5E03 APK \u5230\u6307\u5B9A\u6E20\u9053").requiredOption("--app <id>", "\u5E94\u7528\u5305\u540D").requiredOption("--apk <path>", "APK \u6587\u4EF6\u6216\u76EE\u5F55\u8DEF\u5F84").option("--channels <names>", "\u6E20\u9053\u5217\u8868\uFF0C\u9017\u53F7\u5206\u9694", (v) => v.split(",").map((s) => s.trim())).option("--desc <text>", "\u66F4\u65B0\u63CF\u8FF0").option("--parallel [n]", "\u5E76\u884C\u4E0A\u4F20\u6570", "1").option("--dry-run", "\u4EC5\u9884\u68C0\uFF0C\u4E0D\u5B9E\u9645\u4E0A\u4F20").option("--yes", "\u8DF3\u8FC7\u786E\u8BA4").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").option("--no-progress", "\u7981\u7528\u8FDB\u5EA6\u663E\u793A").option("--debug", "\u8C03\u8BD5\u6A21\u5F0F").action(async (options) => {
+    const jsonMode2 = options.json || !isInteractive();
+    setJsonMode(jsonMode2);
+    try {
+      const appConfig = await loadConfig(options.app);
+      const updateDesc = options.desc ?? appConfig.extension.updateDesc ?? "";
+      if (!updateDesc.trim()) {
+        throw new ApkpubError({
+          code: "INVALID_ARGUMENT" /* INVALID_ARGUMENT */,
+          message: "\u8BF7\u901A\u8FC7 --desc \u63D0\u4F9B\u66F4\u65B0\u63CF\u8FF0",
+          retryable: false
+        });
+      }
+      const channelNames = options.channels;
+      const channels = resolveChannels(appConfig, channelNames);
+      if (channels.length === 0) {
+        throw new ApkpubError({
+          code: "CHANNEL_NOT_FOUND" /* CHANNEL_NOT_FOUND */,
+          message: "\u6CA1\u6709\u53EF\u7528\u7684\u53D1\u5E03\u6E20\u9053",
+          retryable: false
+        });
+      }
+      const dispatcher = new Dispatcher();
+      const result = await dispatcher.dispatch({
+        appConfig,
+        channels,
+        apkPath: options.apk,
+        updateDesc: updateDesc.trim(),
+        dryRun: options.dryRun,
+        parallel: parseInt(options.parallel ?? "1", 10),
+        onChannelProgress: (channel, step, percent) => {
+          if (!jsonMode2 && options.progress !== false) {
+            const pct = percent !== void 0 ? ` ${percent}%` : "";
+            process.stderr.write(`[${channel}] ${step}${pct}
+`);
+          }
+        }
+      });
+      if (jsonMode2) {
+        printJson(result);
+      } else {
+        printPublishResult(result);
+      }
+      process.exit(getExitCode(result));
+    } catch (err) {
+      const apkErr = err instanceof ApkpubError ? err : new ApkpubError({ code: "INTERNAL" /* INTERNAL */, message: String(err) });
+      if (options.json) {
+        printJson({ ok: false, error: { code: apkErr.code, message: apkErr.message, retryable: apkErr.retryable } });
+      } else {
+        process.stderr.write(`\u9519\u8BEF: ${apkErr.message}
+`);
+      }
+      process.exit(2 /* INVALID_ARGUMENT */);
+    }
+  });
+}
+
+// src/cli/status.ts
+function registerStatusCommand(program2) {
+  program2.command("status").description("\u67E5\u8BE2\u5404\u5E02\u573A\u7EBF\u4E0A\u7248\u672C\u4E0E\u5BA1\u6838\u72B6\u6001").requiredOption("--app <id>", "\u5E94\u7528\u5305\u540D").option("--channels <names>", "\u6E20\u9053\u5217\u8868\uFF0C\u9017\u53F7\u5206\u9694", (v) => v.split(",").map((s) => s.trim())).option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (options) => {
+    setJsonMode(!!options.json);
+    try {
+      const appConfig = await loadConfig(options.app);
+      const channels = resolveChannels(appConfig, options.channels);
+      const results = [];
+      for (const channel of channels) {
+        if (!channel.getMarketState) {
+          results.push({ name: channel.name, label: channel.label, state: "n/a", error: "\u81EA\u5B9A\u4E49\u6E20\u9053\u65E0\u5E02\u573A\u72B6\u6001" });
+          continue;
+        }
+        const chConfig = appConfig.channels.find((c) => c.name === channel.name);
+        try {
+          const rawParams = TaskLauncher.getRawParams(chConfig);
+          const resolved = await resolveConfigSecrets(rawParams);
+          const state = await channel.getMarketState(appConfig.applicationId, resolved);
+          results.push({
+            name: channel.name,
+            label: channel.label,
+            state: state?.reviewState ?? "unknown",
+            versionCode: state?.lastVersionCode,
+            versionName: state?.lastVersionName
+          });
+        } catch (err) {
+          results.push({
+            name: channel.name,
+            label: channel.label,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+      if (options.json) {
+        printJson({ ok: true, results });
+      } else {
+        printStatusResults(results);
+      }
+      process.exit(0 /* SUCCESS */);
+    } catch (err) {
+      const message = err instanceof ApkpubError ? err.message : String(err);
+      if (options.json) {
+        printJson({ ok: false, error: { message } });
+      } else {
+        process.stderr.write(`\u9519\u8BEF: ${message}
+`);
+      }
+      process.exit(2 /* INVALID_ARGUMENT */);
+    }
+  });
+}
+
+// src/cli/channels.ts
+function registerChannelsCommand(program2) {
+  program2.command("channels").description("\u5217\u51FA\u652F\u6301\u7684\u5185\u7F6E\u5E02\u573A\u6E20\u9053\u53CA\u6240\u9700\u51ED\u8BC1\u5B57\u6BB5").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action((options) => {
+    const metas = getChannelMetas();
+    if (options.json) {
+      printJson({ channels: metas });
+    } else {
+      for (const ch of metas) {
+        process.stderr.write(`
+${ch.label} (${ch.name})
+`);
+        process.stderr.write(`  \u6587\u4EF6\u540D\u6807\u8BC6: ${ch.fileNameIdentify}
+`);
+        process.stderr.write(`  \u51ED\u8BC1\u5B57\u6BB5:
+`);
+        for (const f of ch.credentialFields) {
+          process.stderr.write(`    - ${f.name}${f.required ? " *" : ""}: ${f.description ?? ""}
+`);
+        }
+      }
+      process.stderr.write("\n");
+    }
+    process.exit(0 /* SUCCESS */);
+  });
+}
+
+// src/cli/doctor.ts
+function registerDoctorCommand(program2) {
+  program2.command("doctor").description("\u4F53\u68C0\uFF1A\u6821\u9A8C\u914D\u7F6E\u5B8C\u6574\u6027\u4E0E\u5404\u6E20\u9053\u51ED\u8BC1\u53EF\u7528\u6027").requiredOption("--app <id>", "\u5E94\u7528\u5305\u540D").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (options) => {
+    setJsonMode(!!options.json);
+    try {
+      const appConfig = await loadConfig(options.app);
+      const channels = resolveChannels(appConfig);
+      const checks = [];
+      for (const channel of channels) {
+        const chConfig = appConfig.channels.find((c) => c.name === channel.name);
+        try {
+          const rawParams = TaskLauncher.getRawParams(chConfig);
+          const resolved = await resolveConfigSecrets(rawParams);
+          if (channel.validateCredentials) {
+            await channel.validateCredentials(resolved);
+          }
+          checks.push({ channel: channel.name, ok: true, message: "\u51ED\u8BC1\u6709\u6548" });
+        } catch (err) {
+          checks.push({
+            channel: channel.name,
+            ok: false,
+            message: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+      const allOk = checks.every((c) => c.ok);
+      const output = { ok: allOk, app: options.app, checks };
+      if (options.json) {
+        printJson(output);
+      } else {
+        for (const c of checks) {
+          const icon = c.ok ? "\u2713" : "\u2717";
+          process.stderr.write(`${icon} [${c.channel}] ${c.message}
+`);
+        }
+      }
+      process.exit(allOk ? 0 /* SUCCESS */ : 5 /* ALL_FAILED */);
+    } catch (err) {
+      const message = err instanceof ApkpubError ? err.message : String(err);
+      if (options.json) {
+        printJson({ ok: false, error: { message } });
+      } else {
+        process.stderr.write(`\u9519\u8BEF: ${message}
+`);
+      }
+      process.exit(2 /* INVALID_ARGUMENT */);
+    }
+  });
+}
+
+// src/cli/describe.ts
+var COMMANDS = [
+  {
+    name: "init",
+    description: "\u521B\u5EFA\u5E94\u7528\u914D\u7F6E",
+    options: [
+      { name: "--name", required: false, description: "\u5E94\u7528\u663E\u793A\u540D\u79F0" },
+      { name: "--app", required: false, description: "\u5E94\u7528\u5305\u540D" },
+      { name: "--channels", required: false, description: "\u542F\u7528\u7684\u5E02\u573A\u6E20\u9053" }
+    ]
+  },
+  {
+    name: "publish",
+    description: "\u53D1\u5E03 APK \u5230\u6307\u5B9A\u6E20\u9053",
+    options: [
+      { name: "--app", required: true, description: "\u5E94\u7528\u5305\u540D" },
+      { name: "--apk", required: true, description: "APK \u6587\u4EF6\u6216\u76EE\u5F55" },
+      { name: "--channels", required: false, description: "\u6E20\u9053\u5217\u8868" },
+      { name: "--desc", required: false, description: "\u66F4\u65B0\u63CF\u8FF0" },
+      { name: "--parallel", required: false, description: "\u5E76\u884C\u6570" },
+      { name: "--dry-run", required: false, description: "\u4EC5\u9884\u68C0" },
+      { name: "--json", required: false, description: "JSON \u8F93\u51FA" }
+    ]
+  },
+  {
+    name: "status",
+    description: "\u67E5\u8BE2\u5E02\u573A\u5BA1\u6838\u72B6\u6001",
+    options: [
+      { name: "--app", required: true, description: "\u5E94\u7528\u5305\u540D" },
+      { name: "--channels", required: false, description: "\u6E20\u9053\u5217\u8868" },
+      { name: "--json", required: false, description: "JSON \u8F93\u51FA" }
+    ]
+  },
+  {
+    name: "info",
+    description: "\u89E3\u6790 APK \u4FE1\u606F",
+    options: [
+      { name: "<apk>", required: true, description: "APK \u6587\u4EF6\u8DEF\u5F84" },
+      { name: "--json", required: false, description: "JSON \u8F93\u51FA" }
+    ]
+  },
+  {
+    name: "doctor",
+    description: "\u914D\u7F6E\u4E0E\u51ED\u8BC1\u4F53\u68C0",
+    options: [
+      { name: "--app", required: true, description: "\u5E94\u7528\u5305\u540D" },
+      { name: "--json", required: false, description: "JSON \u8F93\u51FA" }
+    ]
+  },
+  {
+    name: "mcp",
+    description: "\u542F\u52A8 MCP server \u6A21\u5F0F",
+    options: []
+  }
+];
+function registerDescribeCommand(program2) {
+  program2.command("describe").description("\u8F93\u51FA\u547D\u4EE4\u4E0E\u6E20\u9053\u7684\u673A\u5668\u53EF\u8BFB\u6E05\u5355\uFF08\u4F9B Agent \u81EA\u53D1\u73B0\uFF09").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA", true).action((options) => {
+    const descriptor = {
+      name: "apkpub-cli",
+      version: "1.0.0",
+      commands: COMMANDS,
+      channels: getChannelMetas(),
+      exitCodes: {
+        0: "\u5168\u90E8\u6210\u529F",
+        2: "\u53C2\u6570/\u914D\u7F6E\u9519\u8BEF",
+        3: "\u7248\u672C\u6821\u9A8C\u5931\u8D25",
+        4: "\u90E8\u5206\u6E20\u9053\u5931\u8D25",
+        5: "\u5168\u90E8\u5931\u8D25"
+      },
+      jsonSchema: {
+        publishResult: {
+          ok: "boolean",
+          dryRun: "boolean",
+          results: [{ name: "string", status: "string", downloadUrl: "string?", error: "object?" }],
+          summary: { total: "number", success: "number", failed: "number", skipped: "number" }
+        }
+      }
+    };
+    if (options.json !== false) {
+      printJson(descriptor);
+    }
+    process.exit(0 /* SUCCESS */);
+  });
+}
+
+// src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+async function startMcpServer() {
+  const server = new Server(
+    { name: "apkpub-cli", version: "1.0.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "apkpub_info",
+        description: "\u89E3\u6790 APK \u6587\u4EF6\uFF0C\u83B7\u53D6\u5305\u540D\u3001\u7248\u672C\u53F7\u7B49\u4FE1\u606F",
+        inputSchema: {
+          type: "object",
+          properties: { apk: { type: "string", description: "APK \u6587\u4EF6\u8DEF\u5F84" } },
+          required: ["apk"]
+        }
+      },
+      {
+        name: "apkpub_status",
+        description: "\u67E5\u8BE2\u5E94\u7528\u5728\u5404\u5E02\u573A\u7684\u5BA1\u6838\u72B6\u6001\u4E0E\u7EBF\u4E0A\u7248\u672C",
+        inputSchema: {
+          type: "object",
+          properties: {
+            app: { type: "string", description: "\u5E94\u7528\u5305\u540D" },
+            channels: { type: "array", items: { type: "string" }, description: "\u6E20\u9053\u5217\u8868" }
+          },
+          required: ["app"]
+        }
+      },
+      {
+        name: "apkpub_publish",
+        description: "\u53D1\u5E03 APK \u5230\u6307\u5B9A\u6E20\u9053",
+        inputSchema: {
+          type: "object",
+          properties: {
+            app: { type: "string", description: "\u5E94\u7528\u5305\u540D" },
+            apk: { type: "string", description: "APK \u6587\u4EF6\u6216\u76EE\u5F55\u8DEF\u5F84" },
+            channels: { type: "array", items: { type: "string" }, description: "\u6E20\u9053\u5217\u8868" },
+            desc: { type: "string", description: "\u66F4\u65B0\u63CF\u8FF0" },
+            dryRun: { type: "boolean", description: "\u4EC5\u9884\u68C0" },
+            parallel: { type: "number", description: "\u5E76\u884C\u6570" }
+          },
+          required: ["app", "apk"]
+        }
+      },
+      {
+        name: "apkpub_doctor",
+        description: "\u4F53\u68C0\u5E94\u7528\u914D\u7F6E\u4E0E\u5404\u6E20\u9053\u51ED\u8BC1",
+        inputSchema: {
+          type: "object",
+          properties: { app: { type: "string", description: "\u5E94\u7528\u5305\u540D" } },
+          required: ["app"]
+        }
+      }
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const params = args ?? {};
+    try {
+      switch (name) {
+        case "apkpub_info": {
+          const info = await parseApk(params.apk);
+          return { content: [{ type: "text", text: JSON.stringify(info) }] };
+        }
+        case "apkpub_status": {
+          const appConfig = await loadConfig(params.app);
+          const channels = resolveChannels(appConfig, params.channels);
+          const results = [];
+          for (const channel of channels) {
+            if (!channel.getMarketState) {
+              results.push({ channel: channel.name, state: "n/a" });
+              continue;
+            }
+            const chConfig = appConfig.channels.find((c) => c.name === channel.name);
+            const rawParams = TaskLauncher.getRawParams(chConfig);
+            const resolved = await resolveConfigSecrets(rawParams);
+            const state = await channel.getMarketState(appConfig.applicationId, resolved);
+            results.push({ channel: channel.name, ...state });
+          }
+          return { content: [{ type: "text", text: JSON.stringify({ ok: true, results }) }] };
+        }
+        case "apkpub_publish": {
+          const appConfig = await loadConfig(params.app);
+          const channels = resolveChannels(appConfig, params.channels);
+          const dispatcher = new Dispatcher();
+          const result = await dispatcher.dispatch({
+            appConfig,
+            channels,
+            apkPath: params.apk,
+            updateDesc: params.desc ?? appConfig.extension.updateDesc ?? "",
+            dryRun: params.dryRun,
+            parallel: params.parallel ?? 1
+          });
+          return { content: [{ type: "text", text: JSON.stringify(result) }] };
+        }
+        case "apkpub_doctor": {
+          const appConfig = await loadConfig(params.app);
+          const channels = resolveChannels(appConfig);
+          const checks = [];
+          for (const channel of channels) {
+            const chConfig = appConfig.channels.find((c) => c.name === channel.name);
+            try {
+              const rawParams = TaskLauncher.getRawParams(chConfig);
+              const resolved = await resolveConfigSecrets(rawParams);
+              if (channel.validateCredentials) await channel.validateCredentials(resolved);
+              checks.push({ channel: channel.name, ok: true });
+            } catch (err) {
+              checks.push({ channel: channel.name, ok: false, error: String(err) });
+            }
+          }
+          return { content: [{ type: "text", text: JSON.stringify({ ok: checks.every((c) => c.ok), checks }) }] };
+        }
+        default:
+          return { content: [{ type: "text", text: JSON.stringify({ error: `\u672A\u77E5\u5DE5\u5177: ${name}` }) }], isError: true };
+      }
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }) }],
+        isError: true
+      };
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/cli/mcp.ts
+function registerMcpCommand(program2) {
+  program2.command("mcp").description("\u4EE5 MCP server \u6A21\u5F0F\u8FD0\u884C\uFF0C\u66B4\u9732 publish/status/info/doctor \u5DE5\u5177").action(async () => {
+    await startMcpServer();
+  });
+}
+
+// src/bin/apkpub.ts
+var program = new Command();
+program.name("apkpub").description("APK \u591A\u5E02\u573A\u5206\u53D1 CLI \u5DE5\u5177").version("1.0.0");
+registerInitCommand(program);
+registerConfigCommand(program);
+registerInfoCommand(program);
+registerPublishCommand(program);
+registerStatusCommand(program);
+registerChannelsCommand(program);
+registerDoctorCommand(program);
+registerDescribeCommand(program);
+registerMcpCommand(program);
+program.parseAsync(process.argv).catch((err) => {
+  process.stderr.write(`\u81F4\u547D\u9519\u8BEF: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});