@quantacenter/quanta-problem-cli 0.0.0-stage → 1.0.0

package/dist/index.js

@@ -0,0 +1,4134 @@
+#!/usr/bin/env node
+import { CommanderError, Command } from 'commander';
+import { resolve, relative, basename, join, dirname, isAbsolute, sep, extname } from 'path';
+import { readFileSync, existsSync, constants } from 'fs';
+import { readdir, writeFile, readFile, stat, mkdir, access, chmod, rename, rm } from 'fs/promises';
+import { fileURLToPath } from 'url';
+import { z } from 'zod';
+import sharp from 'sharp';
+import { createInterface } from 'readline';
+import { select as select$1, isCancel, multiselect as multiselect$1 } from '@clack/prompts';
+import { homedir } from 'os';
+import { spawn } from 'child_process';
+import { createColors } from 'picocolors';
+
+// src/core/exit-codes.ts
+var EXIT = {
+  /** 全部成功 */
+  OK: 0,
+  /** 未分类的运行时错误 */
+  FAILURE: 1,
+  /** 参数/配置用法错误（用户输入问题，不是 bug） */
+  USAGE: 2,
+  /** 预检或审计未通过（题目本身不合格，需要改题目而不是改脚本） */
+  PRECHECK_FAILED: 3,
+  /** 网络或服务端 5xx */
+  NETWORK: 4,
+  /** 未登录 / 令牌失效 / 权限不足 */
+  AUTH: 5
+};
+
+// src/core/errors.ts
+var CliError = class extends Error {
+  hint;
+  details;
+  exitCode;
+  constructor(message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = new.target.name;
+    this.hint = options.hint;
+    this.details = options.details;
+    this.exitCode = options.exitCode ?? EXIT.FAILURE;
+  }
+};
+var UsageError = class extends CliError {
+  constructor(message, options = {}) {
+    super(message, { ...options, exitCode: EXIT.USAGE });
+  }
+};
+var ConfigError = class extends CliError {
+  constructor(message, options = {}) {
+    super(message, { ...options, exitCode: EXIT.USAGE });
+  }
+};
+var PrecheckError = class extends CliError {
+  constructor(message, options = {}) {
+    super(message, { ...options, exitCode: EXIT.PRECHECK_FAILED });
+  }
+};
+var AuthError = class extends CliError {
+  constructor(message, options = {}) {
+    super(message, { ...options, exitCode: EXIT.AUTH });
+  }
+};
+var NetworkError = class extends CliError {
+  constructor(message, options = {}) {
+    super(message, { ...options, exitCode: EXIT.NETWORK });
+  }
+};
+var ApiError = class extends CliError {
+  status;
+  path;
+  constructor(message, options) {
+    const { status, path, ...rest } = options;
+    super(message, {
+      ...rest,
+      exitCode: status === 401 || status === 403 ? EXIT.AUTH : EXIT.FAILURE,
+      details: { ...rest.details, status, path }
+    });
+    this.status = status;
+    this.path = path;
+  }
+};
+var CanceledError = class extends CliError {
+  constructor(message = "\u5DF2\u53D6\u6D88") {
+    super(message, { exitCode: EXIT.FAILURE });
+  }
+};
+var isAbortError = (error) => error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
+var toCliError = (error) => {
+  if (error instanceof CliError) return error;
+  if (isAbortError(error)) {
+    return new CliError("\u8BF7\u6C42\u5DF2\u53D6\u6D88\u6216\u8D85\u65F6", {
+      cause: error,
+      hint: "\u7F51\u7EDC\u8F83\u6162\u65F6\u53EF\u8C03\u5927 QUANTA_HTTP_TIMEOUT\uFF0C\u6216\u68C0\u67E5 API \u5730\u5740\u662F\u5426\u53EF\u8FBE\u3002"
+    });
+  }
+  if (error instanceof Error) {
+    return new CliError(error.message, { cause: error });
+  }
+  return new CliError(String(error));
+};
+var pathExists = async (path) => {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var ensureDir = async (dir) => {
+  await mkdir(dir, { recursive: true });
+};
+var readText = async (path) => {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    throw new CliError(`\u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6\uFF1A${path}`, {
+      cause: error,
+      details: { path }
+    });
+  }
+};
+var writeText = async (path, content) => {
+  await ensureDir(dirname(path));
+  await writeFile(path, content, "utf8");
+};
+var writeTextAtomic = async (path, content) => {
+  const dir = dirname(path);
+  await ensureDir(dir);
+  const temp = join(dir, `.${basename(path)}.${process.pid}.tmp`);
+  const mode = await stat(path).then((info) => info.mode).catch(() => void 0);
+  try {
+    await writeFile(temp, content, "utf8");
+    if (mode !== void 0) await chmod(temp, mode);
+    await rename(temp, path);
+  } catch (error) {
+    await rm(temp, { force: true }).catch(() => {
+    });
+    throw error;
+  }
+};
+var writeTextWithMode = async (path, content, mode) => {
+  await writeText(path, content);
+  if (mode !== void 0) await chmod(path, mode);
+};
+var writeBinary = async (path, content) => {
+  await ensureDir(dirname(path));
+  await writeFile(path, content);
+};
+var listDir = async (dir) => {
+  try {
+    return await readdir(dir);
+  } catch {
+    return [];
+  }
+};
+var walkFiles = async (root, options = {}) => {
+  const results = [];
+  const walk = async (dir, prefix) => {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(
+      () => []
+    );
+    for (const entry of entries.sort(
+      (a, b) => a.name.localeCompare(b.name)
+    )) {
+      if (entry.isSymbolicLink()) continue;
+      const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (options.ignore?.(entry.name, relativePath)) continue;
+      const absolutePath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(absolutePath, relativePath);
+        continue;
+      }
+      if (entry.isFile()) results.push(relativePath);
+    }
+  };
+  await walk(root, "");
+  return results.sort();
+};
+
+// ../shared/service/backend-service-image.ts
+var PNPM_VERSION = "9.15.9";
+var BACKEND_SERVICE_IMAGES = {
+  "node-24": {
+    id: "node-24",
+    label: "Node.js 24",
+    image: "challenge-backend-service-agent",
+    editorBootCommand: (mountPath) => [
+      `[install-pnpm] npm install --global pnpm@${PNPM_VERSION}`,
+      `[install] pnpm --dir ./${mountPath} install`
+    ].join("\n"),
+    // 入口由题目的 package.json 决定；npm 在没有 scripts.start 时回退到 node server.js。
+    initCommand: (mountPath) => `[dev-server] cd ./${mountPath} && npm start`,
+    defaultPort: 3e3
+  }
+};
+var BACKEND_SERVICE_IMAGE_IDS = Object.keys(
+  BACKEND_SERVICE_IMAGES
+);
+var DEFAULT_BACKEND_SERVICE_IMAGE_ID = "node-24";
+var isBackendServiceImageId = (value) => typeof value === "string" && Object.prototype.hasOwnProperty.call(BACKEND_SERVICE_IMAGES, value);
+var normalizeBackendServiceImageId = (id) => isBackendServiceImageId(id) ? id : DEFAULT_BACKEND_SERVICE_IMAGE_ID;
+var getBackendServiceImage = (id) => BACKEND_SERVICE_IMAGES[normalizeBackendServiceImageId(id)];
+var buildBackendBootCommand = (id, mountPath) => getBackendServiceImage(id).editorBootCommand(mountPath);
+var buildBackendInitCommand = (id, mountPath) => getBackendServiceImage(id).initCommand(mountPath);
+var getBackendServiceDefaultPort = (id) => getBackendServiceImage(id).defaultPort;
+Object.values(
+  BACKEND_SERVICE_IMAGES
+).map((item) => item.image);
+
+// src/domain/cover.ts
+var COVER_DEFAULTS = {
+  bg: "#0F172A",
+  accent: "#A6FB1D",
+  text: "#F8FAFC",
+  footer: "Quanta Challenge",
+  width: 1200,
+  height: 675
+};
+var COVER_SUGGESTED_BG_TO = "#14432A";
+var HEX_COLOR = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+var isHexColor = (value) => HEX_COLOR.test(value);
+var assertHexColor = (value, field) => {
+  if (!isHexColor(value)) {
+    throw new UsageError(
+      `${field} \u5FC5\u987B\u662F\u5341\u516D\u8FDB\u5236\u989C\u8272\uFF08#rgb / #rrggbb\uFF09\uFF0C\u5F53\u524D\u4E3A "${value}"`,
+      { hint: '\u4F8B\u5982 --bg "#0F172A" --accent "#A6FB1D"\u3002' }
+    );
+  }
+  return value;
+};
+var XML_ESCAPES = {
+  "&": "&",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&apos;"
+};
+var escapeXml = (value) => value.replace(/[&<>"']/g, (char) => XML_ESCAPES[char] ?? char);
+var isWideChar = (code) => code >= 4352 && code <= 4447 || code >= 11904 && code <= 42191 || code >= 44032 && code <= 55203 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65135 || code >= 65280 && code <= 65376 || code >= 65504 && code <= 65510;
+var charWidthEm = (char, bold) => {
+  const code = char.codePointAt(0) ?? 0;
+  if (isWideChar(code)) return 1;
+  if (char === " ") return 0.28;
+  if ("ilj.,:;'|!".includes(char)) return 0.3;
+  if (/[A-Z]/.test(char)) return bold ? 0.68 : 0.66;
+  if (/[0-9]/.test(char)) return 0.58;
+  return bold ? 0.6 : 0.56;
+};
+var textWidthEm = (text, bold) => [...text].reduce((sum, char) => sum + charWidthEm(char, bold), 0);
+var isBreakAfter = (char) => char === " " || isWideChar(char.codePointAt(0) ?? 0);
+var wrapByWidth = (text, maxWidthEm, bold = true) => {
+  const lines = [];
+  let current = "";
+  let currentEm = 0;
+  let breakAt = -1;
+  let breakEm = 0;
+  const flush = (at, em) => {
+    const line = (at >= 0 ? current.slice(0, at) : current).trim();
+    if (line) lines.push(line);
+    current = at >= 0 ? current.slice(at).trimStart() : "";
+    currentEm = at >= 0 ? currentEm - em : 0;
+    breakAt = -1;
+    breakEm = 0;
+  };
+  for (const char of text) {
+    const width = charWidthEm(char, bold);
+    if (currentEm + width > maxWidthEm && current) {
+      if (breakAt > 0 && breakEm > maxWidthEm * 0.4) {
+        flush(breakAt, breakEm);
+      } else {
+        flush(-1, currentEm);
+      }
+    }
+    current += char;
+    currentEm += width;
+    if (isBreakAfter(char)) {
+      breakAt = current.length;
+      breakEm = currentEm;
+    }
+  }
+  if (current.trim()) lines.push(current.trim());
+  return lines.length > 0 ? lines : [""];
+};
+var layoutCover = (spec) => {
+  const scale = spec.width / COVER_DEFAULTS.width;
+  const pad = 72 * scale;
+  const barWidth = 6 * scale;
+  const textX = pad + barWidth + 26 * scale;
+  const contentWidth = spec.width - textX - pad;
+  const baseFontSize = 58 * scale;
+  const minFontSize = Math.max(20, baseFontSize * 0.5);
+  const maxLines = 3;
+  let fontSize = baseFontSize;
+  let lines = wrapByWidth(spec.title, contentWidth / fontSize, true);
+  for (let size = baseFontSize; size >= minFontSize; size -= 2) {
+    const candidate = wrapByWidth(spec.title, contentWidth / size, true);
+    const fits = candidate.every(
+      (line) => textWidthEm(line, true) * size <= contentWidth + 0.5
+    );
+    if (fits && candidate.length <= maxLines) {
+      fontSize = size;
+      lines = candidate;
+      break;
+    }
+    fontSize = size;
+    lines = candidate;
+  }
+  const lineHeight = fontSize * 1.22;
+  const blockTop = pad + 24 * scale;
+  const textBaseline = blockTop + fontSize;
+  const barHeight = lineHeight * (lines.length - 1) + fontSize * 1.02;
+  const subtitleFontSize = 26 * scale;
+  const subtitleBaseline = blockTop + lineHeight * (lines.length - 1) + fontSize * 0.62 + 72 * scale;
+  return {
+    lines,
+    fontSize,
+    lineHeight,
+    barX: pad,
+    barY: blockTop + fontSize * 0.06,
+    barWidth,
+    barHeight,
+    textX,
+    firstBaseline: textBaseline,
+    subtitleBaseline,
+    subtitleFontSize,
+    footerBaseline: spec.height - 60 * scale,
+    footerFontSize: 24 * scale
+  };
+};
+var fontStack = (mono) => mono ? "'Menlo','Monaco','Courier New',monospace" : "'PingFang SC','Hiragino Sans GB','Microsoft YaHei','Noto Sans CJK SC','Source Han Sans SC',sans-serif";
+var buildCoverSvg = (spec) => {
+  assertHexColor(spec.bg, "\u80CC\u666F\u8272");
+  assertHexColor(spec.accent, "\u5F3A\u8C03\u8272");
+  assertHexColor(spec.text, "\u6807\u9898\u989C\u8272");
+  if (spec.bgTo !== void 0) assertHexColor(spec.bgTo, "\u6E10\u53D8\u7EC8\u6B62\u8272");
+  const layout = layoutCover(spec);
+  const background = spec.bgTo === void 0 ? `<rect width="${spec.width}" height="${spec.height}" fill="${spec.bg}"/>` : `<defs><linearGradient id="bg" x1="0" y1="0" x2="1" y2="1"><stop offset="0%" stop-color="${spec.bg}"/><stop offset="100%" stop-color="${spec.bgTo}"/></linearGradient></defs><rect width="${spec.width}" height="${spec.height}" fill="url(#bg)"/>`;
+  const titleLines = layout.lines.map(
+    (line, index) => `<text x="${layout.textX}" y="${round(layout.firstBaseline + index * layout.lineHeight)}" font-family="${fontStack(false)}" font-size="${round(layout.fontSize)}" font-weight="700" fill="${spec.text}">${escapeXml(line)}</text>`
+  ).join("\n");
+  const subtitle = spec.subtitle ? `<text x="${layout.textX}" y="${round(layout.subtitleBaseline)}" font-family="${fontStack(true)}" font-size="${round(layout.subtitleFontSize)}" font-weight="700" fill="${spec.accent}">${escapeXml(spec.subtitle)}</text>` : "";
+  const footer = `<text x="${layout.barX}" y="${round(layout.footerBaseline)}" font-family="${fontStack(false)}" font-size="${round(layout.footerFontSize)}" fill="#64748B">${escapeXml(spec.footer ?? COVER_DEFAULTS.footer)}</text>`;
+  return [
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${spec.width}" height="${spec.height}" viewBox="0 0 ${spec.width} ${spec.height}">`,
+    background,
+    `<rect x="${layout.barX}" y="${round(layout.barY)}" width="${layout.barWidth}" height="${round(layout.barHeight)}" rx="${layout.barWidth / 2}" fill="${spec.accent}"/>`,
+    titleLines,
+    subtitle,
+    footer,
+    "</svg>"
+  ].filter(Boolean).join("\n");
+};
+var round = (value) => Math.round(value * 100) / 100;
+
+// src/domain/problem-config-schema.ts
+var DIFFICULTIES = ["easy", "medium", "hard", "very_hard"];
+var DEFAULT_CONFIG_FILES = [
+  "problem.config.ts",
+  "problem.config.mts",
+  "problem.config.js",
+  "problem.config.mjs",
+  "problem.config.json"
+];
+var DEFAULT_JUDGE_UPLOAD_PATH = "project";
+var DEFAULT_INIT_COMMAND = "npx serve -l 3000 project";
+var PROBLEM_TYPES = ["frontend", "backend_service"];
+var coverGenerateSchema = z.object({
+  /** 背景色（纯色；配合 bgTo 变成对角线渐变） */
+  bg: z.string().default(COVER_DEFAULTS.bg),
+  /** 渐变终止色，留空 = 纯色背景 */
+  bgTo: z.string().optional(),
+  /** 强调色：左侧竖条 + 副标题 */
+  accent: z.string().default(COVER_DEFAULTS.accent),
+  /** 主标题颜色 */
+  text: z.string().default(COVER_DEFAULTS.text),
+  /** 副标题（建议写接口清单或一句话简介），留空则不渲染 */
+  subtitle: z.string().optional(),
+  /** 左下角页脚，默认 “Quanta Challenge” */
+  footer: z.string().optional(),
+  width: z.number().int().min(200).max(4096).default(COVER_DEFAULTS.width),
+  height: z.number().int().min(200).max(4096).default(COVER_DEFAULTS.height),
+  /** 输出文件（相对题目目录） */
+  out: z.string().default("cover.png")
+});
+var coverSchema = z.union([
+  z.object({ mode: z.literal("default") }),
+  z.object({
+    mode: z.literal("custom"),
+    /** 平台上的图片 id；`qpc cover --upload --write` 会把生成结果写回这里 */
+    imageId: z.string().min(1).optional(),
+    /** 配置了就能用 `qpc cover` 一键生成（后端题型必须自定义封面） */
+    generate: coverGenerateSchema.optional()
+  })
+]);
+var problemConfigSchema = z.object({
+  title: z.string().min(1, "title \u4E0D\u80FD\u4E3A\u7A7A"),
+  /** 平台题目 id（qpc upload 返回的 pid）：填了它就在该题目下追加新版本，否则每次新建 */
+  problemId: z.number().int().positive().optional(),
+  /** 题型；缺省为前端，老题目不需要改配置 */
+  type: z.enum(PROBLEM_TYPES).default("frontend"),
+  /** 题面正文；与 detailFile 二选一 */
+  detail: z.string().min(1).optional(),
+  /** 题面文件（相对题目目录），便于把长题面单独放一个 markdown */
+  detailFile: z.string().min(1).optional(),
+  difficulty: z.enum(DIFFICULTIES),
+  tagIds: z.array(z.number().int().positive()).min(1, "tagIds \u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u6807\u7B7E\uFF08\u7528 `qpc tag` \u67E5\u770B\u53EF\u7528 id\uFF09"),
+  /** 留空表示"以判题脚本里各检查点之和为准"；填写则必须与之和相等 */
+  totalScore: z.number().int().positive().optional(),
+  cover: coverSchema.default({ mode: "default" }),
+  runtime: z.object({
+    /** 判题时打包上传的目录，同时决定快照挂载路径（快照键为 `/<judgeUploadPath>/...`） */
+    judgeUploadPath: z.string().min(1).default(DEFAULT_JUDGE_UPLOAD_PATH),
+    initCommand: z.string().min(1).default(DEFAULT_INIT_COMMAND),
+    buildCommand: z.string().min(1).optional(),
+    bootCommand: z.string().min(1).optional(),
+    /** 后端服务：初始镜像 id（不是 docker 镜像名，取值见 @challenge/shared/backend-service-image） */
+    serviceImage: z.enum(BACKEND_SERVICE_IMAGE_IDS).optional(),
+    /** 后端服务：服务监听端口（也是判题机请求的端口） */
+    servicePort: z.number().int().positive().max(65535).default(3e3)
+  }).default({
+    judgeUploadPath: DEFAULT_JUDGE_UPLOAD_PATH,
+    initCommand: DEFAULT_INIT_COMMAND,
+    servicePort: 3e3
+  }),
+  paths: z.object({
+    template: z.string().min(1).default("template"),
+    answer: z.string().min(1).default("answer"),
+    judge: z.string().min(1).default("judge.js")
+  }).default({ template: "template", answer: "answer", judge: "judge.js" })
+});
+var applyBackendServiceImageDefaults = (config) => {
+  if (config.type !== "backend_service") {
+    return { config, overridden: [] };
+  }
+  const mountPath = config.runtime.judgeUploadPath || DEFAULT_JUDGE_UPLOAD_PATH;
+  const serviceImage = normalizeBackendServiceImageId(
+    config.runtime.serviceImage
+  );
+  const bootCommand = buildBackendBootCommand(serviceImage, mountPath);
+  const defaultInitCommand = buildBackendInitCommand(serviceImage, mountPath);
+  const overridden = [];
+  if (config.runtime.bootCommand && config.runtime.bootCommand !== bootCommand) {
+    overridden.push("runtime.bootCommand");
+  }
+  const initCommand = !config.runtime.initCommand || config.runtime.initCommand === DEFAULT_INIT_COMMAND ? defaultInitCommand : config.runtime.initCommand;
+  return {
+    config: {
+      ...config,
+      runtime: {
+        ...config.runtime,
+        serviceImage,
+        servicePort: config.runtime.servicePort ?? getBackendServiceDefaultPort(serviceImage),
+        bootCommand,
+        initCommand
+      }
+    },
+    overridden
+  };
+};
+
+// src/domain/problem-config.ts
+var loadProblemConfig = async (rootDir, options = {}) => {
+  const configFile = await findConfigFile(rootDir, options.file);
+  const module = await importConfig(configFile);
+  const parsed = problemConfigSchema.safeParse(module);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map(
+      (issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`
+    );
+    throw new ConfigError(
+      `\u9898\u76EE\u914D\u7F6E\u6821\u9A8C\u5931\u8D25\uFF1A${configFile}
+  - ${issues.join("\n  - ")}`,
+      {
+        details: { issues },
+        hint: "\u5BF9\u7167 examples/hello-total/problem.config.ts \u7684\u5B57\u6BB5\u8BF4\u660E\u4FEE\u6B63\u3002"
+      }
+    );
+  }
+  const parsedConfig = applyBackendServiceImageDefaults(parsed.data);
+  const config = parsedConfig.config;
+  const detail = await resolveDetail(config, rootDir, configFile);
+  return {
+    ...config,
+    detail,
+    rootDir,
+    configFile,
+    overriddenByImage: parsedConfig.overridden,
+    paths: {
+      template: resolve(rootDir, config.paths.template),
+      answer: resolve(rootDir, config.paths.answer),
+      judge: resolve(rootDir, config.paths.judge)
+    }
+  };
+};
+var findConfigFile = async (rootDir, explicit) => {
+  if (explicit) {
+    const candidate = isAbsolute(explicit) ? explicit : resolve(rootDir, explicit);
+    if (!await pathExists(candidate)) {
+      throw new ConfigError(`\u6307\u5B9A\u7684\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${candidate}`);
+    }
+    return candidate;
+  }
+  for (const name of DEFAULT_CONFIG_FILES) {
+    const candidate = resolve(rootDir, name);
+    if (await pathExists(candidate)) return candidate;
+  }
+  throw new ConfigError(
+    `\u5728 ${rootDir} \u4E0B\u627E\u4E0D\u5230\u9898\u76EE\u914D\u7F6E\uFF08\u671F\u671B ${DEFAULT_CONFIG_FILES.join(" / ")} \u4E4B\u4E00\uFF09`,
+    {
+      hint: `\u521B\u5EFA ${DEFAULT_CONFIG_FILES[0]}\uFF0C\u6216\u5148\u8FD0\u884C \`qpc init <\u76EE\u5F55>\`\u3002`
+    }
+  );
+};
+var importConfig = async (file) => {
+  const { createJiti } = await import('jiti');
+  const jiti = createJiti(import.meta.url, {
+    interopDefault: true,
+    moduleCache: false,
+    alias: {
+      // 让配置文件里的 `import { defineProblemConfig } from '@challenge/problem-creator-cli'`
+      // 无论 CLI 是从源码跑（tsx）还是从 dist 跑都能解析到同一个模块。
+      "@challenge/problem-creator-cli": programModulePath()
+    }
+  });
+  try {
+    return await jiti.import(file);
+  } catch (error) {
+    throw new ConfigError(`\u65E0\u6CD5\u52A0\u8F7D\u914D\u7F6E\u6587\u4EF6\uFF1A${file}`, {
+      cause: error,
+      details: {
+        reason: error instanceof Error ? error.message : String(error)
+      }
+    });
+  }
+};
+var programModulePath = () => {
+  const candidates = [
+    "./program.js",
+    "../program.js",
+    "../program.ts",
+    "./program.ts"
+  ];
+  for (const candidate of candidates) {
+    const path = fileURLToPath(new URL(candidate, import.meta.url));
+    if (existsSync(path)) return path;
+  }
+  throw new ConfigError(
+    "\u5185\u90E8\u9519\u8BEF\uFF1A\u627E\u4E0D\u5230 program \u6A21\u5757\uFF08\u65E0\u6CD5\u89E3\u6790 defineProblemConfig\uFF09",
+    {
+      details: { from: import.meta.url, candidates }
+    }
+  );
+};
+var resolveDetail = async (config, rootDir, configFile) => {
+  if (config.detail) return config.detail;
+  if (!config.detailFile) {
+    throw new ConfigError(
+      `\u9898\u76EE\u914D\u7F6E\u7F3A\u5C11\u9898\u9762\uFF1A${configFile} \u91CC\u9700\u8981 detail \u6216 detailFile`,
+      {
+        hint: "\u63D0\u4F9B `detail`\uFF08\u6B63\u6587\uFF09\u6216 `detailFile`\uFF08\u76F8\u5BF9\u9898\u76EE\u76EE\u5F55\u7684\u6587\u4EF6\u8DEF\u5F84\uFF09\u3002"
+      }
+    );
+  }
+  const file = resolve(rootDir, config.detailFile);
+  if (!await pathExists(file)) {
+    throw new ConfigError(`detailFile \u6307\u5411\u7684\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${file}`);
+  }
+  return readFile(file, "utf8");
+};
+var toPosix = (path) => path.split(sep).join("/");
+var displayPath = (cwd, target) => {
+  const rel = relative(cwd, target);
+  return rel.startsWith("..") ? target : toPosix(rel);
+};
+var normalizeSnapshotKey = (key) => {
+  const segments = toPosix(key).split("/").filter((s) => s && s !== ".");
+  return `/${segments.join("/")}`;
+};
+var joinSnapshotKey = (mountPath, relativePath) => normalizeSnapshotKey(`${mountPath}/${relativePath}`);
+var formatBytes = (bytes) => {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
+};
+
+// src/domain/judge-script.ts
+var IDENT = /[A-Za-z0-9_$]/;
+var isRegexStart = (code, index) => {
+  let i = index - 1;
+  while (i >= 0 && /\s/.test(code[i])) i -= 1;
+  if (i < 0) return true;
+  return /[([{,;:=!&|?+\-*%~^<>]/.test(code[i]);
+};
+var skipQuoted = (code, start, quote) => {
+  let i = start + 1;
+  while (i < code.length) {
+    const ch = code[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === quote) return i + 1;
+    if (ch === "\n") return i;
+    i += 1;
+  }
+  return code.length;
+};
+var skipTemplate = (code, start) => {
+  let i = start + 1;
+  while (i < code.length) {
+    const ch = code[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === "`") return i + 1;
+    if (ch === "$" && code[i + 1] === "{") {
+      i = skipBalanced(code, i + 1, "{", "}");
+      continue;
+    }
+    i += 1;
+  }
+  return code.length;
+};
+var skipRegex = (code, start) => {
+  let i = start + 1;
+  let inClass = false;
+  while (i < code.length) {
+    const ch = code[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === "[") inClass = true;
+    else if (ch === "]") inClass = false;
+    else if (ch === "/" && !inClass) return i + 1;
+    else if (ch === "\n") return i;
+    i += 1;
+  }
+  return code.length;
+};
+var skipBalanced = (code, openIndex, open, close) => {
+  let depth = 0;
+  let i = openIndex;
+  while (i < code.length) {
+    const ch = code[i];
+    if (ch === "/" && code[i + 1] === "/") {
+      const end = code.indexOf("\n", i);
+      i = end === -1 ? code.length : end;
+      continue;
+    }
+    if (ch === "/" && code[i + 1] === "*") {
+      const end = code.indexOf("*/", i + 2);
+      i = end === -1 ? code.length : end + 2;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      i = skipQuoted(code, i, ch);
+      continue;
+    }
+    if (ch === "`") {
+      i = skipTemplate(code, i);
+      continue;
+    }
+    if (ch === "/" && isRegexStart(code, i)) {
+      i = skipRegex(code, i);
+      continue;
+    }
+    if (ch === open) depth += 1;
+    else if (ch === close) {
+      depth -= 1;
+      if (depth === 0) return i + 1;
+    }
+    i += 1;
+  }
+  return code.length;
+};
+var maskNonCode = (code) => {
+  const chars = code.split("");
+  const blank = (from, to) => {
+    for (let i2 = from; i2 < to; i2 += 1) {
+      if (chars[i2] !== "\n") chars[i2] = " ";
+    }
+  };
+  let i = 0;
+  while (i < code.length) {
+    const ch = code[i];
+    const next = code[i + 1];
+    if (ch === "/" && next === "/") {
+      const end = code.indexOf("\n", i);
+      const to = end === -1 ? code.length : end;
+      blank(i, to);
+      i = to;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      const end = code.indexOf("*/", i + 2);
+      const to = end === -1 ? code.length : end + 2;
+      blank(i, to);
+      i = to;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      const to = skipQuoted(code, i, ch);
+      blank(i, to);
+      i = to;
+      continue;
+    }
+    if (ch === "`") {
+      const to = skipTemplate(code, i);
+      blank(i, to);
+      i = to;
+      continue;
+    }
+    if (ch === "/" && isRegexStart(code, i)) {
+      const to = skipRegex(code, i);
+      blank(i, to);
+      i = to;
+      continue;
+    }
+    i += 1;
+  }
+  return chars.join("");
+};
+var splitArgs = (code, mask, from, to) => {
+  const args = [];
+  let depth = 0;
+  let start = from;
+  for (let i = from; i < to; i += 1) {
+    const ch = mask[i];
+    if (ch === "(" || ch === "[" || ch === "{") depth += 1;
+    else if (ch === ")" || ch === "]" || ch === "}") depth -= 1;
+    else if (ch === "," && depth === 0) {
+      args.push(code.slice(start, i));
+      start = i + 1;
+    }
+  }
+  if (to > from) args.push(code.slice(start, to));
+  return args.map((arg) => arg.trim()).filter((arg) => arg.length > 0);
+};
+var findCalls = (code, mask, callee) => {
+  const sites = [];
+  let i = 0;
+  while (i < mask.length) {
+    const index = mask.indexOf(callee, i);
+    if (index === -1) break;
+    const before = index === 0 ? "" : mask[index - 1];
+    const afterIndex = index + callee.length;
+    const after = afterIndex >= mask.length ? "" : mask[afterIndex];
+    if (IDENT.test(callee[0]) && before && IDENT.test(before)) {
+      i = index + 1;
+      continue;
+    }
+    if (after && IDENT.test(after)) {
+      i = index + 1;
+      continue;
+    }
+    let cursor = afterIndex;
+    while (cursor < mask.length && /\s/.test(mask[cursor]))
+      cursor += 1;
+    if (mask[cursor] !== "(") {
+      i = index + 1;
+      continue;
+    }
+    const end = skipBalanced(mask, cursor, "(", ")");
+    sites.push({
+      start: index,
+      end,
+      args: splitArgs(code, mask, cursor + 1, end - 1)
+    });
+    i = end;
+  }
+  return sites;
+};
+var lineOf = (code, index) => {
+  let line = 1;
+  for (let i = 0; i < index && i < code.length; i += 1) {
+    if (code[i] === "\n") line += 1;
+  }
+  return line;
+};
+var parseStringLiteral = (text) => {
+  const trimmed = text.trim();
+  const quote = trimmed[0];
+  if (quote !== '"' && quote !== "'" && quote !== "`") return void 0;
+  if (trimmed.length < 2 || trimmed[trimmed.length - 1] !== quote)
+    return void 0;
+  const body = trimmed.slice(1, -1);
+  if (quote === "`" && body.includes("${")) return void 0;
+  return body.replace(/\\(.)/g, (_, char) => {
+    const escapes = {
+      n: "\n",
+      t: "	",
+      r: "\r",
+      "\\": "\\",
+      '"': '"',
+      "'": "'",
+      "`": "`"
+    };
+    return escapes[char] ?? char;
+  });
+};
+var analyzeJudgeScript = (code) => {
+  const mask = maskNonCode(code);
+  const handlerCalls = findCalls(code, mask, "defineTestHandler");
+  const checkpointCalls = findCalls(code, mask, "defineCheckPoint");
+  const expectCalls = findCalls(code, mask, "expect");
+  const checkpoints = [];
+  const unparsedCheckpoints = [];
+  for (const call of checkpointCalls) {
+    const [nameArg = "", scoreArg = "", handlerArg = ""] = call.args;
+    const name = parseStringLiteral(nameArg) ?? nameArg.replace(/\s+/g, " ").trim();
+    const score = Number.parseFloat(scoreArg.trim());
+    const line = lineOf(code, call.start);
+    if (!Number.isFinite(score)) {
+      unparsedCheckpoints.push({
+        line,
+        value: scoreArg.trim() || "<missing>"
+      });
+    }
+    const returnsValue = /\breturn\b\s*[^;\s}]/.test(maskNonCode(handlerArg));
+    checkpoints.push({
+      name: name || "<unnamed>",
+      score: Number.isFinite(score) ? score : 0,
+      line,
+      returnsValue
+    });
+  }
+  const clickWithoutTimeout = [];
+  for (const call of findCalls(code, mask, ".click")) {
+    const snippet = code.slice(Math.max(0, call.start - 16), call.end).replace(/\s+/g, " ").trim();
+    if (/\btimeout\b/.test(mask.slice(call.start, call.end))) continue;
+    clickWithoutTimeout.push({
+      line: lineOf(code, call.start),
+      value: snippet
+    });
+  }
+  const vagueExpectations = [];
+  for (const call of expectCalls) {
+    const message = call.args[1];
+    if (message === void 0) continue;
+    if (/\$\{|\+|实际|expected|Received/i.test(message)) continue;
+    vagueExpectations.push({
+      line: lineOf(code, call.start),
+      value: parseStringLiteral(message) ?? message.replace(/\s+/g, " ").trim()
+    });
+  }
+  const namedExports = [];
+  const exportRe = /\bexport\s+(?!default\b)(?:const|let|var|function|class|async)\s+([A-Za-z0-9_$]+)/g;
+  for (const match of mask.matchAll(exportRe)) {
+    if (match[1]) namedExports.push(match[1]);
+  }
+  return {
+    hasDefaultExport: /\bexport\s+default\b/.test(mask),
+    hasDefineTestHandler: handlerCalls.length > 0,
+    namedExports,
+    checkpoints,
+    checkpointTotal: checkpoints.reduce((sum, cp) => sum + cp.score, 0),
+    unparsedCheckpoints,
+    clickWithoutTimeout,
+    vagueExpectations,
+    expectationCount: expectCalls.length,
+    lineCount: code.split("\n").length
+  };
+};
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "bmp",
+  "tiff",
+  "webp",
+  "ico",
+  "cur"
+]);
+var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".turbo",
+  ".DS_Store",
+  "dist",
+  "coverage"
+]);
+var collectSnapshot = async (root, options = {}) => {
+  const mountPath = options.mountPath ?? "project";
+  const ignore = (name) => DEFAULT_IGNORE.has(name) || (options.ignore?.(name) ?? false);
+  const ignored = /* @__PURE__ */ new Set();
+  const relativePaths = await walkFiles(root, {
+    ignore: (name) => {
+      if (!ignore(name)) return false;
+      ignored.add(name);
+      return true;
+    }
+  });
+  const files = {};
+  let totalBytes = 0;
+  for (const relativePath of relativePaths) {
+    const absolutePath = join(root, relativePath);
+    let buffer;
+    try {
+      buffer = await readFile(absolutePath);
+    } catch (error) {
+      throw new CliError(`\u5FEB\u7167\u8BFB\u53D6\u5931\u8D25\uFF1A${absolutePath}`, { cause: error });
+    }
+    const extension = extname(relativePath).slice(1).toLowerCase();
+    files[joinSnapshotKey(mountPath, relativePath)] = BINARY_EXTENSIONS.has(
+      extension
+    ) ? buffer.toString("base64") : buffer.toString("utf8");
+    totalBytes += buffer.byteLength;
+  }
+  return {
+    files,
+    fileCount: Object.keys(files).length,
+    totalBytes,
+    ignored: [...ignored].sort()
+  };
+};
+
+// src/domain/validate.ts
+var validateProblem = async (config, options = {}) => {
+  const findings = [];
+  const push = (finding) => {
+    findings.push(finding);
+  };
+  const rel = (path) => displayPath(config.rootDir, path);
+  const judgeExists = await pathExists(config.paths.judge);
+  if (!judgeExists) {
+    push({
+      rule: "JUD001",
+      severity: "error",
+      message: `\u5224\u9898\u811A\u672C\u4E0D\u5B58\u5728\uFF1A${rel(config.paths.judge)}`,
+      file: rel(config.paths.judge),
+      hint: "\u5728\u9898\u76EE\u76EE\u5F55\u4E0B\u521B\u5EFA judge.js\uFF0C\u53C2\u8003 examples/hello-total/judge.js\u3002"
+    });
+  }
+  const judgeCode = judgeExists ? await readText(config.paths.judge) : "";
+  const analysis = analyzeJudgeScript(judgeCode);
+  if (judgeExists && !analysis.hasDefaultExport) {
+    push({
+      rule: "JUD002",
+      severity: "error",
+      message: "\u5224\u9898\u811A\u672C\u7F3A\u5C11 `export default defineTestHandler(...)`",
+      file: rel(config.paths.judge),
+      hint: "\u5224\u9898\u673A\u628A\u6587\u672C `export default ` \u66FF\u6362\u6210 `const run = `\uFF1B\u5199\u6210\u88F8\u51FD\u6570\u58F0\u660E\u4E0D\u4F1A\u751F\u6548\u3002"
+    });
+  }
+  if (judgeExists && !analysis.hasDefineTestHandler) {
+    push({
+      rule: "JUD003",
+      severity: "error",
+      message: "\u5224\u9898\u811A\u672C\u6CA1\u6709\u8C03\u7528 defineTestHandler",
+      file: rel(config.paths.judge)
+    });
+  }
+  for (const checkpoint of analysis.checkpoints) {
+    if (!checkpoint.returnsValue) {
+      push({
+        rule: "JUD004",
+        severity: "error",
+        message: `\u68C0\u67E5\u70B9\u300C${checkpoint.name}\u300D\u7684 handler \u6CA1\u6709 return \u5206\u6570`,
+        file: rel(config.paths.judge),
+        line: checkpoint.line,
+        hint: "handler \u672B\u5C3E\u8865 `return ${checkpoint.score};`\u3002\u4E0D return \u65F6\u5373\u4F7F\u65AD\u8A00\u5168\u8FC7\u4E5F\u8BB0 0 \u5206\u3002"
+      });
+    }
+    if (checkpoint.score <= 0) {
+      push({
+        rule: "JUD005",
+        severity: "warn",
+        message: `\u68C0\u67E5\u70B9\u300C${checkpoint.name}\u300D\u5206\u503C\u4E3A ${checkpoint.score}`,
+        file: rel(config.paths.judge),
+        line: checkpoint.line
+      });
+    }
+  }
+  for (const unparsed of analysis.unparsedCheckpoints) {
+    push({
+      rule: "JUD006",
+      severity: "warn",
+      message: `\u68C0\u67E5\u70B9\u5206\u503C\u4E0D\u662F\u5B57\u9762\u91CF\uFF0C\u65E0\u6CD5\u5728\u672C\u5730\u7D2F\u52A0\uFF1A${unparsed.value}`,
+      file: rel(config.paths.judge),
+      line: unparsed.line,
+      hint: "\u8BF7\u7528\u6570\u5B57\u5B57\u9762\u91CF\u5199\u5206\u503C\uFF0C\u672C\u5730\u6821\u9A8C\u4E0E\u7EBF\u4E0A\u5BA1\u8BA1\u624D\u80FD\u5BF9\u4E0A\u3002"
+    });
+  }
+  const duplicated = duplicateNames(analysis.checkpoints.map((c) => c.name));
+  for (const name of duplicated) {
+    push({
+      rule: "JUD007",
+      severity: "warn",
+      message: `\u68C0\u67E5\u70B9\u540D\u79F0\u91CD\u590D\uFF1A${name}`,
+      file: rel(config.paths.judge),
+      hint: "\u540C\u540D\u68C0\u67E5\u70B9\u5728\u5224\u9898\u8BE6\u60C5\u91CC\u65E0\u6CD5\u533A\u5206\uFF0C\u5EFA\u8BAE\u6539\u6210\u552F\u4E00\u7684\u63CF\u8FF0\u3002"
+    });
+  }
+  for (const click of analysis.clickWithoutTimeout) {
+    push({
+      rule: "JUD008",
+      severity: "warn",
+      message: `click \u672A\u8BBE\u7F6E timeout\uFF1A${click.value}`,
+      file: rel(config.paths.judge),
+      line: click.line,
+      hint: "\u76EE\u6807\u53EF\u80FD\u662F disabled \u6309\u94AE\uFF0CPlaywright \u4F1A\u91CD\u8BD5\u5230 30 \u79D2\u8D85\u65F6\uFF1B\u6539\u6D3E\u53D1\u5408\u6210\u4E8B\u4EF6\u6216\u52A0 `{ timeout: 3000 }`\u3002"
+    });
+  }
+  for (const vague of analysis.vagueExpectations) {
+    push({
+      rule: "JUD009",
+      severity: "info",
+      message: `\u65AD\u8A00\u6D88\u606F\u6CA1\u6709\u8BF4\u660E"\u671F\u671B vs \u5B9E\u9645"\uFF1A${vague.value}`,
+      file: rel(config.paths.judge),
+      line: vague.line,
+      hint: '\u6D88\u606F\u4F1A\u539F\u6837\u5C55\u793A\u7ED9\u5B66\u751F\uFF0C\u5EFA\u8BAE\u62FC\u63A5\u5B9E\u9645\u503C\uFF0C\u4F8B\u5982 `\u5408\u8BA1\u5E94\u4E3A 10.50\uFF0C\u5B9E\u9645\u4E3A "${actual}"`\u3002'
+    });
+  }
+  if (judgeExists && analysis.expectationCount === 0) {
+    push({
+      rule: "JUD010",
+      severity: "warn",
+      message: "\u5224\u9898\u811A\u672C\u91CC\u6CA1\u6709\u4EFB\u4F55 $.expect \u65AD\u8A00",
+      file: rel(config.paths.judge)
+    });
+  }
+  for (const name of analysis.namedExports) {
+    push({
+      rule: "JUD011",
+      severity: "warn",
+      message: `\u5B58\u5728 default \u4E4B\u5916\u7684\u5BFC\u51FA\uFF1A${name}`,
+      file: rel(config.paths.judge),
+      hint: "\u6A21\u5757\u88AB\u66FF\u6362\u540E\u8FD9\u4E9B\u5BFC\u51FA\u4ECD\u4F1A\u6B8B\u7559\uFF0C\u53EF\u80FD\u5BFC\u81F4\u6C99\u7BB1\u91CC\u51FA\u73B0\u610F\u6599\u4E4B\u5916\u7684\u7ED1\u5B9A\u3002"
+    });
+  }
+  const totalScore = config.totalScore ?? analysis.checkpointTotal;
+  if (config.totalScore !== void 0 && config.totalScore !== analysis.checkpointTotal) {
+    push({
+      rule: "CFG001",
+      severity: "error",
+      message: `totalScore=${config.totalScore} \u4E0E\u68C0\u67E5\u70B9\u4E4B\u548C ${analysis.checkpointTotal} \u4E0D\u4E00\u81F4`,
+      file: rel(config.configFile),
+      hint: "\u5BA1\u8BA1\u901A\u8FC7\u7684\u6761\u4EF6\u662F score === totalScore\uFF0C\u4E24\u8005\u4E0D\u7B49\u65F6\u7EBF\u4E0A\u4F1A\u5224\u5931\u8D25\u3002"
+    });
+  }
+  if (config.totalScore === void 0) {
+    push({
+      rule: "CFG002",
+      severity: "info",
+      message: `\u672A\u6307\u5B9A totalScore\uFF0C\u6309\u68C0\u67E5\u70B9\u4E4B\u548C\u53D6 ${analysis.checkpointTotal}`,
+      file: rel(config.configFile)
+    });
+  }
+  const isBackend = config.type === "backend_service";
+  const mountPath = config.runtime.judgeUploadPath;
+  const initCommand = config.runtime.initCommand;
+  if (!isBackend && initCommand && !initCommand.includes(mountPath)) {
+    push({
+      rule: "RUN001",
+      severity: "warn",
+      message: `initCommand \u672A\u5305\u542B\u4E0A\u4F20\u76EE\u5F55 "${mountPath}"\uFF1A${initCommand}`,
+      file: rel(config.configFile),
+      hint: "\u7AD9\u70B9\u6839\u5FC5\u987B\u7B49\u4E8E\u5224\u9898\u6253\u5305\u76EE\u5F55\uFF0C\u5426\u5219\u5224\u9898\u673A\u4F1A\u5728\u9519\u8BEF\u7684\u76EE\u5F55\u4E0B\u627E index.html \u76F4\u5230\u8D85\u65F6\u3002"
+    });
+  }
+  if (config.cover.mode === "custom" && !("imageId" in config.cover)) {
+    push({
+      rule: "IMG001",
+      severity: "error",
+      message: "cover.mode=custom \u65F6\u5FC5\u987B\u63D0\u4F9B imageId",
+      file: rel(config.configFile),
+      hint: "\u914D\u7F6E\u4E86 cover.generate \u7684\u8BDD\uFF0C\u8DD1 `qpc cover --upload --write` \u4E00\u952E\u751F\u6210\u5E76\u5199\u56DE\uFF1B\u5426\u5219\u628A\u5E73\u53F0\u4E0A\u7684\u56FE\u7247 id \u586B\u8FDB imageId\u3002"
+    });
+  }
+  if (isBackend) {
+    for (const field of config.overriddenByImage) {
+      push({
+        rule: "RUN002",
+        severity: "warn",
+        message: `${field} \u4F1A\u88AB\u521D\u59CB\u955C\u50CF ${config.runtime.serviceImage} \u89C4\u5B9A\u7684\u547D\u4EE4\u8986\u76D6\uFF0C\u4E0D\u4F1A\u751F\u6548`,
+        file: rel(config.configFile),
+        hint: "\u7F16\u8F91\u5668\u91CC\u7684\u4E00\u6B21\u6027\u51C6\u5907\u6B65\u9AA4\u7531\u955C\u50CF\u51B3\u5B9A\uFF08\u4E0E\u5BB9\u5668\u5185\u7684\u79BB\u7EBF\u5B89\u88C5\u4FDD\u6301\u4E00\u81F4\uFF09\uFF1B\u670D\u52A1\u542F\u52A8\u547D\u4EE4\u8BF7\u5199\u5728 runtime.initCommand\u3002"
+      });
+    }
+    if (config.cover.mode === "default") {
+      push({
+        rule: "IMG002",
+        severity: "error",
+        message: "\u540E\u7AEF\u670D\u52A1\u9898\u578B\u5FC5\u987B\u4F7F\u7528\u81EA\u5B9A\u4E49\u5C01\u9762\uFF08\u6CA1\u6709\u9996\u5C4F\u53EF\u622A\u56FE\uFF09",
+        file: rel(config.configFile),
+        hint: '\u628A cover \u6539\u6210 { mode: "custom", generate: { bg: "#0F172A", bgTo: "#14432A" } }\uFF0C\u518D\u8DD1 `qpc cover --upload --write`\u3002'
+      });
+    }
+  }
+  const template = await collectSnapshot(config.paths.template, { mountPath });
+  const answer = await collectSnapshot(config.paths.answer, { mountPath });
+  const checkArtifact = async (label, dir, snapshot, rulePrefix, requireIndex) => {
+    const relative4 = rel(dir);
+    if (!await pathExists(dir)) {
+      push({
+        rule: `${rulePrefix}001`,
+        severity: "error",
+        message: `${label} \u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${relative4}`,
+        file: relative4,
+        hint: "\u9898\u76EE\u5FC5\u987B\u6709\u7B54\u6848\u6A21\u677F\uFF08\u5B66\u751F\u8D77\u70B9\uFF09\u4E0E\u53C2\u8003\u89E3\uFF08\u62FF\u6EE1\u5206\u7684\u7B54\u6848\uFF09\u3002"
+      });
+      return;
+    }
+    if (snapshot.fileCount === 0) {
+      push({
+        rule: `${rulePrefix}002`,
+        severity: "error",
+        message: `${label} \u76EE\u5F55\u4E3A\u7A7A\uFF1A${relative4}`,
+        file: relative4
+      });
+      return;
+    }
+    const hasIndex = Object.keys(snapshot.files).some(
+      (key) => key.endsWith("/index.html")
+    );
+    if (requireIndex && label === "template" && !hasIndex) {
+      push({
+        rule: "TPL003",
+        severity: "error",
+        message: `\u7B54\u6848\u6A21\u677F\u7F3A\u5C11 index.html\uFF08\u7AD9\u70B9\u6839 = ${mountPath}\uFF09`,
+        file: relative4,
+        hint: "initCommand \u4EE5\u8BE5\u76EE\u5F55\u4E3A\u7AD9\u70B9\u6839\u542F\u52A8\u9759\u6001\u670D\u52A1\u5668\uFF0C\u6CA1\u6709 index.html \u65F6\u5224\u9898\u4F1A\u4E00\u76F4\u7B49\u9009\u62E9\u5668\u3002"
+      });
+    }
+    if (isBackend && label === "answer") {
+      const hasLockfile = Object.keys(snapshot.files).some(
+        (key) => key.endsWith("/pnpm-lock.yaml")
+      );
+      if (!hasLockfile) {
+        push({
+          rule: "RUN003",
+          severity: "error",
+          message: `\u540E\u7AEF\u670D\u52A1\u53C2\u8003\u7B54\u6848\u7F3A\u5C11 pnpm-lock.yaml\uFF08\u5E94\u5728 ${mountPath}/ \u4E0B\uFF09`,
+          file: relative4,
+          hint: "\u79BB\u7EBF\u5B89\u88C5\u4F9D\u8D56\u9501\u6587\u4EF6\uFF1B\u6CA1\u6709\u5B83\u5BB9\u5668\u65E0\u6CD5\u5728\u65AD\u7F51\u73AF\u5883\u4E0B\u5B89\u88C5\u4F9D\u8D56\u3002\u5148\u5728\u53C2\u8003\u7B54\u6848\u76EE\u5F55\u6267\u884C\u4E00\u6B21 pnpm install \u751F\u6210\u3002"
+        });
+      }
+    }
+    for (const ignored of snapshot.ignored) {
+      push({
+        rule: "SNAP003",
+        severity: "info",
+        message: `${relative4} \u4E0B\u5DF2\u8DF3\u8FC7 ${ignored}/\uFF08\u6784\u5EFA\u4EA7\u7269\u6216\u4F9D\u8D56\uFF09`,
+        file: relative4
+      });
+    }
+  };
+  await checkArtifact(
+    "template",
+    config.paths.template,
+    template,
+    "TPL",
+    !isBackend
+  );
+  await checkArtifact(
+    "answer",
+    config.paths.answer,
+    answer,
+    "ANS",
+    !isBackend
+  );
+  const maxUploadBytes = options.maxUploadBytes ?? Number.POSITIVE_INFINITY;
+  const maxFileCount = options.maxFileCount ?? 500;
+  for (const [label, snapshot] of [
+    ["template", template],
+    ["answer", answer]
+  ]) {
+    if (snapshot.totalBytes > maxUploadBytes) {
+      push({
+        rule: "SNAP001",
+        severity: "error",
+        message: `${label} \u5FEB\u7167\u4F53\u79EF ${formatBytes(snapshot.totalBytes)} \u8D85\u8FC7\u4E0A\u9650 ${formatBytes(maxUploadBytes)}`,
+        hint: "\u786E\u8BA4\u6CA1\u6709\u628A dist/\u3001node_modules/ \u6216\u5927\u56FE\u6253\u8FDB\u9898\u76EE\u76EE\u5F55\uFF1B\u5FC5\u8981\u65F6\u8C03\u6574 QUANTA_MAX_UPLOAD_BYTES\u3002"
+      });
+    }
+    if (snapshot.fileCount > maxFileCount) {
+      push({
+        rule: "SNAP002",
+        severity: "error",
+        message: `${label} \u5FEB\u7167\u6587\u4EF6\u6570 ${snapshot.fileCount} \u8D85\u8FC7\u4E0A\u9650 ${maxFileCount}`
+      });
+    }
+  }
+  const errors = findings.filter((f) => f.severity === "error").length;
+  const warnings = findings.filter((f) => f.severity === "warn").length;
+  return {
+    findings,
+    errors,
+    warnings,
+    ok: errors === 0,
+    totalScore,
+    stats: {
+      checkpointCount: analysis.checkpoints.length,
+      judgeLines: analysis.lineCount,
+      template: toStats(template),
+      answer: toStats(answer)
+    },
+    analysis,
+    templateSnapshot: template.files,
+    answerSnapshot: answer.files
+  };
+};
+var toStats = (snapshot) => ({
+  fileCount: snapshot.fileCount,
+  totalBytes: snapshot.totalBytes,
+  ignored: snapshot.ignored
+});
+var duplicateNames = (names) => {
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    if (seen.has(name)) duplicates.add(name);
+    seen.add(name);
+  }
+  return [...duplicates];
+};
+
+// src/services/admin-api.ts
+var createAdminApi = (client) => ({
+  login: async (input) => client.call(
+    "auth.login.email",
+    {
+      input,
+      method: "POST"
+    }
+  ),
+  getCurrentUser: async () => {
+    const result = await client.call(
+      "auth.login.getUser",
+      {
+        method: "GET"
+      }
+    );
+    return result.user;
+  },
+  uploadProblem: (input) => client.call(
+    "admin.problem.upload",
+    {
+      input,
+      method: "POST"
+    }
+  ),
+  reuploadProblem: (input) => client.call(
+    "admin.problem.reupload",
+    {
+      input,
+      method: "POST"
+    }
+  ),
+  uploadImage: (input) => client.call("admin.image.upload", {
+    input,
+    method: "POST"
+  }),
+  getAuditDetail: (problemId) => client.call("admin.problem.getAuditDetail", {
+    input: { problemId },
+    method: "GET"
+  }),
+  setStatus: (problemId, publish) => client.call("admin.problem.setStatus", {
+    input: { problemId, publish },
+    method: "POST"
+  }),
+  listProblems: async (tagIds = []) => {
+    const result = await client.call("admin.problem.list", { input: { tids: tagIds }, method: "GET" });
+    if (Array.isArray(result)) return result;
+    return result.problems ?? [];
+  },
+  listTags: async () => {
+    const tags = await client.call("public.tag.list", {
+      method: "GET"
+    });
+    return tags.map((tag) => ({
+      tid: tag.tid,
+      name: tag.name,
+      color: tag.color ?? null,
+      description: tag.description ?? null
+    }));
+  }
+});
+var auditRecordOf = (detail) => detail.TemplateJudgeRecord?.[0]?.judgeRecord;
+var isAuditSettled = (detail) => {
+  if (detail.status !== "draft") return true;
+  const record = auditRecordOf(detail);
+  return record !== void 0 && record.result !== "pending";
+};
+var readAuditResults = (record) => {
+  if (!record) return { results: [] };
+  if (Array.isArray(record.info)) return { results: record.info };
+  const errorMessage = record.info.errorMessage;
+  return { results: [], errorMessage };
+};
+
+// src/ui/report.ts
+var SEVERITY_LABEL = {
+  error: "\u9519\u8BEF",
+  warn: "\u8B66\u544A",
+  info: "\u63D0\u793A"
+};
+var SEVERITY_ORDER = ["error", "warn", "info"];
+var renderFindings = (logger, findings, options = {}) => {
+  const { colors } = logger;
+  for (const severity of SEVERITY_ORDER) {
+    const group = findings.filter((finding) => finding.severity === severity);
+    if (group.length === 0) continue;
+    if (severity === "info" && !options.includeInfo) continue;
+    const color = severity === "error" ? colors.red : severity === "warn" ? colors.yellow : colors.dim;
+    logger.info(`${color(`${SEVERITY_LABEL[severity]} \xD7 ${group.length}`)}`);
+    for (const finding of group) {
+      const location = finding.file ? `${finding.file}${finding.line ? `:${finding.line}` : ""} ` : "";
+      logger.info(
+        `  ${colors.bold(finding.rule)} ${location}${finding.message}`
+      );
+      if (finding.hint) logger.detail(finding.hint);
+    }
+  }
+};
+var renderValidationSummary = (logger, report, options = {}) => {
+  const { colors } = logger;
+  logger.step(options.title ?? "\u9884\u68C0\u7ED3\u679C");
+  logger.table([
+    [
+      "\u68C0\u67E5\u70B9",
+      `${report.stats.checkpointCount} \u4E2A\uFF0C\u5408\u8BA1 ${report.totalScore} \u5206`
+    ],
+    [
+      "\u7B54\u6848\u6A21\u677F",
+      `${report.stats.template.fileCount} \u4E2A\u6587\u4EF6\uFF0C${formatBytes(report.stats.template.totalBytes)}`
+    ],
+    [
+      "\u53C2\u8003\u89E3",
+      `${report.stats.answer.fileCount} \u4E2A\u6587\u4EF6\uFF0C${formatBytes(report.stats.answer.totalBytes)}`
+    ],
+    ["\u5224\u9898\u811A\u672C", `${report.stats.judgeLines} \u884C`],
+    [
+      "\u7ED3\u8BBA",
+      report.ok ? colors.green(`\u901A\u8FC7\uFF08${report.warnings} \u6761\u8B66\u544A\uFF09`) : colors.red(`\u672A\u901A\u8FC7\uFF08${report.errors} \u4E2A\u9519\u8BEF\uFF09`)
+    ]
+  ]);
+};
+var renderAuditDetail = (logger, detail, options = {}) => {
+  const { colors } = logger;
+  const record = detail.TemplateJudgeRecord?.[0]?.judgeRecord;
+  const { results, errorMessage } = readAuditResults(record);
+  const score = record?.score ?? 0;
+  logger.step(`\u9898\u76EE #${detail.pid} ${detail.title}`);
+  logger.table([
+    ["\u72B6\u6001", detail.status],
+    ["\u96BE\u5EA6", detail.difficulty],
+    ["\u5BA1\u8BA1\u5F97\u5206", `${score} / ${detail.totalScore}`],
+    ["\u5BA1\u8BA1\u7ED3\u679C", record?.result ?? "unknown"]
+  ]);
+  for (const [index, item] of results.entries()) {
+    const mark = item.status === "pass" ? colors.green("\u2714") : colors.red("\u2716");
+    logger.info(
+      `  ${mark} [${index + 1}] ${item.score}/${item.totalScore}  ${item.details ?? ""}`
+    );
+  }
+  if (errorMessage) logger.error(`\u5BA1\u8BA1\u6267\u884C\u5931\u8D25\uFF1A${errorMessage}`);
+  if (options.verbose && detail.JudgeFile?.[0]?.judgeScript) {
+    logger.debug(`\u5224\u9898\u811A\u672C ${detail.JudgeFile[0].judgeScript.length} \u5B57\u7B26`);
+  }
+  return record?.result === "success" && detail.totalScore > 0 && score === detail.totalScore;
+};
+var validationToJson = (report) => ({
+  ok: report.ok,
+  totalScore: report.totalScore,
+  errors: report.errors,
+  warnings: report.warnings,
+  stats: report.stats,
+  checkpoints: report.analysis.checkpoints,
+  findings: report.findings
+});
+var auditToJson = (detail) => {
+  const record = detail.TemplateJudgeRecord?.[0]?.judgeRecord;
+  return {
+    problemId: detail.pid,
+    title: detail.title,
+    status: detail.status,
+    totalScore: detail.totalScore,
+    audit: record ? {
+      result: record.result,
+      score: record.score,
+      ...readAuditResults(record)
+    } : null
+  };
+};
+
+// src/commands/check.ts
+var registerCheckCommand = (registry) => {
+  const { program, context } = registry;
+  program.command("check").description("\u79BB\u7EBF\u9884\u68C0\u9898\u76EE\uFF08\u5224\u9898\u811A\u672C\u3001\u5FEB\u7167\u3001\u5206\u503C\u3001\u8FD0\u884C\u914D\u7F6E\uFF09").argument("[dir]", "\u9898\u76EE\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09", ".").option("--strict", "\u8B66\u544A\u4E5F\u89C6\u4E3A\u5931\u8D25").action(async (dir, options) => {
+    const ctx = await context();
+    await runCheck(ctx, { dir, ...options });
+  });
+};
+var runCheck = async (ctx, options) => {
+  const rootDir = resolve(ctx.cwd, options.dir);
+  ctx.logger.step(`\u8BFB\u53D6\u9898\u76EE\u914D\u7F6E \u2192 ${rootDir}`);
+  const config = await loadProblemConfig(rootDir);
+  ctx.logger.detail(`title: ${config.title}`);
+  const report = await validateProblem(config, {
+    maxUploadBytes: ctx.env.maxUploadBytes
+  });
+  renderFindings(ctx.logger, report.findings, {
+    includeInfo: ctx.logger.level === "debug"
+  });
+  renderValidationSummary(ctx.logger, report);
+  if (ctx.logger.json) {
+    ctx.logger.result(validationToJson(report));
+  }
+  if (!report.ok) {
+    throw new PrecheckError(
+      `\u9884\u68C0\u672A\u901A\u8FC7\uFF1A${report.errors} \u4E2A\u9519\u8BEF\u3001${report.warnings} \u6761\u8B66\u544A`,
+      {
+        hint: "\u6309\u4E0A\u9762\u7684\u89C4\u5219\u53F7\u9010\u6761\u4FEE\u590D\u540E\u91CD\u8DD1 `qpc check`\u3002"
+      }
+    );
+  }
+  if (options.strict && report.warnings > 0) {
+    throw new PrecheckError(`--strict\uFF1A\u5B58\u5728 ${report.warnings} \u6761\u8B66\u544A`, {
+      hint: "\u53BB\u6389 --strict \u53EF\u53EA\u62E6\u622A\u9519\u8BEF\uFF1B\u8B66\u544A\u4E0D\u5F71\u54CD\u7EBF\u4E0A\u5BA1\u8BA1\u3002"
+    });
+  }
+  ctx.logger.success("\u9884\u68C0\u901A\u8FC7");
+  return report;
+};
+
+// src/domain/config-writer.ts
+var applyCoverUpdate = (content, update, file) => {
+  if (file.endsWith(".json")) {
+    return applyToJson(content, update);
+  }
+  return applyToSource(content, update, file);
+};
+var applyToJson = (content, update) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (error) {
+    throw new ConfigError("\u9898\u76EE\u914D\u7F6E\u4E0D\u662F\u5408\u6CD5 JSON\uFF0C\u65E0\u6CD5\u5199\u56DE\u5C01\u9762", {
+      cause: error,
+      hint: "\u624B\u52A8\u628A imageId \u4E0E\u914D\u8272\u586B\u8FDB cover\u3002"
+    });
+  }
+  const root = parsed;
+  const cover = root.cover;
+  if (cover?.mode !== "custom") {
+    throw new ConfigError(
+      '\u914D\u7F6E\u91CC\u6CA1\u6709 cover: { mode: "custom" }\uFF0C\u65E0\u6CD5\u5199\u56DE\u5C01\u9762',
+      { hint: "\u5148\u6309\u6587\u6863\u628A\u5C01\u9762\u6539\u6210\u81EA\u5B9A\u4E49\u6A21\u5F0F\uFF0C\u518D\u91CD\u8DD1\u3002" }
+    );
+  }
+  cover.imageId = update.imageId;
+  if (update.colors) {
+    const previous = cover.generate && typeof cover.generate === "object" ? cover.generate : {};
+    const generate = { ...previous };
+    generate.bg = update.colors.bg;
+    generate.accent = update.colors.accent;
+    generate.text = update.colors.text;
+    if (update.colors.bgTo === void 0) {
+      delete generate.bgTo;
+    } else {
+      generate.bgTo = update.colors.bgTo;
+    }
+    cover.generate = generate;
+  }
+  return `${JSON.stringify(parsed, null, 3)}
+`;
+};
+var applyToSource = (content, update, file) => {
+  const coverMatch = /cover\s*:\s*\{/.exec(content);
+  if (!coverMatch) {
+    throw new ConfigError(
+      `\u5728 ${file} \u91CC\u627E\u4E0D\u5230 cover: { ... }\uFF0C\u65E0\u6CD5\u5199\u56DE\u5C01\u9762`,
+      { hint: "\u628A imageId \u4E0E\u914D\u8272\u624B\u52A8\u586B\u8FDB cover\u3002" }
+    );
+  }
+  const openBrace = content.indexOf("{", coverMatch.index);
+  const closeBrace = findObjectEnd(content, openBrace);
+  if (closeBrace < 0) {
+    throw new ConfigError(`\u5728 ${file} \u91CC\u65E0\u6CD5\u89E3\u6790 cover \u5BF9\u8C61\uFF08\u62EC\u53F7\u4E0D\u914D\u5BF9\uFF09`, {
+      hint: "\u628A imageId \u4E0E\u914D\u8272\u624B\u52A8\u586B\u8FDB cover\u3002"
+    });
+  }
+  const before = content.slice(0, openBrace);
+  const after = content.slice(closeBrace + 1);
+  const coverLineStart = content.lastIndexOf("\n", coverMatch.index) + 1;
+  const coverLinePrefix = content.slice(coverLineStart, coverMatch.index);
+  const indent = /^[ \t]*$/.test(coverLinePrefix) ? `${coverLinePrefix}   ` : `${/\n([ \t]+)\S/.exec(before)?.[1] ?? "   "}   `;
+  let body = content.slice(openBrace, closeBrace + 1);
+  if (update.colors) {
+    body = writeColors(body, update.colors, indent, file);
+  }
+  body = writeImageId(body, update.imageId, file, indent);
+  return `${before}${body}${after}`;
+};
+var applyProblemIdUpdate = (content, problemId, file) => {
+  if (file.endsWith(".json")) {
+    return applyProblemIdToJson(content, problemId, file);
+  }
+  return applyProblemIdToSource(content, problemId, file);
+};
+var applyProblemIdToJson = (content, problemId, file) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (error) {
+    throw new ConfigError("\u9898\u76EE\u914D\u7F6E\u4E0D\u662F\u5408\u6CD5 JSON\uFF0C\u65E0\u6CD5\u5199\u56DE problemId", {
+      cause: error,
+      hint: `\u624B\u52A8\u628A problemId: ${problemId} \u586B\u8FDB\u914D\u7F6E\u3002`
+    });
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new ConfigError(`${file} \u7684\u9876\u5C42\u4E0D\u662F\u4E00\u4E2A\u5BF9\u8C61\uFF0C\u65E0\u6CD5\u5199\u56DE problemId`, {
+      hint: `\u624B\u52A8\u628A problemId: ${problemId} \u586B\u8FDB\u914D\u7F6E\u3002`
+    });
+  }
+  parsed.problemId = problemId;
+  return `${JSON.stringify(parsed, null, 3)}
+`;
+};
+var applyProblemIdToSource = (content, problemId, file) => {
+  const existing = /\bproblemId\s*:\s*\d+/.exec(content);
+  if (existing) return content.replace(existing[0], `problemId: ${problemId}`);
+  const openBrace = findConfigObjectStart(content);
+  if (openBrace < 0) {
+    throw new ConfigError(
+      `\u5728 ${file} \u91CC\u627E\u4E0D\u5230\u9898\u76EE\u914D\u7F6E\u5BF9\u8C61\uFF0C\u65E0\u6CD5\u5199\u56DE problemId`,
+      { hint: `\u624B\u52A8\u628A problemId: ${problemId} \u586B\u8FDB\u914D\u7F6E\u3002` }
+    );
+  }
+  const after = content.slice(openBrace + 1);
+  const firstNewline = after.indexOf("\n");
+  const sameLine = after.slice(0, firstNewline < 0 ? void 0 : firstNewline);
+  const insertion = /^[ \t]*$/.test(sameLine) ? `
+${/\n([ \t]+)\S/.exec(after)?.[1] ?? "   "}problemId: ${problemId},` : ` problemId: ${problemId},`;
+  return `${content.slice(0, openBrace + 1)}${insertion}${after}`;
+};
+var applyTagIdsUpdate = (content, tagIds, file) => {
+  if (file.endsWith(".json")) {
+    return applyTagIdsToJson(content, tagIds, file);
+  }
+  return applyTagIdsToSource(content, tagIds, file);
+};
+var applyTagIdsToJson = (content, tagIds, file) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (error) {
+    throw new ConfigError("\u9898\u76EE\u914D\u7F6E\u4E0D\u662F\u5408\u6CD5 JSON\uFF0C\u65E0\u6CD5\u5199\u56DE tagIds", {
+      cause: error,
+      hint: `\u624B\u52A8\u628A tagIds: [${tagIds.join(", ")}] \u586B\u8FDB\u914D\u7F6E\u3002`
+    });
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new ConfigError(`${file} \u7684\u9876\u5C42\u4E0D\u662F\u4E00\u4E2A\u5BF9\u8C61\uFF0C\u65E0\u6CD5\u5199\u56DE tagIds`, {
+      hint: `\u624B\u52A8\u628A tagIds: [${tagIds.join(", ")}] \u586B\u8FDB\u914D\u7F6E\u3002`
+    });
+  }
+  parsed.tagIds = tagIds;
+  return `${JSON.stringify(parsed, null, 3)}
+`;
+};
+var applyTagIdsToSource = (content, tagIds, file) => {
+  const literal = `[${tagIds.join(", ")}]`;
+  const existing = /\btagIds\s*:\s*\[[^\]]*\]/.exec(content);
+  if (existing) return content.replace(existing[0], `tagIds: ${literal}`);
+  for (const anchor of ["difficulty", "title"]) {
+    const match = new RegExp(
+      `\\b${anchor}\\s*:\\s*(['"\`])[^'"\`]*\\1,?`
+    ).exec(content);
+    if (!match) continue;
+    const lineStart = content.lastIndexOf("\n", match.index) + 1;
+    const prefix = content.slice(lineStart, match.index);
+    const indent = /^([ \t]*)$/.exec(prefix)?.[1] ?? "   ";
+    const sep2 = /,\s*$/.test(match[0]) ? "" : ",";
+    const insertAt = match.index + match[0].length;
+    const next = /^[ \t]*$/.test(prefix) ? `${sep2}
+${indent}tagIds: ${literal},` : `${sep2} tagIds: ${literal},`;
+    return `${content.slice(0, insertAt)}${next}${content.slice(insertAt)}`;
+  }
+  const openBrace = findConfigObjectStart(content);
+  if (openBrace < 0) {
+    throw new ConfigError(
+      `\u5728 ${file} \u91CC\u627E\u4E0D\u5230\u9898\u76EE\u914D\u7F6E\u5BF9\u8C61\uFF0C\u65E0\u6CD5\u5199\u56DE tagIds`,
+      { hint: `\u624B\u52A8\u628A tagIds: ${literal} \u586B\u8FDB\u914D\u7F6E\u3002` }
+    );
+  }
+  const after = content.slice(openBrace + 1);
+  const firstNewline = after.indexOf("\n");
+  const sameLine = after.slice(0, firstNewline < 0 ? void 0 : firstNewline);
+  const insertion = /^[ \t]*$/.test(sameLine) ? `
+${/\n([ \t]+)\S/.exec(after)?.[1] ?? "   "}tagIds: ${literal},` : ` tagIds: ${literal},`;
+  return `${content.slice(0, openBrace + 1)}${insertion}${after}`;
+};
+var findConfigObjectStart = (content) => {
+  const wrapper = /defineProblemConfig\s*\(\s*\{/.exec(content);
+  if (wrapper) return wrapper.index + wrapper[0].lastIndexOf("{");
+  const fallback = /export\s+default\s*\{/.exec(content);
+  if (fallback) return fallback.index + fallback[0].lastIndexOf("{");
+  return content.indexOf("{");
+};
+var writeColors = (body, colors, coverIndent, file) => {
+  const generateMatch = /generate\s*:\s*\{/.exec(body);
+  if (!generateMatch) {
+    return insertGenerate(body, colors, coverIndent, file);
+  }
+  const openBrace = body.indexOf("{", generateMatch.index);
+  const closeBrace = findObjectEnd(body, openBrace);
+  if (closeBrace < 0) {
+    throw new ConfigError(
+      `\u5728 ${file} \u91CC\u65E0\u6CD5\u89E3\u6790 cover.generate\uFF08\u62EC\u53F7\u4E0D\u914D\u5BF9\uFF09`,
+      {
+        hint: "\u628A\u914D\u8272\u624B\u52A8\u586B\u8FDB cover.generate\u3002"
+      }
+    );
+  }
+  const generatePrefix = body.slice(openBrace, closeBrace + 1);
+  const generateIndent = detectIndent(generatePrefix) ?? `${coverIndent}   `;
+  let generateBody = generatePrefix;
+  generateBody = upsertColor(generateBody, "bg", colors.bg, generateIndent);
+  generateBody = upsertColor(
+    generateBody,
+    "bgTo",
+    colors.bgTo,
+    generateIndent
+  );
+  generateBody = upsertColor(
+    generateBody,
+    "accent",
+    colors.accent,
+    generateIndent
+  );
+  generateBody = upsertColor(
+    generateBody,
+    "text",
+    colors.text,
+    generateIndent
+  );
+  return body.slice(0, openBrace) + generateBody + body.slice(closeBrace + 1);
+};
+var insertGenerate = (body, colors, indent, file) => {
+  const modeMatch = /mode\s*:\s*(['"`])custom\1,?/.exec(body);
+  if (!modeMatch) {
+    throw new ConfigError(
+      `\u5728 ${file} \u7684 cover \u5BF9\u8C61\u91CC\u627E\u4E0D\u5230 mode: 'custom'\uFF0C\u65E0\u6CD5\u5199\u5165 generate`,
+      { hint: "\u628A\u914D\u8272\u624B\u52A8\u586B\u8FDB cover.generate\u3002" }
+    );
+  }
+  const literal = formatColors(colors);
+  const matched = modeMatch[0];
+  const hasComma = /,\s*$/.test(matched);
+  const linePrefix = body.slice(
+    body.lastIndexOf("\n", modeMatch.index) + 1,
+    modeMatch.index
+  );
+  const inline = !/^[ \t]*$/.test(linePrefix);
+  const separator = hasComma ? " " : ", ";
+  const replacement = inline ? `${matched}${separator}generate: { ${literal} },` : `${matched}${hasComma ? "" : ","}
+${indent}generate: { ${literal} },`;
+  return body.replace(matched, replacement);
+};
+var formatColors = (colors) => {
+  const parts = [
+    `bg: '${colors.bg}'`,
+    colors.bgTo === void 0 ? void 0 : `bgTo: '${colors.bgTo}'`,
+    `accent: '${colors.accent}'`,
+    `text: '${colors.text}'`
+  ].filter((part) => part !== void 0);
+  return parts.join(", ");
+};
+var writeImageId = (body, imageId, file, indent) => {
+  const existing = /imageId\s*:\s*(['"`])(?:[^'"`]*)\1/.exec(body);
+  return existing ? body.replace(existing[0], `imageId: '${imageId}'`) : insertImageId(body, imageId, file, indent);
+};
+var insertImageId = (body, imageId, file, indent) => {
+  const modeMatch = /mode\s*:\s*(['"`])custom\1,?/.exec(body);
+  if (!modeMatch) {
+    throw new ConfigError(
+      `\u5728 ${file} \u7684 cover \u5BF9\u8C61\u91CC\u627E\u4E0D\u5230 mode: 'custom'\uFF0C\u65E0\u6CD5\u5199\u56DE imageId`,
+      { hint: "\u628A imageId \u624B\u52A8\u586B\u8FDB cover.imageId\u3002" }
+    );
+  }
+  const matched = modeMatch[0];
+  const hasComma = /,\s*$/.test(matched);
+  const linePrefix = body.slice(
+    body.lastIndexOf("\n", modeMatch.index) + 1,
+    modeMatch.index
+  );
+  const inline = !/^[ \t]*$/.test(linePrefix);
+  const separator = hasComma ? " " : ", ";
+  const replacement = inline ? `${matched}${separator}imageId: '${imageId}',` : `${matched}${hasComma ? "" : ","}
+${indent}imageId: '${imageId}',`;
+  return body.replace(matched, replacement);
+};
+var keyPattern = (key) => `\\b${key}\\s*:\\s*(['"\`])(?:[^'"\`]*)\\1`;
+var detectIndent = (body) => /\n([ \t]+)\S/.exec(body)?.[1];
+var upsertColor = (body, key, value, indent) => {
+  const existing = new RegExp(keyPattern(key)).exec(body);
+  if (value === void 0) {
+    return existing ? removeKey(body, key) : body;
+  }
+  if (existing) {
+    return body.replace(existing[0], `${key}: '${value}'`);
+  }
+  return insertKey(body, key, value, indent);
+};
+var insertKey = (body, key, value, indent) => {
+  const inner = body.slice(1, -1);
+  if (inner.trim() === "") return `{ ${key}: '${value}' }`;
+  if (!inner.includes("\n")) return body.replace("{", `{ ${key}: '${value}',`);
+  const entryIndent = detectIndent(body) ?? indent;
+  return body.replace("{", `{
+${entryIndent}${key}: '${value}',`);
+};
+var removeKey = (body, key) => {
+  const pattern = keyPattern(key);
+  const trailing = new RegExp(`${pattern}\\s*,\\s*`);
+  if (trailing.test(body)) return body.replace(trailing, "");
+  const leading = new RegExp(`\\s*,\\s*${pattern}`);
+  if (leading.test(body)) return body.replace(leading, "");
+  return body.replace(new RegExp(pattern), "");
+};
+var findObjectEnd = (content, openBrace) => {
+  let depth = 0;
+  let quote = null;
+  for (let i = openBrace; i < content.length; i += 1) {
+    const char = content[i];
+    const previous = content[i - 1];
+    if (quote) {
+      if (char === quote && previous !== "\\") quote = null;
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "{") depth += 1;
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+};
+
+// src/domain/cover-palette.ts
+var TEXT_CONTRAST = 7;
+var ACCENT_CONTRAST = 4.5;
+var BG_ANCHORS = [
+  { name: "\u6DF1\u84DD", hue: 216 },
+  { name: "\u975B\u84DD", hue: 232 },
+  { name: "\u9752\u84DD", hue: 198 },
+  { name: "\u5E7D\u7EFF", hue: 168 },
+  { name: "\u677E\u7EFF", hue: 148 },
+  { name: "\u7D2B\u7F57\u5170", hue: 262 },
+  { name: "\u6697\u7D2B", hue: 280 },
+  { name: "\u9152\u7EA2", hue: 348 },
+  { name: "\u6697\u7EA2", hue: 10 },
+  { name: "\u6696\u68D5", hue: 26 }
+];
+var clamp01 = (value) => Math.min(1, Math.max(0, value));
+var createRandom = (seed) => {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let value = state;
+    value = Math.imul(value ^ value >>> 15, value | 1);
+    value ^= value + Math.imul(value ^ value >>> 7, value | 61);
+    return ((value ^ value >>> 14) >>> 0) / 4294967296;
+  };
+};
+var hueToRgb = (hue, chroma, second) => {
+  if (hue < 60) return [chroma, second, 0];
+  if (hue < 120) return [second, chroma, 0];
+  if (hue < 180) return [0, chroma, second];
+  if (hue < 240) return [0, second, chroma];
+  if (hue < 300) return [second, 0, chroma];
+  return [chroma, 0, second];
+};
+var toHexByte = (value) => Math.round(clamp01(value) * 255).toString(16).padStart(2, "0").toUpperCase();
+var hslToHex = (hue, sat, light) => {
+  const h = (hue % 360 + 360) % 360;
+  const s = clamp01(sat);
+  const l = clamp01(light);
+  const chroma = (1 - Math.abs(2 * l - 1)) * s;
+  const second = chroma * (1 - Math.abs(h / 60 % 2 - 1));
+  const offset = l - chroma / 2;
+  const [r, g, b] = hueToRgb(h, chroma, second);
+  return `#${toHexByte(r + offset)}${toHexByte(g + offset)}${toHexByte(b + offset)}`;
+};
+var parseHex = (hex) => {
+  const value = hex.slice(1);
+  const full = value.length === 3 ? [...value].map((char) => char + char).join("") : value.slice(0, 6);
+  return [
+    Number.parseInt(full.slice(0, 2), 16),
+    Number.parseInt(full.slice(2, 4), 16),
+    Number.parseInt(full.slice(4, 6), 16)
+  ];
+};
+var toLinear = (channel) => {
+  const value = channel / 255;
+  return value <= 0.03928 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+};
+var relativeLuminance = (hex) => {
+  const [r, g, b] = parseHex(hex);
+  return 0.2126 * toLinear(r) + 0.7152 * toLinear(g) + 0.0722 * toLinear(b);
+};
+var contrastRatio = (a, b) => {
+  const [high, low] = [relativeLuminance(a), relativeLuminance(b)].sort(
+    (x, y) => y - x
+  );
+  return (high + 0.05) / (low + 0.05);
+};
+var describePaletteProblem = (palette) => {
+  const backgrounds = palette.bgTo === void 0 ? [palette.bg] : [palette.bg, palette.bgTo];
+  const requirements = [
+    [palette.text, "\u4E3B\u6807\u9898\u8272", TEXT_CONTRAST],
+    [palette.accent, "\u5F3A\u8C03\u8272", ACCENT_CONTRAST]
+  ];
+  for (const [color, label, minimum] of requirements) {
+    for (const bg of backgrounds) {
+      const ratio = contrastRatio(color, bg);
+      if (ratio < minimum) {
+        return `${label} ${color} \u5BF9\u80CC\u666F ${bg} \u7684\u5BF9\u6BD4\u5EA6\u53EA\u6709 ${ratio.toFixed(2)}:1\uFF08\u8981\u6C42 \u2265 ${minimum}:1\uFF09`;
+      }
+    }
+  }
+  return void 0;
+};
+var pickRelation = (rand) => {
+  const sign = rand() < 0.5 ? -1 : 1;
+  const roll = rand();
+  if (roll < 0.22) return { name: "\u540C\u8272\u7CFB", offset: sign * (6 + rand() * 20) };
+  if (roll < 0.45)
+    return { name: "\u90BB\u8FD1\u8272", offset: sign * (30 + rand() * 25) };
+  if (roll < 0.7) {
+    return { name: "\u5206\u88C2\u4E92\u8865", offset: sign * (138 + rand() * 24) };
+  }
+  if (roll < 0.88) {
+    return { name: "\u4E92\u8865\u8272", offset: sign * (172 + rand() * 16) };
+  }
+  return { name: "\u4E09\u89D2\u8272", offset: sign * (108 + rand() * 24) };
+};
+var fitAccent = (hue, sat, backgrounds, rand) => {
+  const meetsContrast = (light) => {
+    const candidate = hslToHex(hue, sat, light);
+    return backgrounds.every(
+      (bg) => contrastRatio(candidate, bg) >= ACCENT_CONTRAST
+    );
+  };
+  let minimum;
+  for (let light = 0.94; light >= 0.5; light -= 5e-3) {
+    if (meetsContrast(light)) {
+      minimum = light;
+    } else if (minimum !== void 0) {
+      break;
+    }
+  }
+  if (minimum === void 0) return COVER_DEFAULTS.accent;
+  const preferred = minimum + 0.05 + rand() * 0.06;
+  return hslToHex(hue, sat, Math.max(minimum, Math.min(0.9, preferred)));
+};
+var randomCoverPalette = (seed) => {
+  const resolvedSeed = (seed ?? Math.floor(Math.random() * 4294967295)) >>> 0;
+  const rand = createRandom(resolvedSeed);
+  const anchor = BG_ANCHORS[Math.floor(rand() * BG_ANCHORS.length)];
+  const bgHue = anchor.hue + (rand() - 0.5) * 16;
+  const bgSat = 0.34 + rand() * 0.2;
+  const bgLight = 0.095 + rand() * 0.07;
+  const bg = hslToHex(bgHue, bgSat, bgLight);
+  const text = hslToHex(
+    bgHue + (rand() - 0.5) * 24,
+    0.06 + rand() * 0.1,
+    0.94 + rand() * 0.03
+  );
+  let bgTo;
+  if (rand() < 0.6) {
+    const toHue = bgHue + (rand() - 0.5) * 40;
+    const toSat = clamp01(bgSat + (rand() - 0.5) * 0.12);
+    let toLight = bgLight + 0.03 + rand() * 0.06;
+    while (toLight > bgLight && contrastRatio(text, hslToHex(toHue, toSat, toLight)) < TEXT_CONTRAST) {
+      toLight -= 0.01;
+    }
+    if (toLight > bgLight + 5e-3) {
+      bgTo = hslToHex(toHue, toSat, toLight);
+    }
+  }
+  const relation = pickRelation(rand);
+  const accentSat = relation.name === "\u540C\u8272\u7CFB" ? 0.6 + rand() * 0.3 : 0.72 + rand() * 0.28;
+  const accent = fitAccent(
+    bgHue + relation.offset,
+    accentSat,
+    bgTo === void 0 ? [bg] : [bg, bgTo],
+    rand
+  );
+  return {
+    palette: { bg, bgTo, accent, text },
+    seed: resolvedSeed,
+    scheme: `${anchor.name} \xB7 ${relation.name}`
+  };
+};
+var renderCoverPng = async (spec) => sharp(Buffer.from(buildCoverSvg(spec), "utf8")).png().toBuffer();
+var isInteractive = (stdin) => Boolean(stdin.isTTY) && typeof stdin.setRawMode === "function";
+var promptHidden = async (question, io) => {
+  const { stdin, stderr } = io;
+  if (!isInteractive(stdin)) {
+    const rl = createInterface({ input: stdin, terminal: false });
+    const answer = await new Promise((resolve8) => {
+      rl.question(question, resolve8);
+    });
+    rl.close();
+    return answer.trim();
+  }
+  stderr(question);
+  const wasRaw = Boolean(stdin.isRaw);
+  stdin.setRawMode?.(true);
+  stdin.resume();
+  return new Promise((resolve8, reject) => {
+    const chars = [];
+    const cleanup = () => {
+      stdin.setRawMode?.(wasRaw);
+      stdin.removeListener("data", onData);
+      stdin.pause();
+      stderr("\n");
+    };
+    const onData = (chunk) => {
+      for (const char of chunk.toString("utf8")) {
+        if (char === "\r" || char === "\n") {
+          cleanup();
+          resolve8(chars.join(""));
+          return;
+        }
+        if (char === "") {
+          cleanup();
+          reject(new CanceledError());
+          return;
+        }
+        if (char === "\x7F" || char === "\b") {
+          chars.pop();
+          continue;
+        }
+        chars.push(char);
+      }
+    };
+    stdin.on("data", onData);
+  });
+};
+var promptVisible = async (question, io) => {
+  const rl = createInterface({ input: io.stdin, terminal: false });
+  const answer = await new Promise((resolve8) => {
+    rl.question(question, resolve8);
+  });
+  rl.close();
+  return answer.trim();
+};
+var readAllStdin = async (stdin) => {
+  const chunks = [];
+  for await (const chunk of stdin) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8").trim();
+};
+var confirm = async (question, io, defaultValue = false) => {
+  if (!io.stdin.isTTY) {
+    throw new UsageError("\u5F53\u524D\u4E0D\u662F\u4EA4\u4E92\u5F0F\u7EC8\u7AEF\uFF0C\u65E0\u6CD5\u786E\u8BA4", {
+      hint: "\u8BF7\u5728\u547D\u4EE4\u4E2D\u663E\u5F0F\u52A0\u4E0A --yes \u8868\u793A\u786E\u8BA4\uFF0C\u6216\u4F7F\u7528 --dry-run \u9884\u89C8\u3002"
+    });
+  }
+  const rl = createInterface({ input: io.stdin, terminal: false });
+  const answer = await new Promise((resolve8) => {
+    rl.question(`${question} ${defaultValue ? "[Y/n]" : "[y/N]"} `, resolve8);
+  });
+  rl.close();
+  const normalized = answer.trim().toLowerCase();
+  if (normalized === "") return defaultValue;
+  return normalized === "y" || normalized === "yes";
+};
+var select = async (message, choices, io, options = {}) => {
+  if (!isInteractive(io.stdin)) {
+    throw new UsageError("\u5F53\u524D\u4E0D\u662F\u4EA4\u4E92\u5F0F\u7EC8\u7AEF\uFF0C\u65E0\u6CD5\u9009\u62E9", {
+      hint: "\u8BF7\u5728\u547D\u4EE4\u91CC\u663E\u5F0F\u6307\u5B9A\uFF0C\u4F8B\u5982 `qpc init --type backend_service`\u3002"
+    });
+  }
+  const answer = await select$1({
+    message,
+    options: choices.map(
+      (choice) => ({
+        value: choice.value,
+        label: choice.label,
+        ...choice.hint === void 0 ? {} : { hint: choice.hint }
+      })
+    ),
+    ...options.initialValue === void 0 ? {} : { initialValue: options.initialValue },
+    input: io.stdin,
+    output: io.stderrStream ?? process.stderr
+  });
+  if (isCancel(answer)) {
+    throw new CanceledError("\u5DF2\u53D6\u6D88\u9009\u62E9");
+  }
+  return answer;
+};
+var multiselect = async (message, choices, io, options = {}) => {
+  if (!isInteractive(io.stdin)) {
+    throw new UsageError("\u5F53\u524D\u4E0D\u662F\u4EA4\u4E92\u5F0F\u7EC8\u7AEF\uFF0C\u65E0\u6CD5\u591A\u9009", {
+      hint: "\u8BF7\u5728\u547D\u4EE4\u91CC\u663E\u5F0F\u6307\u5B9A\uFF0C\u4F8B\u5982 `qpc tag --set 1,2`\u3002"
+    });
+  }
+  const answer = await multiselect$1({
+    message,
+    options: choices.map(
+      (choice) => ({
+        value: choice.value,
+        label: choice.label,
+        ...choice.hint === void 0 ? {} : { hint: choice.hint }
+      })
+    ),
+    ...options.initialValues === void 0 ? {} : { initialValues: options.initialValues },
+    ...options.required === void 0 ? {} : { required: options.required },
+    input: io.stdin,
+    output: io.stderrStream ?? process.stderr
+  });
+  if (isCancel(answer)) {
+    throw new CanceledError("\u5DF2\u53D6\u6D88\u9009\u62E9");
+  }
+  return answer;
+};
+
+// src/commands/support.ts
+var requireSession = (ctx) => {
+  if (!ctx.client.hasSession) {
+    throw new AuthError("\u5C1A\u672A\u767B\u5F55", {
+      hint: `\u5148\u6267\u884C \`qpc login --api ${ctx.env.apiUrl}\`\uFF08\u6216\u8BBE\u7F6E QUANTA_TOKEN\uFF09\u3002`
+    });
+  }
+};
+var summarizeUser = (user) => [user.nickname, user.email, user.role].filter(Boolean).join(" \xB7 ") || "<unknown>";
+var confirmOrSkip = async (ctx, question) => {
+  if (ctx.assumeYes) return true;
+  if (!ctx.runtime.stdin.isTTY) {
+    ctx.logger.detail("\u975E\u4EA4\u4E92\u73AF\u5883\uFF0C\u5DF2\u8DF3\u8FC7\u786E\u8BA4\uFF08--yes \u53EF\u663E\u5F0F\u58F0\u660E\uFF09");
+    return true;
+  }
+  return confirm(question, {
+    stdin: ctx.runtime.stdin,
+    stderr: ctx.runtime.stderr
+  });
+};
+
+// src/commands/cover.ts
+var registerCoverCommand = (registry) => {
+  const { program, context } = registry;
+  program.command("cover").description("\u751F\u6210\u5C01\u9762\u56FE\uFF08\u53EF\u4E0A\u4F20\u3001\u5199\u56DE\u914D\u7F6E\uFF09").argument("[dir]", "\u9898\u76EE\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09", ".").option("--out <file>", "\u8F93\u51FA\u6587\u4EF6\uFF08\u9ED8\u8BA4\u53D6\u914D\u7F6E\u91CC\u7684 cover.generate.out\uFF09").option("--bg <color>", `\u80CC\u666F\u8272\uFF0C\u9ED8\u8BA4 ${COVER_DEFAULTS.bg}`).option(
+    "--bg-to <color>",
+    `\u6E10\u53D8\u7EC8\u6B62\u8272\uFF08\u7ED9\u4E86\u5C31\u753B\u6E10\u53D8\uFF09\uFF0C\u63A8\u8350 ${COVER_SUGGESTED_BG_TO}`
+  ).option("--accent <color>", `\u5F3A\u8C03\u8272\uFF0C\u9ED8\u8BA4 ${COVER_DEFAULTS.accent}`).option("--text <color>", `\u4E3B\u6807\u9898\u989C\u8272\uFF0C\u9ED8\u8BA4 ${COVER_DEFAULTS.text}`).option("--subtitle <text>", "\u526F\u6807\u9898\uFF08\u7559\u7A7A\u5219\u4E0D\u6E32\u67D3\uFF09").option("--footer <text>", `\u5DE6\u4E0B\u89D2\u9875\u811A\uFF0C\u9ED8\u8BA4 ${COVER_DEFAULTS.footer}`).option("--width <px>", `\u753B\u5E03\u5BBD\u5EA6\uFF0C\u9ED8\u8BA4 ${COVER_DEFAULTS.width}`).option("--height <px>", `\u753B\u5E03\u9AD8\u5EA6\uFF0C\u9ED8\u8BA4 ${COVER_DEFAULTS.height}`).option("--random", "\u968F\u673A\u751F\u6210\u4E00\u5957\u5408\u7406\u914D\u8272\uFF08\u53EF\u590D\u73B0\uFF09").option("--seed <n>", "\u914D\u5408 --random\uFF1A\u56FA\u5B9A\u79CD\u5B50").option("--upload", "\u4E0A\u4F20\u5C01\u9762\uFF0C\u8F93\u51FA imageId").option("--write", "\u628A imageId \u4E0E\u914D\u8272\u5199\u56DE\u914D\u7F6E\uFF08\u9690\u542B --upload\uFF09").action(async (dir, options) => {
+    const ctx = await context();
+    await runCover(ctx, { dir, ...options });
+  });
+};
+var runCover = async (ctx, options) => {
+  const rootDir = resolve(ctx.cwd, options.dir);
+  const config = await loadProblemConfig(rootDir);
+  if (config.cover.mode !== "custom") {
+    throw new ConfigError(
+      "\u5F53\u524D\u9898\u76EE\u7528\u7684\u662F\u300C\u9996\u5C4F\u622A\u56FE\u300D\u5C01\u9762\uFF0C\u4E0D\u9700\u8981\u4E5F\u4E0D\u5E94\u8BE5\u751F\u6210\u5C01\u9762\u56FE",
+      {
+        hint: "\u6539\u6210 cover: { mode: 'custom', generate: { ... } } \u518D\u8DD1 `qpc cover`\u3002"
+      }
+    );
+  }
+  const generate = config.cover.generate;
+  const outFile = resolve(
+    rootDir,
+    options.out ?? generate?.out ?? "cover.png"
+  );
+  const randomized = resolveRandom(options);
+  const spec = resolveSpec(
+    config.title,
+    generate,
+    options,
+    randomized?.palette
+  );
+  if (randomized) {
+    const problem = describePaletteProblem({
+      bg: spec.bg,
+      bgTo: spec.bgTo,
+      accent: spec.accent,
+      text: spec.text
+    });
+    if (problem) {
+      throw new UsageError(`\u968F\u673A\u914D\u8272\u4E0E\u663E\u5F0F\u989C\u8272\u53C2\u6570\u51B2\u7A81\uFF1A${problem}`, {
+        hint: "\u53BB\u6389\u989C\u8272\u53C2\u6570\u8BA9 --random \u6574\u7EC4\u751F\u6210\uFF0C\u6216\u6574\u7EC4\u624B\u52A8\u6307\u5B9A\u3002"
+      });
+    }
+  }
+  const colors = randomized ? {
+    bg: spec.bg,
+    bgTo: spec.bgTo,
+    accent: spec.accent,
+    text: spec.text
+  } : void 0;
+  ctx.logger.step(`\u6E32\u67D3\u5C01\u9762 \u2192 ${relative(ctx.cwd, outFile) || outFile}`);
+  const png = await renderCoverPng(spec);
+  try {
+    await writeBinary(outFile, png);
+  } catch (error) {
+    throw new ConfigError(`\u65E0\u6CD5\u5199\u5165\u5C01\u9762\u6587\u4EF6\uFF1A${outFile}`, { cause: error });
+  }
+  const rows = [
+    ["\u6807\u9898", spec.title],
+    ["\u526F\u6807\u9898", spec.subtitle || "<\u65E0>"],
+    ["\u5C3A\u5BF8", `${spec.width} \xD7 ${spec.height}`],
+    [
+      "\u914D\u8272",
+      `${spec.bg}${spec.bgTo ? ` \u2192 ${spec.bgTo}` : ""} / ${spec.accent}`
+    ]
+  ];
+  if (randomized) {
+    rows.push(["\u968F\u673A", `${randomized.scheme}\uFF08seed=${randomized.seed}\uFF09`]);
+  }
+  rows.push(["\u6587\u4EF6", `${outFile}\uFF08${formatBytes(png.byteLength)}\uFF09`]);
+  ctx.logger.table(rows);
+  ctx.logger.success("\u5C01\u9762\u5DF2\u751F\u6210");
+  const shouldUpload = options.upload === true || options.write === true;
+  if (!shouldUpload) {
+    if (ctx.logger.json) {
+      ctx.logger.result({
+        out: outFile,
+        bytes: png.byteLength,
+        spec,
+        random: randomized ? { seed: randomized.seed, scheme: randomized.scheme } : void 0
+      });
+    }
+    return;
+  }
+  requireSession(ctx);
+  const api = createAdminApi(ctx.client);
+  ctx.logger.step("\u4E0A\u4F20\u5C01\u9762\uFF08admin.image.upload\uFF09");
+  const image = await api.uploadImage({
+    fileBase64: png.toString("base64"),
+    fileName: basename(outFile)
+  });
+  ctx.logger.success(`\u5C01\u9762\u5DF2\u4E0A\u4F20\uFF1A${image.id}`);
+  if (options.write) {
+    const written = await writeBackCover(config.configFile, image.id, colors);
+    ctx.logger.success(
+      `${colors ? "imageId \u4E0E\u914D\u8272" : "imageId"} \u5DF2\u5199\u56DE ${relative(ctx.cwd, written) || written}`
+    );
+  } else {
+    ctx.logger.info("  \u52A0 --write \u53EF\u5199\u56DE\u914D\u7F6E");
+  }
+  if (ctx.logger.json) {
+    ctx.logger.result({
+      out: outFile,
+      bytes: png.byteLength,
+      imageId: image.id,
+      imageName: image.name,
+      spec,
+      random: randomized ? { seed: randomized.seed, scheme: randomized.scheme } : void 0,
+      wroteColors: options.write === true && colors !== void 0,
+      configFile: options.write ? config.configFile : void 0
+    });
+  }
+};
+var writeBackCover = async (configFile, imageId, colors) => {
+  const original = await readText(configFile);
+  const patched = applyCoverUpdate(original, { imageId, colors }, configFile);
+  await writeTextAtomic(configFile, patched);
+  try {
+    const reloaded = await loadProblemConfig(resolve(configFile, ".."));
+    if (reloaded.cover.mode !== "custom" || reloaded.cover.imageId !== imageId) {
+      throw new Error("\u5199\u56DE\u540E\u8BFB\u53D6\u5230\u7684 imageId \u4E0E\u9884\u671F\u4E0D\u4E00\u81F4");
+    }
+    if (colors) {
+      const generate = reloaded.cover.generate;
+      const matches = generate !== void 0 && generate.bg === colors.bg && generate.bgTo === colors.bgTo && generate.accent === colors.accent && generate.text === colors.text;
+      if (!matches) throw new Error("\u5199\u56DE\u540E\u8BFB\u53D6\u5230\u7684\u914D\u8272\u4E0E\u9884\u671F\u4E0D\u4E00\u81F4");
+    }
+  } catch (error) {
+    await writeTextAtomic(configFile, original);
+    throw new ConfigError("\u5199\u56DE\u5C01\u9762\u4FE1\u606F\u540E\u914D\u7F6E\u6821\u9A8C\u5931\u8D25\uFF0C\u5DF2\u56DE\u6EDA\u539F\u6587\u4EF6", {
+      cause: error,
+      hint: `\u624B\u52A8\u628A imageId \u586B\u6210 ${imageId}\uFF0C\u5E76\u6284\u56DE\u914D\u8272\u3002`
+    });
+  }
+  return configFile;
+};
+var resolveRandom = (options) => {
+  if (!options.random) {
+    if (options.seed !== void 0) {
+      throw new UsageError("--seed \u53EA\u6709\u5728 --random \u65F6\u624D\u6709\u610F\u4E49", {
+        hint: "\u4F8B\u5982 `qpc cover --random --seed 42`\u3002"
+      });
+    }
+    return void 0;
+  }
+  return randomCoverPalette(parseSeed(options.seed));
+};
+var parseSeed = (value) => {
+  if (value === void 0) return void 0;
+  if (!/^\d+$/.test(value)) {
+    throw new UsageError(`--seed \u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570\uFF1A${value}`, {
+      hint: "\u4F8B\u5982 `qpc cover --random --seed 42`\u3002"
+    });
+  }
+  const seed = Number.parseInt(value, 10);
+  if (!Number.isSafeInteger(seed) || seed > 4294967295) {
+    throw new UsageError(`--seed \u8D85\u51FA\u8303\u56F4\uFF080~4294967295\uFF09\uFF1A${value}`);
+  }
+  return seed;
+};
+var resolveSpec = (title, generate, options, palette) => {
+  const pick = (flag, fromConfig) => flag ?? fromConfig;
+  const color = (value, fallback, field) => assertHexColor(value ?? fallback, field);
+  const colorFrom = (flag, fromRandom, fromConfig) => flag ?? (palette === void 0 ? fromConfig : fromRandom);
+  const bgTo = colorFrom(options.bgTo, palette?.bgTo, generate?.bgTo);
+  return {
+    title,
+    subtitle: pick(options.subtitle, generate?.subtitle),
+    footer: pick(options.footer, generate?.footer),
+    bg: color(
+      colorFrom(options.bg, palette?.bg, generate?.bg),
+      COVER_DEFAULTS.bg,
+      "--bg"
+    ),
+    bgTo: bgTo === void 0 ? void 0 : color(bgTo, COVER_DEFAULTS.bg, "--bg-to"),
+    accent: color(
+      colorFrom(options.accent, palette?.accent, generate?.accent),
+      COVER_DEFAULTS.accent,
+      "--accent"
+    ),
+    text: color(
+      colorFrom(options.text, palette?.text, generate?.text),
+      COVER_DEFAULTS.text,
+      "--text"
+    ),
+    width: parseSize(
+      options.width,
+      generate?.width,
+      COVER_DEFAULTS.width,
+      "--width"
+    ),
+    height: parseSize(
+      options.height,
+      generate?.height,
+      COVER_DEFAULTS.height,
+      "--height"
+    )
+  };
+};
+var parseSize = (flag, fromConfig, fallback, field) => {
+  if (flag === void 0) return fromConfig ?? fallback;
+  const value = Number.parseInt(flag, 10);
+  if (!Number.isFinite(value) || value < 200 || value > 4096) {
+    throw new UsageError(`${field} \u5FC5\u987B\u662F 200~4096 \u4E4B\u95F4\u7684\u6574\u6570\uFF1A${flag}`);
+  }
+  return value;
+};
+
+// src/utils/jwt.ts
+var decodeJwt = (token) => {
+  const segments = token.split(".");
+  if (segments.length < 2 || !segments[1]) return void 0;
+  try {
+    const payload = Buffer.from(
+      segments[1].replace(/-/g, "+").replace(/_/g, "/"),
+      "base64"
+    ).toString("utf8");
+    const parsed = JSON.parse(payload);
+    return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var describeTokenExpiry = (token, now = Date.now()) => {
+  if (!token) return "\u65E0";
+  const claims = decodeJwt(token);
+  if (!claims?.exp) return "\u672A\u77E5\uFF08\u65E0\u6CD5\u89E3\u6790 exp\uFF09";
+  const expiresAt = claims.exp * 1e3;
+  const remainingMs = expiresAt - now;
+  const stamp = new Date(expiresAt).toISOString();
+  if (remainingMs <= 0) return `\u5DF2\u8FC7\u671F\uFF08${stamp}\uFF09`;
+  if (remainingMs < 6e4)
+    return `${Math.round(remainingMs / 1e3)} \u79D2\u540E\u8FC7\u671F\uFF08${stamp}\uFF09`;
+  return `${Math.round(remainingMs / 6e4)} \u5206\u949F\u540E\u8FC7\u671F\uFF08${stamp}\uFF09`;
+};
+
+// src/commands/doctor.ts
+var MIN_NODE_MAJOR = 20;
+var registerDoctorCommand = (registry) => {
+  const { program, context } = registry;
+  program.command("doctor").description("\u81EA\u68C0\uFF1A\u8FD0\u884C\u73AF\u5883\u3001API \u53EF\u8FBE\u6027\u3001\u767B\u5F55\u72B6\u6001").action(async () => {
+    const ctx = await context();
+    await runDoctor(ctx);
+  });
+};
+var runDoctor = async (ctx) => {
+  const results = [];
+  results.push(checkNodeVersion());
+  const credentials = await checkCredentialsFile(ctx);
+  results.push(credentials);
+  results.push(await checkApiReachable(ctx));
+  results.push(await checkSession(ctx));
+  const configFile = DEFAULT_CONFIG_FILES.map(
+    (name) => existsSync(join(ctx.cwd, name))
+  ).some(Boolean);
+  results.push({
+    name: "\u5F53\u524D\u76EE\u5F55\u7684\u9898\u76EE\u914D\u7F6E",
+    status: configFile ? "ok" : "skip",
+    detail: configFile ? "\u627E\u5230 problem.config.*" : `\u5728 ${ctx.cwd} \u672A\u627E\u5230\uFF08\u7528 --cwd \u6307\u5B9A\u9898\u76EE\u76EE\u5F55\uFF09`
+  });
+  ctx.logger.step("qpc doctor");
+  const symbols = {
+    ok: ctx.logger.colors.green("\u2714"),
+    warn: ctx.logger.colors.yellow("\u25B2"),
+    fail: ctx.logger.colors.red("\u2716"),
+    skip: ctx.logger.colors.dim("\u2013")
+  };
+  for (const result of results) {
+    ctx.logger.info(
+      `  ${symbols[result.status]} ${result.name}\uFF1A${result.detail}`
+    );
+    if (result.fix && result.status !== "ok")
+      ctx.logger.detail(`\u4FEE\u590D\uFF1A${result.fix}`);
+  }
+  const failures = results.filter((result) => result.status === "fail");
+  if (ctx.logger.json) {
+    ctx.logger.result({
+      ok: failures.length === 0,
+      checks: results,
+      apiUrl: ctx.env.apiUrl,
+      credentialsFile: ctx.credentialsFile
+    });
+  }
+  if (failures.length > 0) {
+    throw new CliError(`${failures.length} \u9879\u68C0\u67E5\u5931\u8D25`, {
+      hint: '\u6309\u4E0A\u9762\u7684"\u4FEE\u590D"\u9010\u9879\u5904\u7406\uFF1B\u53EA\u5173\u5FC3\u9898\u76EE\u672C\u8EAB\u65F6\u53EF\u4EE5\u5148\u8DD1 `qpc check`\u3002'
+    });
+  }
+  ctx.logger.success("\u5168\u90E8\u68C0\u67E5\u901A\u8FC7");
+};
+var checkNodeVersion = () => {
+  const major = Number.parseInt(
+    process.versions.node.split(".")[0] ?? "0",
+    10
+  );
+  return {
+    name: "Node \u7248\u672C",
+    status: major >= MIN_NODE_MAJOR ? "ok" : "fail",
+    detail: `v${process.versions.node}`,
+    fix: `\u5347\u7EA7\u5230 Node ${MIN_NODE_MAJOR} \u53CA\u4EE5\u4E0A`
+  };
+};
+var checkCredentialsFile = async (ctx) => {
+  if (!existsSync(ctx.credentialsFile)) {
+    return {
+      name: "\u51ED\u636E\u6587\u4EF6",
+      status: ctx.client.hasSession ? "ok" : "warn",
+      detail: ctx.client.hasSession ? "\u4E0D\u5B58\u5728\uFF0C\u4F46\u5DF2\u901A\u8FC7\u73AF\u5883\u53D8\u91CF\u63D0\u4F9B\u4EE4\u724C" : `\u4E0D\u5B58\u5728\uFF1A${ctx.credentialsFile}`,
+      fix: "qpc login"
+    };
+  }
+  const info = await stat(ctx.credentialsFile).catch(() => void 0);
+  if (!info) {
+    return {
+      name: "\u51ED\u636E\u6587\u4EF6",
+      status: "warn",
+      detail: `\u65E0\u6CD5\u8BFB\u53D6\uFF1A${ctx.credentialsFile}`,
+      fix: "qpc login"
+    };
+  }
+  const mode = (info.mode & 511).toString(8);
+  const tooOpen = (info.mode & 63) !== 0;
+  return {
+    name: "\u51ED\u636E\u6587\u4EF6",
+    status: tooOpen ? "warn" : "ok",
+    detail: `${ctx.credentialsFile}\uFF08\u6743\u9650 ${mode}\uFF09`,
+    fix: tooOpen ? `chmod 600 ${ctx.credentialsFile}` : void 0
+  };
+};
+var checkApiReachable = async (ctx) => {
+  try {
+    await ctx.client.call("auth.login.getUser", { method: "GET" });
+    return {
+      name: "API \u53EF\u8FBE",
+      status: "ok",
+      detail: `${ctx.env.apiUrl}\uFF08\u5DF2\u767B\u5F55\uFF09`
+    };
+  } catch (error) {
+    if (error instanceof ApiError && (error.status === 401 || error.status === 403)) {
+      return {
+        name: "API \u53EF\u8FBE",
+        status: "ok",
+        detail: `${ctx.env.apiUrl}\uFF08\u672A\u767B\u5F55/\u65E0\u6743\u9650\uFF0C\u4F46\u670D\u52A1\u6B63\u5E38\uFF09`
+      };
+    }
+    return {
+      name: "API \u53EF\u8FBE",
+      status: "fail",
+      detail: error instanceof Error ? error.message : String(error),
+      fix: "\u786E\u8BA4 Web \u5E94\u7528\u5DF2\u542F\u52A8\uFF08docker compose up -d\uFF09\uFF0C\u6216\u7528 --api \u6307\u5B9A\u5730\u5740"
+    };
+  }
+};
+var checkSession = async (ctx) => {
+  if (!ctx.client.hasSession) {
+    return {
+      name: "\u767B\u5F55\u72B6\u6001",
+      status: "warn",
+      detail: "\u672A\u767B\u5F55",
+      fix: `qpc login --api ${ctx.env.apiUrl}`
+    };
+  }
+  try {
+    const user = await ctx.client.call(
+      "auth.login.getUser",
+      { method: "GET" }
+    );
+    const role = user.user.role;
+    const admin = role === "ADMIN" || role === "SUPER_ADMIN";
+    return {
+      name: "\u767B\u5F55\u72B6\u6001",
+      status: admin ? "ok" : "warn",
+      detail: `${summarizeUser(user.user)}\uFF1Baccess token ${describeTokenExpiry(ctx.credentials.cookies.access)}`,
+      fix: admin ? void 0 : "\u51FA\u9898\u63A5\u53E3\u8981\u6C42 ADMIN \u89D2\u8272\uFF0C\u8BF7\u7528\u7BA1\u7406\u5458\u8D26\u53F7\u767B\u5F55"
+    };
+  } catch (error) {
+    return {
+      name: "\u767B\u5F55\u72B6\u6001",
+      status: "fail",
+      detail: error instanceof Error ? error.message : String(error),
+      fix: "qpc login\uFF08\u51ED\u636E\u53EF\u80FD\u5DF2\u8FC7\u671F\u6216\u88AB\u670D\u52A1\u7AEF\u5BC6\u94A5\u8F6E\u6362\u5931\u6548\uFF09"
+    };
+  }
+};
+var GITIGNORE_TEMPLATE = "gitignore";
+var PLACEHOLDER = /\{\{(\w+)\}\}/g;
+var TEMPLATE_DIR_CANDIDATES = ["../../templates", "../templates"];
+var resolveTemplateDir = (type) => {
+  for (const candidate of TEMPLATE_DIR_CANDIDATES) {
+    const dir = fileURLToPath(
+      new URL(`${candidate}/${type}`, import.meta.url)
+    );
+    if (existsSync(dir)) return dir;
+  }
+  throw new ConfigError("\u5185\u90E8\u9519\u8BEF\uFF1A\u627E\u4E0D\u5230\u811A\u624B\u67B6\u6A21\u677F\u76EE\u5F55", {
+    details: { from: import.meta.url, type }
+  });
+};
+var buildProblemScaffold = async (vars) => {
+  const templateDir = resolveTemplateDir(vars.type);
+  const context = buildContext(vars);
+  const relativePaths = await walkFiles(templateDir, {
+    ignore: (name) => name === ".DS_Store"
+  });
+  const files = await Promise.all(
+    relativePaths.map(async (relativePath) => {
+      const raw = await readText(join(templateDir, relativePath));
+      return {
+        path: relativePath === GITIGNORE_TEMPLATE ? ".gitignore" : relativePath,
+        content: renderTemplate(raw, context, relativePath)
+      };
+    })
+  );
+  return {
+    files,
+    cover: vars.type === "backend_service" ? { path: "cover.png", spec: buildBackendCoverSpec(vars.title) } : void 0
+  };
+};
+var renderTemplate = (content, context, file) => content.replace(PLACEHOLDER, (match, key) => {
+  const value = context[key];
+  if (value === void 0) {
+    throw new ConfigError(`\u6A21\u677F ${file} \u5F15\u7528\u4E86\u672A\u77E5\u5360\u4F4D\u7B26 ${match}`, {
+      details: {
+        file,
+        placeholder: key,
+        available: Object.keys(context).sort()
+      }
+    });
+  }
+  return value;
+});
+var buildContext = (vars) => {
+  const { title, type, difficulty, tagIds, mountPath } = vars;
+  const context = {
+    title,
+    difficulty,
+    tagIds: tagIds.join(", "),
+    mountPath,
+    initCommand: type === "backend_service" ? buildBackendInitCommand(
+      DEFAULT_BACKEND_SERVICE_IMAGE_ID,
+      mountPath
+    ) : DEFAULT_INIT_COMMAND.replace(/\sproject$/, ` ${mountPath}`)
+  };
+  if (type === "backend_service") {
+    context.serviceImage = DEFAULT_BACKEND_SERVICE_IMAGE_ID;
+    context.servicePort = String(
+      getBackendServiceDefaultPort(DEFAULT_BACKEND_SERVICE_IMAGE_ID)
+    );
+    context.coverBg = BACKEND_COVER.bg;
+    context.coverBgTo = BACKEND_COVER.bgTo;
+    context.coverAccent = BACKEND_COVER.accent;
+    context.coverSubtitle = BACKEND_COVER.subtitle;
+  }
+  return context;
+};
+var BACKEND_COVER = {
+  bg: COVER_DEFAULTS.bg,
+  bgTo: COVER_SUGGESTED_BG_TO,
+  accent: COVER_DEFAULTS.accent,
+  subtitle: "GET /health"
+};
+var buildBackendCoverSpec = (title) => ({
+  title,
+  subtitle: BACKEND_COVER.subtitle,
+  bg: BACKEND_COVER.bg,
+  bgTo: BACKEND_COVER.bgTo,
+  accent: BACKEND_COVER.accent,
+  text: COVER_DEFAULTS.text,
+  width: COVER_DEFAULTS.width,
+  height: COVER_DEFAULTS.height
+});
+
+// src/commands/init.ts
+var registerInitCommand = (registry) => {
+  const { program, context } = registry;
+  program.command("init").description(
+    "\u751F\u6210\u9898\u76EE\u9AA8\u67B6\uFF1Aproblem.config.ts / judge.js / template / answer"
+  ).argument("[dir]", "\u76EE\u6807\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09", ".").option("--name <title>", "\u9898\u76EE\u6807\u9898\uFF08\u9ED8\u8BA4\u53D6\u76EE\u5F55\u540D\uFF09").option(
+    "--type <type>",
+    `\u9898\u578B\uFF1A${PROBLEM_TYPES.join(" | ")}\uFF08\u4E0D\u4F20\u5219\u65B9\u5411\u952E\u9009\u62E9\uFF1B\u975E\u4EA4\u4E92\u73AF\u5883\u9ED8\u8BA4 frontend\uFF09`
+  ).option(
+    "--difficulty <level>",
+    `\u96BE\u5EA6\uFF1A${DIFFICULTIES.join(" | ")}`,
+    "easy"
+  ).option("--tag <id...>", "\u6807\u7B7E id\uFF0C\u53EF\u7ED9\u591A\u4E2A\uFF08\u7528 `qpc tag` \u67E5\u770B\uFF09", ["1"]).option(
+    "--mount <path>",
+    "\u5224\u9898\u6253\u5305\u76EE\u5F55 / \u5FEB\u7167\u6302\u8F7D\u8DEF\u5F84",
+    DEFAULT_JUDGE_UPLOAD_PATH
+  ).option("--force", "\u76EE\u5F55\u975E\u7A7A\u65F6\u4ECD\u7136\u5199\u5165\uFF08\u53EA\u8986\u76D6\u540C\u540D\u6587\u4EF6\uFF0C\u4E0D\u5220\u9664\u5176\u5B83\u6587\u4EF6\uFF09").action(async (dir, options) => {
+    const ctx = await context();
+    await runInit(ctx, dir, options);
+  });
+};
+var runInit = async (ctx, dir, options) => {
+  const target = resolve(ctx.cwd, dir);
+  const difficulty = assertDifficulty(options.difficulty);
+  const tagIds = assertTagIds(options.tag);
+  const mountPath = options.mount ?? DEFAULT_JUDGE_UPLOAD_PATH;
+  const title = options.name?.trim() || defaultTitle(target);
+  if (!options.force) {
+    const existing = (await listDir(target)).filter(
+      (name) => name !== ".git"
+    );
+    if (existing.length > 0) {
+      throw new UsageError(`\u76EE\u5F55\u975E\u7A7A\uFF1A${displayPath(ctx.cwd, target)}`, {
+        hint: "\u6362\u4E00\u4E2A\u7A7A\u76EE\u5F55\uFF0C\u6216\u52A0 --force \u8986\u76D6\u540C\u540D\u6587\u4EF6\uFF08\u5DF2\u6709\u6587\u4EF6\u4E0D\u4F1A\u88AB\u5220\u9664\uFF09\u3002"
+      });
+    }
+  }
+  const type = await resolveProblemType(ctx, options.type);
+  const scaffold = await buildProblemScaffold({
+    title,
+    type,
+    difficulty,
+    tagIds,
+    mountPath
+  });
+  ctx.logger.step(
+    `\u751F\u6210${type === "backend_service" ? "\u540E\u7AEF\u670D\u52A1\u9898" : "\u524D\u7AEF\u9898"}\u9AA8\u67B6 \u2192 ${displayPath(ctx.cwd, target)}`
+  );
+  for (const file of scaffold.files) {
+    await writeTextWithMode(resolve(target, file.path), file.content);
+    ctx.logger.success(
+      `${file.path}  ${ctx.logger.colors.dim(`${file.content.length} \u5B57\u7B26`)}`
+    );
+  }
+  if (scaffold.cover) {
+    const outFile = resolve(target, scaffold.cover.path);
+    try {
+      const png = await renderCoverPng(scaffold.cover.spec);
+      await writeBinary(outFile, png);
+      ctx.logger.success(
+        `${scaffold.cover.path}  ${ctx.logger.colors.dim(formatBytes(png.byteLength))}`
+      );
+    } catch (error) {
+      ctx.logger.warn(
+        `\u5C01\u9762\u6E32\u67D3\u5931\u8D25\uFF08${error instanceof Error ? error.message : String(error)}\uFF09\uFF1A\u914D\u7F6E\u91CC\u5DF2\u6709 cover.generate\uFF0C\u8DD1 \`qpc cover\` \u53EF\u91CD\u8BD5`
+      );
+    }
+  }
+  const cd = dir === "." ? "qpc" : `cd ${displayPath(ctx.cwd, target)} && qpc`;
+  ctx.logger.blank();
+  ctx.logger.step("\u4E0B\u4E00\u6B65");
+  if (type === "backend_service") {
+    ctx.logger.info(
+      `  ${cd} cover --upload --write   # \u540E\u7AEF\u9898\u5FC5\u987B\u81EA\u5B9A\u4E49\u5C01\u9762\uFF1A\u751F\u6210 \u2192 \u4E0A\u4F20 \u2192 \u5199\u56DE imageId`
+    );
+  }
+  ctx.logger.info(`  ${cd} check          # \u6BEB\u79D2\u7EA7\u9759\u6001\u9884\u68C0`);
+  ctx.logger.info(`  ${cd} upload --wait  # \u4E0A\u4F20\u5E76\u7B49\u5F85\u5BA1\u8BA1\uFF08\u7EA6 20 \u79D2\uFF09`);
+  if (ctx.logger.json) {
+    ctx.logger.result({
+      dir: target,
+      type,
+      files: scaffold.files.map((file) => file.path),
+      cover: scaffold.cover?.path,
+      difficulty,
+      tagIds
+    });
+  }
+};
+var defaultTitle = (target) => target.split(/[\\/]/).filter(Boolean).pop() ?? "\u672A\u547D\u540D\u9898\u76EE";
+var assertProblemType = (value) => {
+  const candidate = value ?? "frontend";
+  if (!PROBLEM_TYPES.includes(candidate)) {
+    throw new UsageError(`\u9898\u578B\u4E0D\u5408\u6CD5\uFF1A${value}`, {
+      hint: `\u53EF\u9009\u503C\uFF1A${PROBLEM_TYPES.join(" | ")}`
+    });
+  }
+  return candidate;
+};
+var resolveProblemType = async (ctx, value) => {
+  if (value !== void 0) return assertProblemType(value);
+  if (ctx.assumeYes || ctx.logger.json || !ctx.runtime.stdin.isTTY) {
+    return "frontend";
+  }
+  return select(
+    "\u8BF7\u9009\u62E9\u9898\u578B",
+    [
+      {
+        value: "frontend",
+        label: "\u524D\u7AEF\u9898\uFF08frontend\uFF09",
+        hint: "\u9759\u6001\u7AD9\u70B9\uFF0C\u7528 Playwright \u5224\u9898"
+      },
+      {
+        value: "backend_service",
+        label: "\u540E\u7AEF\u670D\u52A1\u9898\uFF08backend_service\uFF09",
+        hint: "\u5E38\u9A7B\u8FDB\u7A0B\uFF0C\u7528 HTTP \u5224\u9898\uFF0C\u6A21\u677F\u542B\u5C01\u9762\u56FE"
+      }
+    ],
+    {
+      stdin: ctx.runtime.stdin,
+      stderr: ctx.runtime.stderr,
+      stderrStream: ctx.runtime.stderrStream
+    },
+    { initialValue: "frontend" }
+  );
+};
+var assertDifficulty = (value) => {
+  const candidate = value ?? "easy";
+  if (!DIFFICULTIES.includes(candidate)) {
+    throw new UsageError(`\u96BE\u5EA6\u4E0D\u5408\u6CD5\uFF1A${value}`, {
+      hint: `\u53EF\u9009\u503C\uFF1A${DIFFICULTIES.join(" | ")}`
+    });
+  }
+  return candidate;
+};
+var assertTagIds = (values) => {
+  const list = values && values.length > 0 ? values : ["1"];
+  const parts = list.flatMap(
+    (value) => value.split(",").map((part) => part.trim()).filter(Boolean)
+  );
+  const parsed = parts.map((part) => Number.parseInt(part, 10));
+  if (parsed.some((id) => !Number.isInteger(id) || id <= 0)) {
+    throw new UsageError(`\u6807\u7B7E id \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF1A${parts.join(", ")}`, {
+      hint: "\u8FD0\u884C `qpc tag` \u67E5\u770B\u53EF\u7528\u6807\u7B7E id\uFF0C\u6216\u7528 `qpc tag --write` \u4EA4\u4E92\u9009\u62E9\u3002"
+    });
+  }
+  return parsed;
+};
+var credentialsSchema = z.object({
+  version: z.literal(1),
+  apiUrl: z.string().optional(),
+  cookies: z.object({
+    access: z.string().optional(),
+    refresh: z.string().optional(),
+    csrf: z.string().optional()
+  }),
+  user: z.object({
+    id: z.string(),
+    nickname: z.string().optional(),
+    email: z.string().optional(),
+    role: z.string().optional()
+  }).optional(),
+  updatedAt: z.string().optional()
+});
+var emptyCredentials = () => ({
+  version: 1,
+  cookies: {}
+});
+var resolveConfigDir = (env = process.env) => {
+  const explicit = env.QUANTA_CONFIG_DIR;
+  if (explicit) return explicit;
+  const xdg = env.XDG_CONFIG_HOME;
+  if (xdg) return xdg;
+  return join(homedir(), ".config");
+};
+var credentialsPath = (configDir) => join(configDir, "quanta", "credentials.json");
+var readCredentials = async (file) => {
+  if (!await pathExists(file)) return emptyCredentials();
+  const raw = await readText(file);
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new ConfigError(`\u51ED\u636E\u6587\u4EF6\u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${file}`, {
+      cause: error,
+      hint: "\u6267\u884C `qpc logout` \u540E\u91CD\u65B0 `qpc login`\u3002"
+    });
+  }
+  const result = credentialsSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new ConfigError(`\u51ED\u636E\u6587\u4EF6\u7ED3\u6784\u65E0\u6CD5\u8BC6\u522B\uFF1A${file}`, {
+      details: { issues: result.error.issues.map((i) => i.message) },
+      hint: "\u6267\u884C `qpc logout` \u540E\u91CD\u65B0 `qpc login`\u3002"
+    });
+  }
+  return result.data;
+};
+var writeCredentials = async (file, credentials) => {
+  await writeTextWithMode(
+    file,
+    `${JSON.stringify({ ...credentials, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 3)}
+`,
+    384
+  );
+};
+var removeCredentials = async (file) => {
+  const { rm: rm2 } = await import('fs/promises');
+  if (!await pathExists(file)) return false;
+  await rm2(file, { force: true });
+  return true;
+};
+
+// ../shared/service/oauth/device-flow.ts
+var DEVICE_CODE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
+var DEVICE_CODE_SLOW_DOWN_SECONDS = 5;
+var DEVICE_FLOW_CLIENT_ID = "quanta-problem-creator-cli";
+var DEVICE_FLOW_SCOPE = "problem:write";
+var DEVICE_FLOW_ERRORS = {
+  /** 用户还没批准，继续按 interval 轮询 */
+  authorizationPending: "authorization_pending",
+  /** 轮询太快：interval 必须 +5s */
+  slowDown: "slow_down",
+  /** 用户明确拒绝：立即停止轮询 */
+  accessDenied: "access_denied",
+  /** device_code 过期，会话结束 */
+  expiredToken: "expired_token"
+};
+var DEVICE_FLOW_PATHS = {
+  deviceAuthorization: "/api/oauth/device/authorize",
+  deviceToken: "/api/oauth/device/token",
+  /** 用户在浏览器里确认授权的人机页面 */
+  verification: "/auth/device"
+};
+
+// src/utils/async.ts
+var sleep = (ms, signal) => new Promise((resolve8, reject) => {
+  if (signal?.aborted) {
+    reject(
+      signal.reason instanceof Error ? signal.reason : new Error("aborted")
+    );
+    return;
+  }
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve8();
+  }, ms);
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(
+      signal?.reason instanceof Error ? signal.reason : new Error("aborted")
+    );
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+var poll = async (options) => {
+  const intervalMs = options.intervalMs ?? 2e3;
+  const timeoutMs = options.timeoutMs ?? 12e4;
+  const startedAt = Date.now();
+  let attempt = 0;
+  for (; ; ) {
+    attempt += 1;
+    const value = await options.probe(attempt);
+    if (value !== void 0) return value;
+    const elapsed = Date.now() - startedAt;
+    if (elapsed + intervalMs > timeoutMs) return void 0;
+    options.onTick?.(elapsed, attempt);
+    await sleep(intervalMs, options.signal);
+  }
+};
+var CLI_NAME = "qpc";
+var CLI_DESCRIPTION = "Quanta \u51FA\u9898\u5DE5\u5177\uFF1A\u811A\u624B\u67B6\u3001\u79BB\u7EBF\u9884\u68C0\u3001\u4E0A\u4F20\u4E0E\u53D1\u5E03";
+var readVersion = () => {
+  try {
+    const raw = readFileSync(
+      new URL("../package.json", import.meta.url),
+      "utf8"
+    );
+    const parsed = JSON.parse(raw);
+    return parsed.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+};
+var CLI_VERSION = readVersion();
+
+// src/services/device-flow.ts
+var postForm = async (options, path, body) => {
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  const signal = options.signal ? AbortSignal.any([options.signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs);
+  let response;
+  try {
+    response = await options.fetch(`${options.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        // RFC 8628 §3.1 要求 x-www-form-urlencoded；服务端为兼容也收 JSON，
+        // 但这里按规范发送，避免依赖服务端的宽松解析。
+        "content-type": "application/x-www-form-urlencoded",
+        accept: "application/json",
+        "user-agent": `qpc/${CLI_VERSION} (quanta-problem-creator)`
+      },
+      body: new URLSearchParams(body).toString(),
+      signal
+    });
+  } catch (error) {
+    throw new CliError(`\u65E0\u6CD5\u8FDE\u63A5 ${options.baseUrl}${path}`, {
+      cause: error,
+      hint: "\u786E\u8BA4 API \u5730\u5740\u6B63\u786E\u4E14\u670D\u52A1\u5DF2\u542F\u52A8\uFF1Aqpc doctor"
+    });
+  }
+  const text = await response.text();
+  let json;
+  try {
+    json = text ? JSON.parse(text) : void 0;
+  } catch {
+    json = void 0;
+  }
+  return { status: response.status, json };
+};
+var createDeviceFlow = (options) => {
+  const requestCodes = async () => {
+    const { status, json } = await postForm(
+      options,
+      DEVICE_FLOW_PATHS.deviceAuthorization,
+      { client_id: DEVICE_FLOW_CLIENT_ID, scope: DEVICE_FLOW_SCOPE }
+    );
+    const body = json;
+    if (status !== 200 || !body?.device_code || !body.user_code) {
+      throw new CliError(`\u670D\u52A1\u7AEF\u62D2\u7EDD\u4E86\u8BBE\u5907\u6388\u6743\u8BF7\u6C42\uFF08HTTP ${status}\uFF09`, {
+        details: { body: body ?? null },
+        hint: body?.error === "invalid_client" ? "\u670D\u52A1\u7AEF\u4E0D\u8BA4\u8BC6\u672C\u5BA2\u6237\u7AEF\u7684 client_id\uFF0C\u786E\u8BA4 CLI \u4E0E\u670D\u52A1\u7AEF\u7248\u672C\u4E00\u81F4\u3002" : "\u68C0\u67E5 API \u5730\u5740\u662F\u5426\u6307\u5411 quanta-challenge \u5E94\u7528\uFF08\u800C\u975E\u5176\u5B83\u670D\u52A1\uFF09\u3002"
+      });
+    }
+    return {
+      device_code: body.device_code,
+      user_code: body.user_code,
+      verification_uri: body.verification_uri ?? "",
+      verification_uri_complete: body.verification_uri_complete ?? "",
+      // RFC §3.2：interval 缺省时客户端必须按 5 秒处理
+      interval: body.interval ?? 5,
+      expires_in: body.expires_in ?? 600
+    };
+  };
+  const pollForToken = async (auth, onPending) => {
+    let intervalMs = (options.overrideIntervalSeconds ?? auth.interval) * 1e3;
+    const deadline = Date.now() + auth.expires_in * 1e3;
+    const startedAt = Date.now();
+    let consecutiveNetworkErrors = 0;
+    for (; ; ) {
+      if (Date.now() >= deadline) {
+        throw new CliError("\u8BBE\u5907\u6388\u6743\u7801\u5DF2\u8FC7\u671F", {
+          hint: "\u91CD\u65B0\u6267\u884C `qpc login` \u4F1A\u751F\u6210\u65B0\u7684\u9A8C\u8BC1\u7801\u3002"
+        });
+      }
+      let status;
+      let body;
+      try {
+        const result = await postForm(
+          options,
+          DEVICE_FLOW_PATHS.deviceToken,
+          {
+            grant_type: DEVICE_CODE_GRANT_TYPE,
+            device_code: auth.device_code,
+            client_id: DEVICE_FLOW_CLIENT_ID
+          }
+        );
+        status = result.status;
+        body = result.json;
+        consecutiveNetworkErrors = 0;
+      } catch (error2) {
+        consecutiveNetworkErrors += 1;
+        intervalMs *= 2;
+        options.logger.warn(
+          `\u8F6E\u8BE2\u5931\u8D25\uFF08\u7B2C ${consecutiveNetworkErrors} \u6B21\uFF09\uFF0C\u95F4\u9694\u8C03\u6574\u4E3A ${Math.round(intervalMs / 1e3)} \u79D2`
+        );
+        if (consecutiveNetworkErrors >= 5) throw error2;
+        await sleep(intervalMs, options.signal);
+        continue;
+      }
+      if (status === 200 && body?.access_token && body.refresh_token) {
+        return {
+          access_token: body.access_token,
+          refresh_token: body.refresh_token,
+          token_type: "Bearer",
+          expires_in: body.expires_in ?? 900,
+          scope: body.scope ?? DEVICE_FLOW_SCOPE
+        };
+      }
+      const error = body?.error;
+      if (error === DEVICE_FLOW_ERRORS.authorizationPending) {
+        onPending?.(Date.now() - startedAt);
+      } else if (error === DEVICE_FLOW_ERRORS.slowDown) {
+        intervalMs += DEVICE_CODE_SLOW_DOWN_SECONDS * 1e3;
+        options.logger.detail(
+          `\u670D\u52A1\u7AEF\u8981\u6C42\u964D\u4F4E\u8F6E\u8BE2\u9891\u7387\uFF0C\u95F4\u9694\u8C03\u6574\u4E3A ${Math.round(intervalMs / 1e3)} \u79D2`
+        );
+      } else if (error === DEVICE_FLOW_ERRORS.accessDenied) {
+        throw new PrecheckError("\u6388\u6743\u88AB\u62D2\u7EDD", {
+          hint: "\u4F60\u5728\u786E\u8BA4\u9875\u70B9\u51FB\u4E86\u62D2\u7EDD\uFF1B\u91CD\u65B0\u6267\u884C `qpc login` \u53EF\u518D\u8BD5\u4E00\u6B21\u3002"
+        });
+      } else if (error === DEVICE_FLOW_ERRORS.expiredToken) {
+        throw new CliError("\u8BBE\u5907\u6388\u6743\u7801\u5DF2\u5931\u6548\uFF08\u53EF\u80FD\u5DF2\u88AB\u4F7F\u7528\uFF09", {
+          hint: "\u91CD\u65B0\u6267\u884C `qpc login`\u3002"
+        });
+      } else {
+        throw new CliError(
+          `\u6362\u4EE4\u724C\u5931\u8D25${error ? `\uFF1A${error}` : `\uFF08HTTP ${status}\uFF09`}`,
+          {
+            details: {
+              status,
+              error: body?.error,
+              description: body?.error_description
+            }
+          }
+        );
+      }
+      await sleep(intervalMs, options.signal);
+    }
+  };
+  return { requestCodes, pollForToken };
+};
+var openBrowser = async (url) => {
+  const platform = process.platform;
+  const command = platform === "darwin" ? { file: "open", args: [url] } : platform === "win32" ? (
+    // cmd 的 start 是内置命令；第一个空参数是为了让 start 把带引号的 URL
+    // 当作标题之外的参数（Windows 上 start 会把第一个引号参数当窗口标题）。
+    { file: "cmd", args: ["/c", "start", "", url] }
+  ) : { file: "xdg-open", args: [url] };
+  return new Promise((resolve8) => {
+    try {
+      const child = spawn(command.file, command.args, {
+        stdio: "ignore",
+        detached: true
+      });
+      child.on("error", () => resolve8(false));
+      child.on("spawn", () => {
+        child.unref();
+        resolve8(true);
+      });
+    } catch {
+      resolve8(false);
+    }
+  });
+};
+
+// src/commands/login.ts
+var registerLoginCommand = (registry) => {
+  const { program, context } = registry;
+  program.command("login").description(
+    "\u767B\u5F55\u5E76\u4FDD\u5B58\u4F1A\u8BDD\u51ED\u636E\uFF08\u9ED8\u8BA4 ~/.config/quanta/credentials.json\uFF09"
+  ).option(
+    "--email <email>",
+    "\u8D26\u53F7\u90AE\u7BB1\uFF08\u663E\u5F0F\u8D70\u5BC6\u7801\u767B\u5F55\uFF1B\u4E5F\u53EF\u7528 QUANTA_EMAIL\uFF09"
+  ).option(
+    "--password-stdin",
+    "\u4ECE\u6807\u51C6\u8F93\u5165\u8BFB\u53D6\u5BC6\u7801\uFF08\u663E\u5F0F\u8D70\u5BC6\u7801\u767B\u5F55\uFF0C\u63A8\u8350\u7528\u4E8E CI\uFF09"
+  ).option("--show", "\u53EA\u663E\u793A\u5F53\u524D\u767B\u5F55\u72B6\u6001\uFF0C\u4E0D\u505A\u767B\u5F55").option("--logout", "\u5220\u9664\u672C\u5730\u51ED\u636E").option("--device", "\u7528\u8BBE\u5907\u7801\u5728\u6D4F\u89C8\u5668\u91CC\u6388\u6743\u767B\u5F55\uFF08\u9ED8\u8BA4\u884C\u4E3A\uFF09").option(
+    "--no-browser",
+    "\u8BBE\u5907\u7801\u6D41\u7A0B\u4E0B\u53EA\u6253\u5370\u5730\u5740\u4E0E\u9A8C\u8BC1\u7801\uFF0C\u4E0D\u81EA\u52A8\u6253\u5F00\u6D4F\u89C8\u5668"
+  ).action(async (options) => {
+    const ctx = await context();
+    await runLogin(ctx, options);
+  });
+};
+var wantsPasswordFlow = (options) => Boolean(options.email || options.passwordStdin);
+var runLogin = async (ctx, options) => {
+  if (options.logout) {
+    const removed = await removeCredentials(ctx.credentialsFile);
+    ctx.logger.info(
+      removed ? `\u5DF2\u5220\u9664\u51ED\u636E\uFF1A${ctx.credentialsFile}` : `\u672C\u5730\u6CA1\u6709\u51ED\u636E\uFF1A${ctx.credentialsFile}`
+    );
+    if (ctx.logger.json) ctx.logger.result({ loggedOut: true, removed });
+    return;
+  }
+  if (options.show) {
+    const stored = await readCredentials(ctx.credentialsFile);
+    const api2 = createAdminApi(ctx.client);
+    let user = stored.user;
+    if (ctx.client.hasSession) {
+      user = await api2.getCurrentUser().catch(() => stored.user);
+    }
+    ctx.logger.table([
+      ["\u51ED\u636E\u6587\u4EF6", ctx.credentialsFile],
+      ["API", ctx.client.baseUrl],
+      ["\u7528\u6237", user ? summarizeUser(user) : "<\u672A\u767B\u5F55>"],
+      ["access token", describeTokenExpiry(stored.cookies.access)],
+      ["refresh token", stored.cookies.refresh ? "\u5DF2\u4FDD\u5B58" : "\u65E0"],
+      [
+        "csrf token",
+        stored.cookies.csrf ? "\u5DF2\u4FDD\u5B58" : "\u65E0\uFF08\u5C06\u4F7F\u7528 x-ssr \u901A\u9053\uFF09"
+      ]
+    ]);
+    if (ctx.logger.json) {
+      ctx.logger.result({
+        credentialsFile: ctx.credentialsFile,
+        apiUrl: ctx.client.baseUrl,
+        user: user ?? null,
+        hasSession: ctx.client.hasSession
+      });
+    }
+    return;
+  }
+  if (options.device || !wantsPasswordFlow(options)) {
+    await runDeviceLogin(ctx, options);
+    return;
+  }
+  const email = options.email?.trim() || ctx.runtime.env.QUANTA_EMAIL?.trim() || await promptVisible("\u90AE\u7BB1\uFF1A", {
+    stdin: ctx.runtime.stdin,
+    stderr: ctx.runtime.stderr
+  });
+  if (!email)
+    throw new UsageError("\u7F3A\u5C11\u90AE\u7BB1\uFF1A\u7528 --email \u6216 QUANTA_EMAIL \u63D0\u4F9B");
+  const password = await resolvePassword(ctx, options);
+  const api = createAdminApi(ctx.client);
+  ctx.logger.step(`\u767B\u5F55 ${ctx.client.baseUrl}`);
+  const result = await api.login({ email, password });
+  if (result.csrfToken && !ctx.client.cookies.csrf) {
+    ctx.client.cookies.csrf = result.csrfToken;
+  }
+  await writeCredentials(ctx.credentialsFile, {
+    version: 1,
+    apiUrl: ctx.env.apiUrl,
+    cookies: { ...ctx.client.cookies },
+    user: result.user
+  });
+  ctx.logger.success(`\u5DF2\u767B\u5F55\uFF1A${summarizeUser(result.user)}`);
+  ctx.logger.detail(`\u51ED\u636E\u5DF2\u5199\u5165 ${ctx.credentialsFile}\uFF08\u6743\u9650 0600\uFF09`);
+  if (result.user.role !== "ADMIN" && result.user.role !== "SUPER_ADMIN") {
+    ctx.logger.warn(`\u5F53\u524D\u89D2\u8272\u662F ${result.user.role}\uFF0C\u51FA\u9898\u63A5\u53E3\u8981\u6C42 ADMIN`);
+  }
+  if (ctx.logger.json) {
+    ctx.logger.result({
+      credentialsFile: ctx.credentialsFile,
+      apiUrl: ctx.env.apiUrl,
+      user: result.user
+    });
+  }
+};
+var runDeviceLogin = async (ctx, options) => {
+  const flow = createDeviceFlow({
+    baseUrl: ctx.env.apiUrl,
+    fetch: ctx.runtime.fetch,
+    logger: ctx.logger,
+    ...ctx.runtime.signal ? { signal: ctx.runtime.signal } : {},
+    timeoutMs: ctx.env.timeoutMs
+  });
+  ctx.logger.step(`\u5411 ${ctx.env.apiUrl} \u7533\u8BF7\u8BBE\u5907\u6388\u6743\u7801`);
+  const auth = await flow.requestCodes();
+  ctx.logger.blank();
+  ctx.logger.info("\u8BF7\u5728\u6D4F\u89C8\u5668\u4E2D\u5B8C\u6210\u6388\u6743\uFF1A");
+  ctx.logger.info(`  \u5730\u5740\uFF1A${auth.verification_uri}`);
+  ctx.logger.info(`  \u9A8C\u8BC1\u7801\uFF1A${ctx.logger.colors.bold(auth.user_code)}`);
+  ctx.logger.detail(
+    `\u9A8C\u8BC1\u7801 ${Math.round(auth.expires_in / 60)} \u5206\u949F\u5185\u6709\u6548\uFF0C\u8BF7\u5728\u786E\u8BA4\u9875\u6838\u5BF9\u4E0E\u672C\u7EC8\u7AEF\u4E00\u81F4`
+  );
+  ctx.logger.blank();
+  if (!options.noBrowser) {
+    const target = auth.verification_uri_complete || auth.verification_uri;
+    const opened = await openBrowser(target);
+    ctx.logger.detail(
+      opened ? "\u5DF2\u5C1D\u8BD5\u5728\u6D4F\u89C8\u5668\u4E2D\u6253\u5F00\u6388\u6743\u9875\u9762" : "\u65E0\u6CD5\u81EA\u52A8\u6253\u5F00\u6D4F\u89C8\u5668\uFF0C\u8BF7\u624B\u52A8\u8BBF\u95EE\u4E0A\u9762\u7684\u5730\u5740"
+    );
+  }
+  ctx.logger.step("\u7B49\u5F85\u6388\u6743\u5B8C\u6210\uFF08Ctrl-C \u53D6\u6D88\uFF09");
+  const tokens = await flow.pollForToken(auth, (elapsedMs) => {
+    if (ctx.logger.level === "debug") {
+      ctx.logger.detail(
+        `\u4ECD\u5728\u7B49\u5F85\u6388\u6743\u2026 \u5DF2\u7B49\u5F85 ${Math.round(elapsedMs / 1e3)} \u79D2`
+      );
+    }
+  });
+  ctx.client.cookies.access = tokens.access_token;
+  ctx.client.cookies.refresh = tokens.refresh_token;
+  await writeCredentials(ctx.credentialsFile, {
+    version: 1,
+    apiUrl: ctx.env.apiUrl,
+    cookies: { ...ctx.client.cookies }
+  });
+  const api = createAdminApi(ctx.client);
+  let summary = "\u5DF2\u767B\u5F55";
+  try {
+    const user = await api.getCurrentUser();
+    summary = `\u5DF2\u767B\u5F55\uFF1A${summarizeUser(user)}`;
+    await writeCredentials(ctx.credentialsFile, {
+      version: 1,
+      apiUrl: ctx.env.apiUrl,
+      cookies: { ...ctx.client.cookies },
+      user
+    });
+    if (user.role !== "ADMIN" && user.role !== "SUPER_ADMIN") {
+      ctx.logger.warn(
+        `\u5F53\u524D\u89D2\u8272\u662F ${user.role}\uFF0C\u51FA\u9898\u63A5\u53E3\u8981\u6C42 ADMIN\uFF0Cupload/publish \u4F1A\u88AB\u62D2\u7EDD`
+      );
+    }
+  } catch (error) {
+    ctx.logger.warn(
+      `\u767B\u5F55\u6210\u529F\u4F46\u8BFB\u53D6\u7528\u6237\u4FE1\u606F\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  ctx.logger.success(summary);
+  ctx.logger.detail(`\u51ED\u636E\u5DF2\u5199\u5165 ${ctx.credentialsFile}\uFF08\u6743\u9650 0600\uFF09`);
+  if (ctx.logger.json) {
+    ctx.logger.result({
+      loginMethod: "device_code",
+      credentialsFile: ctx.credentialsFile,
+      apiUrl: ctx.env.apiUrl,
+      scope: tokens.scope
+    });
+  }
+};
+var resolvePassword = async (ctx, options) => {
+  const fromEnv = ctx.runtime.env.QUANTA_PASSWORD;
+  if (fromEnv) return fromEnv;
+  if (options.passwordStdin) {
+    const value2 = await readAllStdin(ctx.runtime.stdin);
+    if (!value2) throw new UsageError("--password-stdin \u6CA1\u6709\u8BFB\u5230\u5185\u5BB9");
+    return value2;
+  }
+  if (!ctx.runtime.stdin.isTTY) {
+    throw new UsageError("\u975E\u4EA4\u4E92\u73AF\u5883\u4E0B\u65E0\u6CD5\u63D0\u793A\u8F93\u5165\u5BC6\u7801", {
+      hint: '\u7528 `echo "$PASSWORD" | qpc login --password-stdin`\uFF0C\u6216\u8BBE\u7F6E QUANTA_PASSWORD\u3002'
+    });
+  }
+  const value = await promptHidden("\u5BC6\u7801\uFF08\u4E0D\u4F1A\u56DE\u663E\uFF09\uFF1A", {
+    stdin: ctx.runtime.stdin,
+    stderr: ctx.runtime.stderr
+  });
+  if (!value) throw new UsageError("\u5BC6\u7801\u4E3A\u7A7A");
+  return value;
+};
+
+// src/commands/status.ts
+var registerStatusCommand = (registry) => {
+  const { program, context } = registry;
+  program.command("status").description("\u67E5\u770B\u9898\u76EE\u72B6\u6001\u4E0E\u6700\u8FD1\u4E00\u6B21\u5BA1\u8BA1\u7684\u68C0\u67E5\u70B9\u660E\u7EC6").argument("<problemId>", "\u9898\u76EE\u7248\u672C id\uFF08upload \u8FD4\u56DE\u7684 pid\uFF09").option("--watch", "\u6301\u7EED\u5237\u65B0\uFF0C\u76F4\u5230\u5BA1\u8BA1\u51FA\u7ED3\u679C\uFF08Ctrl-C \u9000\u51FA\uFF09").option("--interval <seconds>", "\u5237\u65B0\u95F4\u9694\uFF08\u79D2\uFF09", "3").action(
+    async (problemId, options) => {
+      const ctx = await context();
+      await runStatus(ctx, { problemId, ...options });
+    }
+  );
+};
+var runStatus = async (ctx, options) => {
+  const problemId = parseProblemId(options.problemId);
+  requireSession(ctx);
+  const api = createAdminApi(ctx.client);
+  if (!options.watch) {
+    const detail = await api.getAuditDetail(problemId);
+    renderAuditDetail(ctx.logger, detail, {
+      verbose: ctx.logger.level === "debug"
+    });
+    if (ctx.logger.json) ctx.logger.result(auditToJson(detail));
+    return;
+  }
+  const intervalMs = parseInterval(options.interval);
+  let lastSignature = "";
+  for (; ; ) {
+    if (ctx.runtime.signal?.aborted) return;
+    const detail = await api.getAuditDetail(problemId);
+    const record = auditRecordOf(detail);
+    const signature = `${detail.status}|${record?.result ?? "none"}|${record?.score ?? 0}`;
+    if (signature !== lastSignature) {
+      lastSignature = signature;
+      ctx.logger.blank();
+      renderAuditDetail(ctx.logger, detail, {
+        verbose: ctx.logger.level === "debug"
+      });
+    } else {
+      ctx.logger.detail(`\u72B6\u6001\u672A\u53D8\u5316\uFF08${signature}\uFF09`);
+    }
+    if (isAuditSettled(detail)) {
+      if (ctx.logger.json) ctx.logger.result(auditToJson(detail));
+      ctx.logger.success("\u5BA1\u8BA1\u5DF2\u51FA\u7ED3\u679C\uFF0C\u505C\u6B62\u5237\u65B0");
+      return;
+    }
+    await sleep(intervalMs, ctx.runtime.signal);
+  }
+};
+var parseProblemId = (value) => {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new UsageError(`\u9898\u76EE id \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF1A${value}`, {
+      hint: "id \u6765\u81EA `qpc upload` \u7684\u8F93\u51FA\uFF0C\u6216\u7BA1\u7406\u7AEF\u9898\u76EE\u5217\u8868\u3002"
+    });
+  }
+  return parsed;
+};
+var parseInterval = (value) => {
+  const seconds = Number.parseFloat(value ?? "3");
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    throw new UsageError(`--interval \u5FC5\u987B\u662F\u6B63\u6570\uFF08\u79D2\uFF09\uFF1A${value}`);
+  }
+  return seconds * 1e3;
+};
+
+// src/commands/publish.ts
+var registerPublishCommand = (registry) => {
+  const { program, context } = registry;
+  program.command("publish").description("\u53D1\u5E03\u9898\u76EE\uFF08status: ready \u2192 published\uFF09\uFF0C\u6216 --unpublish \u4E0B\u67B6").argument("<problemId>", "\u9898\u76EE\u7248\u672C id").option("--unpublish", "\u4E0B\u67B6\uFF08published \u2192 ready\uFF09").action(
+    async (problemId, options) => {
+      const ctx = await context();
+      await runPublish(ctx, { problemId, ...options });
+    }
+  );
+};
+var runPublish = async (ctx, options) => {
+  const problemId = parseProblemId(options.problemId);
+  requireSession(ctx);
+  const api = createAdminApi(ctx.client);
+  const detail = await api.getAuditDetail(problemId);
+  const publish = !options.unpublish;
+  if (publish && !["ready", "published"].includes(detail.status)) {
+    throw new UsageError(
+      `\u9898\u76EE #${problemId} \u5F53\u524D\u72B6\u6001\u662F ${detail.status}\uFF0C\u4E0D\u80FD\u53D1\u5E03`,
+      {
+        hint: "\u53EA\u6709\u5BA1\u8BA1\u901A\u8FC7\uFF08status=ready\uFF09\u7684\u7248\u672C\u624D\u80FD\u53D1\u5E03\uFF1B\u5148 `qpc status <id> --watch` \u770B\u5BA1\u8BA1\u7ED3\u679C\u3002"
+      }
+    );
+  }
+  if (!publish && detail.status !== "published") {
+    throw new UsageError(
+      `\u9898\u76EE #${problemId} \u5F53\u524D\u72B6\u6001\u662F ${detail.status}\uFF0C\u65E0\u9700\u4E0B\u67B6`
+    );
+  }
+  ctx.logger.step(
+    `${publish ? "\u53D1\u5E03" : "\u4E0B\u67B6"}\u9898\u76EE #${problemId}\uFF08${detail.title}\uFF09`
+  );
+  const result = await api.setStatus(problemId, publish);
+  ctx.logger.success(result.message);
+  if (ctx.logger.json) {
+    ctx.logger.result({
+      problemId,
+      publish,
+      status: publish ? "published" : "ready",
+      message: result.message
+    });
+  }
+};
+var registerTagCommand = (registry) => {
+  const { program, context } = registry;
+  program.command("tag").description("\u67E5\u770B\u5E73\u53F0\u6807\u7B7E\uFF1B--write \u4EA4\u4E92\u591A\u9009\u540E\u628A tagIds \u5199\u56DE\u914D\u7F6E").argument("[dir]", "\u9898\u76EE\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09", ".").option("--write", "\u4EA4\u4E92\u5F0F\u591A\u9009\u6807\u7B7E\u5E76\u5199\u56DE\u914D\u7F6E").option("--set <id...>", "\u76F4\u63A5\u6307\u5B9A\u6807\u7B7E id\uFF08\u9017\u53F7\u6216\u7A7A\u683C\u5206\u9694\uFF09\uFF0C\u5199\u56DE\u914D\u7F6E").action(async (dir, options) => {
+    const ctx = await context();
+    await runTag(ctx, { dir, ...options });
+  });
+};
+var runTag = async (ctx, options) => {
+  if (options.write && options.set !== void 0) {
+    throw new UsageError("--write \u4E0E --set \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528", {
+      hint: "--write \u662F\u4EA4\u4E92\u591A\u9009\uFF0C--set \u662F\u76F4\u63A5\u6307\u5B9A id\uFF0C\u4E8C\u9009\u4E00\u3002"
+    });
+  }
+  const api = createAdminApi(ctx.client);
+  ctx.logger.step("\u8BFB\u53D6\u5E73\u53F0\u6807\u7B7E\uFF08public.tag.list\uFF09");
+  const tags = await api.listTags();
+  if (!options.write && options.set === void 0) {
+    renderTags(ctx, tags);
+    if (ctx.logger.json) ctx.logger.result({ tags });
+    return;
+  }
+  if (tags.length === 0) {
+    throw new UsageError("\u5E73\u53F0\u4E0A\u8FD8\u6CA1\u6709\u6807\u7B7E\uFF0C\u65E0\u6CD5\u914D\u7F6E", {
+      hint: "\u5148\u5728\u7BA1\u7406\u7AEF\u300C\u6807\u7B7E\u7BA1\u7406\u300D\u521B\u5EFA\u6807\u7B7E\uFF0C\u518D\u91CD\u8DD1\u3002"
+    });
+  }
+  const rootDir = resolve(ctx.cwd, options.dir);
+  const configFile = await findConfigFile(rootDir);
+  const tagIds = options.set !== void 0 ? assertTagsExist(parseTagIds(options.set), tags) : await pickTags(ctx, tags, await readCurrentTagIds(configFile));
+  const written = await writeBackTagIds(configFile, tagIds);
+  ctx.logger.blank();
+  renderTags(ctx, tags, new Set(tagIds));
+  ctx.logger.success(
+    `tagIds \u5DF2\u5199\u56DE ${displayPath(ctx.cwd, written)}\uFF1A[${tagIds.join(", ")}]`
+  );
+  if (ctx.logger.json) {
+    ctx.logger.result({
+      tagIds,
+      tags,
+      configFile
+    });
+  }
+};
+var renderTags = (ctx, tags, selected) => {
+  if (tags.length === 0) {
+    ctx.logger.warn("\u5E73\u53F0\u4E0A\u8FD8\u6CA1\u6709\u6807\u7B7E");
+    return;
+  }
+  const { colors } = ctx.logger;
+  ctx.logger.step(`\u5E73\u53F0\u6807\u7B7E\uFF08${tags.length} \u4E2A\uFF09`);
+  for (const tag of tags) {
+    const mark = selected ? selected.has(tag.tid) ? colors.green("\u25CF") : colors.dim("\u25CB") : colors.dim("\xB7");
+    const color = tag.color ? colors.dim(tag.color) : "";
+    ctx.logger.info(`  ${mark} #${tag.tid} ${tag.name}  ${color}`);
+    if (tag.description) ctx.logger.detail(tag.description);
+  }
+};
+var pickTags = async (ctx, tags, current) => {
+  const chosen = await multiselect(
+    "\u9009\u62E9\u672C\u9898\u7684\u6807\u7B7E\uFF08\u7A7A\u683C\u5207\u6362\uFF0C\u56DE\u8F66\u786E\u8BA4\uFF09",
+    tags.map((tag) => ({
+      value: String(tag.tid),
+      label: `#${tag.tid} ${tag.name}`,
+      ...tag.color ? { hint: tag.color } : {}
+    })),
+    {
+      stdin: ctx.runtime.stdin,
+      stderr: ctx.runtime.stderr,
+      stderrStream: ctx.runtime.stderrStream
+    },
+    { initialValues: current.map(String), required: true }
+  );
+  return chosen.map((value) => Number.parseInt(value, 10));
+};
+var readCurrentTagIds = async (configFile) => {
+  const content = await readText(configFile);
+  const match = /\btagIds\s*:\s*\[([^\]]*)\]/.exec(content);
+  if (!match) return [];
+  return (match[1] ?? "").split(",").map((part) => Number.parseInt(part.trim(), 10)).filter((id) => Number.isInteger(id) && id > 0);
+};
+var parseTagIds = (values) => {
+  const parts = values.flatMap((value) => value.split(",")).map((part) => part.trim()).filter(Boolean);
+  const parsed = parts.map((part) => Number.parseInt(part, 10));
+  if (parsed.length === 0 || parsed.some((id) => !Number.isInteger(id) || id <= 0)) {
+    throw new UsageError(`\u6807\u7B7E id \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF1A${parts.join(", ")}`, {
+      hint: "\u8FD0\u884C `qpc tag` \u67E5\u770B\u53EF\u7528 id\u3002"
+    });
+  }
+  return parsed;
+};
+var assertTagsExist = (tagIds, tags) => {
+  const known = new Set(tags.map((tag) => tag.tid));
+  const missing = tagIds.filter((id) => !known.has(id));
+  if (missing.length > 0) {
+    throw new UsageError(`\u6807\u7B7E\u4E0D\u5B58\u5728\uFF1A${missing.join(", ")}`, {
+      hint: `\u53EF\u7528 id\uFF1A${tags.map((tag) => tag.tid).join(", ")}\uFF08\`qpc tag\` \u770B\u540D\u79F0\uFF09\u3002`
+    });
+  }
+  return tagIds;
+};
+var writeBackTagIds = async (configFile, tagIds) => {
+  const original = await readText(configFile);
+  const patched = applyTagIdsUpdate(original, tagIds, configFile);
+  await writeTextAtomic(configFile, patched);
+  try {
+    const reloaded = await loadProblemConfig(resolve(configFile, ".."));
+    const same = reloaded.tagIds.length === tagIds.length && reloaded.tagIds.every((id, index) => id === tagIds[index]);
+    if (!same) throw new Error("\u5199\u56DE\u540E\u8BFB\u53D6\u5230\u7684 tagIds \u4E0E\u9884\u671F\u4E0D\u4E00\u81F4");
+  } catch (error) {
+    await writeTextAtomic(configFile, original);
+    throw new ConfigError("\u5199\u56DE tagIds \u540E\u914D\u7F6E\u6821\u9A8C\u5931\u8D25\uFF0C\u5DF2\u56DE\u6EDA\u539F\u6587\u4EF6", {
+      cause: error,
+      hint: `\u624B\u52A8\u628A tagIds \u586B\u6210 [${tagIds.join(", ")}]\u3002`
+    });
+  }
+  return configFile;
+};
+var registerUploadCommand = (registry) => {
+  const { program, context } = registry;
+  program.command("upload").description("\u4E0A\u4F20\u9898\u76EE\uFF08\u65B0\u5EFA\u6216\u8FFD\u52A0\u7248\u672C\uFF09\u5E76\u53EF\u7B49\u5F85\u7EBF\u4E0A\u5BA1\u8BA1\u7ED3\u679C").argument("[dir]", "\u9898\u76EE\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09", ".").option("--dry-run", "\u53EA\u505A\u9884\u68C0\u5E76\u6253\u5370\u5C06\u8981\u63D0\u4EA4\u7684\u5185\u5BB9").option("--skip-check", "\u8DF3\u8FC7\u9884\u68C0\uFF08\u4E0D\u5EFA\u8BAE\uFF09").option("--no-wait", "\u4E0A\u4F20\u540E\u4E0D\u7B49\u5F85\u5BA1\u8BA1").option(
+    "--problem <pid>",
+    "\u5728\u8BE5\u9898\u76EE\u4E0B\u8FFD\u52A0\u65B0\u7248\u672C\uFF08\u8986\u76D6\u914D\u7F6E\u91CC\u7684 problemId\uFF09"
+  ).option("--new", "\u5F3A\u5236\u65B0\u5EFA\u9898\u76EE\uFF08\u5FFD\u7565\u914D\u7F6E\u91CC\u7684 problemId\uFF09").option("--write", "\u628A\u672C\u6B21\u4F7F\u7528\u7684\u9898\u76EE id \u5199\u56DE\u914D\u7F6E").option("--timeout <seconds>", "\u5BA1\u8BA1\u7B49\u5F85\u8D85\u65F6\uFF08\u79D2\uFF09", "180").option("--interval <seconds>", "\u5BA1\u8BA1\u72B6\u6001\u8F6E\u8BE2\u95F4\u9694\uFF08\u79D2\uFF09", "2").action(async (dir, options) => {
+    const ctx = await context();
+    await runUpload(ctx, { dir, ...options });
+  });
+};
+var runUpload = async (ctx, options) => {
+  const rootDir = resolve(ctx.cwd, options.dir);
+  const config = await loadProblemConfig(rootDir);
+  if (options.new && options.problem !== void 0) {
+    throw new UsageError("--new \u4E0E --problem \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528", {
+      hint: "\u8981\u65B0\u5EFA\u9898\u76EE\u5C31\u522B\u6307\u5B9A --problem\uFF1B\u8981\u8FFD\u52A0\u7248\u672C\u5C31\u522B\u52A0 --new\u3002"
+    });
+  }
+  const targetProblemId = resolveTargetProblemId(options, config.problemId);
+  let report;
+  if (options.skipCheck) {
+    ctx.logger.warn(
+      "\u5DF2\u8DF3\u8FC7\u9884\u68C0\uFF08--skip-check\uFF09\uFF1A\u9759\u6001\u9519\u8BEF\u4F1A\u7559\u5230\u7EBF\u4E0A\u5BA1\u8BA1\u624D\u66B4\u9732"
+    );
+    report = await validateProblem(config, {
+      maxUploadBytes: ctx.env.maxUploadBytes
+    });
+  } else {
+    report = await validateProblem(config, {
+      maxUploadBytes: ctx.env.maxUploadBytes
+    });
+    renderFindings(ctx.logger, report.findings);
+    if (!report.ok) {
+      throw new PrecheckError(
+        `\u9884\u68C0\u672A\u901A\u8FC7\uFF1A${report.errors} \u4E2A\u9519\u8BEF\uFF0C\u5DF2\u4E2D\u6B62\u4E0A\u4F20`,
+        {
+          hint: "\u4FEE\u590D\u540E\u91CD\u8DD1\uFF1B\u786E\u5B9E\u8981\u5F3A\u884C\u4E0A\u4F20\u65F6\u7528 --skip-check\u3002"
+        }
+      );
+    }
+  }
+  const judgeScript = await readText(config.paths.judge);
+  const payload = {
+    title: config.title,
+    detail: config.detail,
+    tagIds: config.tagIds,
+    difficulty: config.difficulty,
+    totalScore: report.totalScore,
+    judgeScript,
+    answerTemplateSnapshot: report.templateSnapshot,
+    referenceAnswerSnapshot: report.answerSnapshot,
+    coverMode: config.cover.mode,
+    ...config.cover.mode === "custom" ? { coverImageId: config.cover.imageId } : {},
+    ...config.runtime.bootCommand ? { bootCommand: config.runtime.bootCommand } : {},
+    ...config.runtime.buildCommand ? { buildCommand: config.runtime.buildCommand } : {},
+    initCommand: config.runtime.initCommand,
+    judgeUploadPath: config.runtime.judgeUploadPath,
+    problemType: config.type,
+    ...config.runtime.serviceImage ? { serviceImage: config.runtime.serviceImage } : {},
+    servicePort: config.runtime.servicePort
+  };
+  const payloadBytes = Buffer.byteLength(judgeScript, "utf8") + report.stats.template.totalBytes + report.stats.answer.totalBytes;
+  ctx.logger.step("\u4E0A\u4F20\u5185\u5BB9\u6458\u8981");
+  ctx.logger.table([
+    ["\u6807\u9898", config.title],
+    ["\u96BE\u5EA6 / \u603B\u5206", `${config.difficulty} / ${report.totalScore}`],
+    ["\u6807\u7B7E", config.tagIds.join(", ")],
+    ["\u5224\u9898\u6253\u5305\u76EE\u5F55", config.runtime.judgeUploadPath],
+    ["\u9898\u578B", config.type],
+    ["\u542F\u52A8\u547D\u4EE4", config.runtime.initCommand ?? "<\u9ED8\u8BA4>"],
+    ["\u7B54\u6848\u6A21\u677F", `${report.stats.template.fileCount} \u4E2A\u6587\u4EF6`],
+    ["\u53C2\u8003\u89E3", `${report.stats.answer.fileCount} \u4E2A\u6587\u4EF6`],
+    ["\u5224\u9898\u811A\u672C", `${Buffer.byteLength(judgeScript, "utf8")} \u5B57\u8282`],
+    ["\u8BF7\u6C42\u4F53", formatBytes(payloadBytes)],
+    [
+      "\u76EE\u6807",
+      targetProblemId === void 0 ? "\u65B0\u5EFA\u9898\u76EE" : `\u9898\u76EE #${targetProblemId} \u7684\u65B0\u7248\u672C`
+    ],
+    [
+      "\u63A5\u53E3",
+      `${ctx.env.apiUrl} \u2192 ${targetProblemId === void 0 ? "admin.problem.upload" : "admin.problem.reupload"}`
+    ]
+  ]);
+  if (options.dryRun) {
+    ctx.logger.success("--dry-run\uFF1A\u672A\u53D1\u8D77\u4EFB\u4F55\u8BF7\u6C42");
+    if (ctx.logger.json) {
+      ctx.logger.result({
+        dryRun: true,
+        mode: targetProblemId === void 0 ? "create" : "version",
+        targetProblemId,
+        payload: {
+          ...payload,
+          judgeScript: `<${judgeScript.length} \u5B57\u7B26>`,
+          answerTemplateSnapshot: `<${report.stats.template.fileCount} \u4E2A\u6587\u4EF6>`,
+          referenceAnswerSnapshot: `<${report.stats.answer.fileCount} \u4E2A\u6587\u4EF6>`
+        },
+        validation: validationToJson(report)
+      });
+    }
+    return;
+  }
+  requireSession(ctx);
+  const api = createAdminApi(ctx.client);
+  let baseId;
+  if (targetProblemId !== void 0) {
+    ctx.logger.step(`\u67E5\u627E\u9898\u76EE #${targetProblemId} \u7684\u57FA\u7840\u9898 id`);
+    const target = await api.getAuditDetail(targetProblemId);
+    baseId = target.BaseProblem?.id;
+    if (baseId === void 0) {
+      throw new PrecheckError(
+        `\u9898\u76EE #${targetProblemId} \u6CA1\u6709\u5173\u8054\u7684\u57FA\u7840\u9898\uFF0C\u65E0\u6CD5\u8FFD\u52A0\u7248\u672C`,
+        {
+          hint: "\u786E\u8BA4\u8FD9\u4E2A id \u6765\u81EA `qpc upload` / \u7BA1\u7406\u7AEF\uFF0C\u4E14\u5C5E\u4E8E\u5F53\u524D\u8D26\u53F7\u3002"
+        }
+      );
+    }
+  }
+  await confirmOrSkip(
+    ctx,
+    targetProblemId === void 0 ? "\u786E\u8BA4\u521B\u5EFA\u65B0\u9898\u76EE\uFF1F" : `\u786E\u8BA4\u5728\u9898\u76EE #${targetProblemId} \u4E0B\u521B\u5EFA\u65B0\u7248\u672C\uFF1F`
+  );
+  ctx.logger.step(
+    baseId === void 0 ? "\u63D0\u4EA4 upload \u8BF7\u6C42" : "\u63D0\u4EA4 reupload \u8BF7\u6C42"
+  );
+  const created = baseId === void 0 ? await api.uploadProblem(payload) : await api.reuploadProblem({ ...payload, baseId });
+  const problemId = created.problemId;
+  ctx.logger.success(
+    baseId === void 0 ? `\u9898\u76EE\u5DF2\u521B\u5EFA\uFF1A#${problemId}\uFF08${created.message}\uFF09` : `\u65B0\u7248\u672C\u5DF2\u521B\u5EFA\uFF1A#${problemId}\uFF08${created.message}\uFF09`
+  );
+  const writeBackIfRequested = async () => {
+    if (!options.write) return;
+    const written = await writeBackProblemId(config.configFile, problemId);
+    ctx.logger.success(
+      `problemId \u5DF2\u5199\u56DE ${relative(ctx.cwd, written) || written}`
+    );
+  };
+  if (!options.write) {
+    if (targetProblemId === void 0 && config.problemId === void 0) {
+      ctx.logger.info(
+        `  \u52A0 --write \u53EF\u628A problemId: ${problemId} \u5199\u56DE\u914D\u7F6E\uFF0C\u4E4B\u540E\u4E0A\u4F20\u9ED8\u8BA4\u5728\u8BE5\u9898\u76EE\u4E0B\u8FFD\u52A0\u7248\u672C`
+      );
+    } else if (options.new && config.problemId !== void 0) {
+      ctx.logger.warn(
+        `  \u914D\u7F6E\u91CC\u7684 problemId: ${config.problemId} \u4ECD\u6307\u5411\u65E7\u9898\u76EE\uFF1B\u8981\u6539\u7528\u65B0\u9898\u76EE\u8BF7\u52A0 --write`
+      );
+    }
+  }
+  if (options.wait === false) {
+    await writeBackIfRequested();
+    ctx.logger.info(`  \u5BA1\u8BA1\u72B6\u6001\uFF1Aqpc status ${problemId} --watch`);
+    if (ctx.logger.json) ctx.logger.result({ problemId, waited: false });
+    return;
+  }
+  const detail = await waitForAudit(
+    ctx,
+    problemId,
+    options.timeout,
+    options.interval
+  );
+  const passed = renderAuditDetail(ctx.logger, detail, {
+    verbose: ctx.logger.level === "debug"
+  });
+  if (ctx.logger.json) ctx.logger.result({ problemId, waited: true, detail });
+  if (!passed) {
+    const hasRecord = auditRecordOf(detail) !== void 0;
+    const reason = hasRecord ? '\u770B\u4E0A\u9762\u7684\u68C0\u67E5\u70B9\u660E\u7EC6\uFF1A\u5206\u6570\u4E0D\u7B49\u901A\u5E38\u662F"\u53C2\u8003\u89E3\u62FF\u4E0D\u5230\u6EE1\u5206"\u6216"totalScore \u4E0E\u68C0\u67E5\u70B9\u4E4B\u548C\u4E0D\u4E00\u81F4"\u3002' : "\u9898\u76EE\u72B6\u6001\u5DF2\u7F6E\u4E3A invalid\uFF0C\u4F46\u5224\u9898\u8BB0\u5F55\u6CA1\u6709\u5199\u56DE\uFF1A\u591A\u534A\u662F\u5224\u9898\u673A/\u5BB9\u5668\u51FA\u7ED3\u679C\u524D\u5C31\u5D29\u4E86\uFF0C\u770B\u8C03\u5EA6\u5668\u65E5\u5FD7\u3002";
+    throw new PrecheckError(`\u9898\u76EE #${problemId} \u5BA1\u8BA1\u672A\u901A\u8FC7`, {
+      hint: options.write ? `${reason}\uFF08--write \u5DF2\u8DF3\u8FC7\uFF1A\u5BA1\u8BA1\u672A\u901A\u8FC7\u4E0D\u5199\u56DE problemId\uFF09` : reason
+    });
+  }
+  await writeBackIfRequested();
+  ctx.logger.success(`\u5BA1\u8BA1\u901A\u8FC7\uFF1A${detail.totalScore} \u5206\u6EE1\u5206`);
+  ctx.logger.info(`  \u53D1\u5E03\uFF1Aqpc publish ${problemId}`);
+};
+var waitForAudit = async (ctx, problemId, timeoutSeconds, intervalSeconds) => {
+  const api = createAdminApi(ctx.client);
+  const timeoutMs = parsePositiveSeconds(timeoutSeconds, 180) * 1e3;
+  const intervalMs = parsePositiveSeconds(intervalSeconds, 2) * 1e3;
+  ctx.logger.step(`\u7B49\u5F85\u5BA1\u8BA1\u7ED3\u679C\uFF08\u6700\u591A ${Math.round(timeoutMs / 1e3)} \u79D2\uFF09`);
+  const detail = await poll({
+    intervalMs,
+    timeoutMs,
+    signal: ctx.runtime.signal,
+    probe: async () => {
+      const current = await api.getAuditDetail(problemId);
+      if (isAuditSettled(current)) return current;
+      ctx.logger.detail(`\u5BA1\u8BA1\u8FDB\u884C\u4E2D\u2026\uFF08status=${current.status}\uFF09`);
+      return void 0;
+    }
+  });
+  if (!detail) {
+    throw new PrecheckError(`\u7B49\u5F85\u5BA1\u8BA1\u8D85\u65F6\uFF08\u9898\u76EE #${problemId}\uFF09`, {
+      hint: `\u53EF\u80FD\u539F\u56E0\uFF1A\u8C03\u5EA6\u5668\u672A\u8FD0\u884C / \u5224\u9898\u673A\u5BB9\u5668\u8D77\u4E0D\u6765\u3002\u68C0\u67E5 qpc status ${problemId}\uFF0C\u5E76\u770B\u8C03\u5EA6\u5668\u65E5\u5FD7\u3002`
+    });
+  }
+  return detail;
+};
+var parsePositiveSeconds = (value, fallback) => {
+  if (value === void 0) return fallback;
+  const seconds = Number.parseFloat(value);
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    throw new UsageError(`\u65F6\u95F4\u53C2\u6570\u5FC5\u987B\u662F\u6B63\u6570\uFF08\u79D2\uFF09\uFF1A${value}`);
+  }
+  return seconds;
+};
+var resolveTargetProblemId = (options, configuredProblemId) => {
+  if (options.new) return void 0;
+  if (options.problem !== void 0) return parseProblemId(options.problem);
+  return configuredProblemId;
+};
+var writeBackProblemId = async (configFile, problemId) => {
+  const original = await readText(configFile);
+  const patched = applyProblemIdUpdate(original, problemId, configFile);
+  await writeTextAtomic(configFile, patched);
+  try {
+    const reloaded = await loadProblemConfig(resolve(configFile, ".."));
+    if (reloaded.problemId !== problemId) {
+      throw new Error("\u5199\u56DE\u540E\u8BFB\u53D6\u5230\u7684 problemId \u4E0E\u9884\u671F\u4E0D\u4E00\u81F4");
+    }
+  } catch (error) {
+    await writeTextAtomic(configFile, original);
+    throw new ConfigError("\u5199\u56DE problemId \u540E\u914D\u7F6E\u6821\u9A8C\u5931\u8D25\uFF0C\u5DF2\u56DE\u6EDA\u539F\u6587\u4EF6", {
+      cause: error,
+      hint: `\u624B\u52A8\u628A problemId: ${problemId} \u586B\u8FDB\u914D\u7F6E\u3002`
+    });
+  }
+  return configFile;
+};
+
+// src/commands/index.ts
+var registerCommands = (registry) => {
+  registerInitCommand(registry);
+  registerCheckCommand(registry);
+  registerCoverCommand(registry);
+  registerTagCommand(registry);
+  registerUploadCommand(registry);
+  registerStatusCommand(registry);
+  registerPublishCommand(registry);
+  registerLoginCommand(registry);
+  registerDoctorCommand(registry);
+};
+
+// src/services/http.ts
+var COOKIE_NAMES = {
+  access: "quanta_access_token",
+  refresh: "quanta_refresh_token",
+  csrf: "quanta_csrf_token"
+};
+var HttpClient = class {
+  baseUrl;
+  cookies;
+  options;
+  refreshing;
+  constructor(options) {
+    this.options = options;
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.cookies = { ...options.cookies };
+  }
+  get hasSession() {
+    return Boolean(this.cookies.access || this.cookies.refresh);
+  }
+  url(path) {
+    if (/^https?:\/\//i.test(path)) return path;
+    return `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+  }
+  headers(extra = {}) {
+    const headers = {
+      accept: "application/json",
+      "user-agent": `qpc/${CLI_VERSION} (quanta-problem-creator)`,
+      ...extra
+    };
+    const cookie = Object.entries(COOKIE_NAMES).map(([key, name]) => {
+      const value = this.cookies[key];
+      return value ? `${name}=${value}` : void 0;
+    }).filter((entry) => Boolean(entry)).join("; ");
+    if (cookie) headers.cookie = cookie;
+    if (this.cookies.csrf) {
+      headers["x-csrf-token"] = this.cookies.csrf;
+    } else {
+      headers["x-ssr"] = "1";
+    }
+    return headers;
+  }
+  /** 解析 set-cookie 并并入 cookie jar，返回是否有变化 */
+  absorbCookies(response) {
+    const raw = response.headers.getSetCookie?.() ?? [];
+    if (raw.length === 0) return false;
+    let changed = false;
+    for (const entry of raw) {
+      const [pair] = entry.split(";");
+      if (!pair) continue;
+      const index = pair.indexOf("=");
+      if (index <= 0) continue;
+      const name = pair.slice(0, index).trim();
+      const value = pair.slice(index + 1).trim();
+      for (const [key, cookieName] of Object.entries(COOKIE_NAMES)) {
+        if (name !== cookieName) continue;
+        const slot = key;
+        if (value === "") {
+          delete this.cookies[slot];
+        } else if (this.cookies[slot] !== value) {
+          this.cookies[slot] = value;
+        } else {
+          continue;
+        }
+        changed = true;
+      }
+    }
+    return changed;
+  }
+  async persistCookies() {
+    await this.options.onCookiesChanged?.(this.cookies);
+  }
+  /** 低层请求：负责超时、错误分类与 cookie 吸收，不做 tRPC 解码 */
+  async request(path, init = {}) {
+    const url = this.url(path);
+    const timeoutMs = init.timeoutMs ?? this.options.timeoutMs ?? 15e3;
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    const signal = init.signal ? AbortSignal.any([init.signal, timeoutSignal]) : timeoutSignal;
+    const headers = {
+      ...this.headers(),
+      ...init.headers ?? {}
+    };
+    this.options.logger.debug(`${init.method ?? "GET"} ${url}`);
+    let response;
+    try {
+      response = await this.options.fetch(url, { ...init, headers, signal });
+    } catch (error) {
+      if (isAbortError(error)) {
+        throw new NetworkError(`\u8BF7\u6C42\u8D85\u65F6\u6216\u5DF2\u53D6\u6D88\uFF1A${url}`, {
+          cause: error,
+          details: { url, timeoutMs },
+          hint: "\u786E\u8BA4\u670D\u52A1\u5DF2\u542F\u52A8\uFF08docker compose up -d\uFF09\uFF0C\u6216\u8C03\u5927 QUANTA_HTTP_TIMEOUT\u3002"
+        });
+      }
+      throw new NetworkError(`\u65E0\u6CD5\u8FDE\u63A5 ${url}`, {
+        cause: error,
+        details: { url },
+        hint: "\u786E\u8BA4 API \u5730\u5740\u6B63\u786E\u4E14\u670D\u52A1\u5DF2\u542F\u52A8\uFF1Aqpc doctor"
+      });
+    }
+    if (this.absorbCookies(response)) await this.persistCookies();
+    return response;
+  }
+  /** 调用 tRPC procedure。path 形如 `admin.problem.upload` */
+  async call(path, options = {}) {
+    const method = options.method ?? "POST";
+    const endpoint = `/api/trpc/${path}`;
+    const send = async (retried = false) => {
+      const response = method === "GET" ? await this.request(
+        `${endpoint}?input=${encodeURIComponent(JSON.stringify(options.input ?? null))}`,
+        { method: "GET", signal: options.signal }
+      ) : await this.request(endpoint, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(options.input ?? null),
+        signal: options.signal
+      });
+      const text = await response.text();
+      const payload = parseJson(text);
+      if (response.ok && isTrpcSuccess(payload))
+        return payload.result.data;
+      if (response.status === 401 && !retried && await this.refreshSession()) {
+        return send(true);
+      }
+      throw this.toApiError(response, payload, endpoint);
+    };
+    return send();
+  }
+  /** 用 refresh token 换新的 access token（GET /api/refresh）；token 仅 15 分钟，刷新是必需路径。 */
+  async refreshSession() {
+    if (this.refreshing) return this.refreshing;
+    if (!this.cookies.refresh) return false;
+    this.refreshing = (async () => {
+      try {
+        const response = await this.request("/api/refresh", {
+          method: "GET"
+        });
+        if (!response.ok) {
+          this.options.logger.warn(
+            "\u5237\u65B0\u767B\u5F55\u72B6\u6001\u5931\u8D25\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C `qpc login`"
+          );
+          return false;
+        }
+        await response.arrayBuffer();
+        this.options.logger.debug("access token \u5DF2\u5237\u65B0");
+        return Boolean(this.cookies.access);
+      } catch {
+        return false;
+      } finally {
+        this.refreshing = void 0;
+      }
+    })();
+    return this.refreshing;
+  }
+  toApiError(response, payload, path) {
+    const failure = payload;
+    const json = failure?.error?.json;
+    const message = json?.message ?? `HTTP ${response.status}`;
+    const status = json?.data?.httpStatus ?? response.status;
+    if (status === 401 || status === 403) {
+      return new ApiError(message, {
+        status,
+        path,
+        details: { code: json?.data?.code, traceId: json?.data?.traceId },
+        hint: status === 401 ? "\u767B\u5F55\u72B6\u6001\u5DF2\u5931\u6548\uFF1Aqpc login --force \u91CD\u65B0\u767B\u5F55\u3002" : "\u5F53\u524D\u8D26\u53F7\u6CA1\u6709\u7BA1\u7406\u5458\u6743\u9650\uFF08\u51FA\u9898\u63A5\u53E3\u8981\u6C42 role=ADMIN\uFF09\u3002"
+      });
+    }
+    return new ApiError(message, {
+      status,
+      path,
+      details: {
+        code: json?.data?.code,
+        traceId: json?.data?.traceId,
+        zodError: json?.data?.zodError
+      }
+    });
+  }
+};
+var parseJson = (text) => {
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+};
+var isTrpcSuccess = (payload) => typeof payload === "object" && payload !== null && "result" in payload && typeof payload.result?.data !== "undefined";
+
+// src/core/env.ts
+var DEFAULT_API_URL = "http://localhost:3000";
+var DEFAULT_HTTP_TIMEOUT_MS = 15e3;
+var DEFAULT_MAX_UPLOAD_BYTES = 5 * 1024 * 1024;
+var parsePositiveInt = (value, fallback) => {
+  if (!value) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var resolveEnvConfig = (env = process.env) => {
+  const apiUrlFromEnv = env.QUANTA_API_URL?.trim() || void 0;
+  return {
+    apiUrl: apiUrlFromEnv || DEFAULT_API_URL,
+    apiUrlFromEnv,
+    token: env.QUANTA_TOKEN?.trim() || void 0,
+    timeoutMs: parsePositiveInt(
+      env.QUANTA_HTTP_TIMEOUT,
+      DEFAULT_HTTP_TIMEOUT_MS
+    ),
+    maxUploadBytes: parsePositiveInt(
+      env.QUANTA_MAX_UPLOAD_BYTES,
+      DEFAULT_MAX_UPLOAD_BYTES
+    ),
+    configDir: resolveConfigDir(env)
+  };
+};
+var OTEL_SEVERITY = {
+  error: { number: 17, text: "ERROR" },
+  warn: { number: 13, text: "WARN" },
+  info: { number: 9, text: "INFO" },
+  debug: { number: 5, text: "DEBUG" }
+};
+var LOG_LEVEL_RANK = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4
+};
+var write = (target, line) => target(`${line}
+`);
+var createLogger = (options = {}) => {
+  const level = options.level ?? "info";
+  const json = options.json ?? false;
+  const colors = createColors(json ? false : options.color ?? true);
+  const stdout = options.stdout ?? ((chunk) => process.stdout.write(chunk));
+  const stderr = options.stderr ?? ((chunk) => process.stderr.write(chunk));
+  const enabled = (candidate) => LOG_LEVEL_RANK[candidate] <= LOG_LEVEL_RANK[level] && level !== "silent";
+  const emit = (candidate, symbol, message, meta, stream = "stderr") => {
+    if (!enabled(candidate)) return;
+    if (json) {
+      const severity = OTEL_SEVERITY[candidate];
+      const attributes = meta && Object.keys(meta).length > 0 ? meta : void 0;
+      write(
+        stderr,
+        JSON.stringify({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          severity_number: severity.number,
+          severity_text: severity.text,
+          body: message,
+          ...attributes ? { attributes } : {},
+          resource: { "service.name": "challenge-problem-creator-cli" }
+        })
+      );
+      return;
+    }
+    const target = stream === "stdout" ? stdout : stderr;
+    const label = symbol ? `${symbol} ` : "";
+    write(target, `${label}${message}`);
+    if (meta && Object.keys(meta).length > 0) {
+      write(target, colors.dim(`   ${JSON.stringify(meta)}`));
+    }
+  };
+  const symbols = colors.isColorSupported ? {
+    info: colors.blue("\u2139"),
+    warn: colors.yellow("\u25B2"),
+    error: colors.red("\u2716"),
+    step: colors.cyan("\u25B8"),
+    success: colors.green("\u2714"),
+    fail: colors.red("\u2716")
+  } : {
+    info: "[i]",
+    warn: "[!]",
+    error: "[x]",
+    step: ">",
+    success: "[ok]",
+    fail: "[x]"
+  };
+  return {
+    level,
+    json,
+    colors,
+    error: (message, meta) => emit("error", symbols.error, message, meta),
+    warn: (message, meta) => emit("warn", symbols.warn, colors.yellow(message), meta),
+    info: (message, meta) => emit("info", symbols.info, message, meta, "stdout"),
+    debug: (message, meta) => emit("debug", colors.dim("\xB7"), colors.dim(message), meta),
+    step: (message) => emit("info", symbols.step, colors.bold(message), void 0, "stdout"),
+    success: (message) => emit(
+      "info",
+      symbols.success,
+      colors.green(message),
+      void 0,
+      "stdout"
+    ),
+    fail: (message) => emit("error", symbols.fail, colors.red(message)),
+    detail: (message) => emit("info", "", colors.dim(`  ${message}`), void 0, "stdout"),
+    blank: () => {
+      if (json || level === "silent") return;
+      write(stderr, "");
+    },
+    result: (payload) => {
+      write(stdout, json ? JSON.stringify(payload) : String(payload));
+    },
+    table: (rows) => {
+      if (json || rows.length === 0) return;
+      const width = Math.max(...rows.map(([key]) => displayWidth(key)));
+      for (const [key, value] of rows) {
+        const pad = " ".repeat(Math.max(0, width - displayWidth(key)));
+        write(stdout, `  ${key}${pad}  ${value}`);
+      }
+    }
+  };
+};
+var displayWidth = (text) => {
+  let width = 0;
+  for (const char of text) {
+    const code = char.codePointAt(0) ?? 0;
+    width += code >= 4352 && isWide(code) ? 2 : 1;
+  }
+  return width;
+};
+var isWide = (code) => code >= 4352 && code <= 4447 || code >= 11904 && code <= 42191 || code >= 44032 && code <= 55203 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65135 || code >= 65280 && code <= 65376 || code >= 65504 && code <= 65510;
+
+// src/core/context.ts
+var resolveLogLevel = (options) => {
+  if (options.verbose) return "debug";
+  if (options.quiet) return "error";
+  return "info";
+};
+var resolveColor = (options, runtime2) => {
+  if (options.color !== void 0) return options.color;
+  if (runtime2.env.NO_COLOR) return false;
+  return runtime2.isTTY ?? false;
+};
+var createCommandContext = async (options, runtime2) => {
+  const env = resolveEnvConfig(runtime2.env);
+  const logger = createLogger({
+    level: resolveLogLevel(options),
+    json: options.json ?? false,
+    color: resolveColor(options, runtime2),
+    stdout: runtime2.stdout,
+    stderr: runtime2.stderr
+  });
+  const baseDir = options.cwd ?? runtime2.env.INIT_CWD ?? runtime2.cwd;
+  const cwd = resolve(runtime2.cwd, baseDir);
+  const credentialsFile = credentialsPath(env.configDir);
+  const stored = await readCredentials(credentialsFile);
+  const apiUrl = (options.api ?? env.apiUrlFromEnv ?? stored.apiUrl ?? env.apiUrl).replace(/\/+$/, "");
+  const credentials = {
+    ...stored,
+    apiUrl,
+    cookies: { ...stored.cookies }
+  };
+  const tokenFromEnv = Boolean(options.token ?? env.token);
+  if (tokenFromEnv) credentials.cookies.access = options.token ?? env.token;
+  const persistCredentials = async (next) => {
+    if (tokenFromEnv && !next) return;
+    await writeCredentials(credentialsFile, next ?? credentials);
+  };
+  const client = new HttpClient({
+    baseUrl: apiUrl,
+    fetch: runtime2.fetch,
+    cookies: credentials.cookies,
+    logger,
+    timeoutMs: env.timeoutMs,
+    signal: runtime2.signal,
+    onCookiesChanged: (cookies) => {
+      if (tokenFromEnv) return;
+      return persistCredentials({ ...credentials, cookies });
+    }
+  });
+  return {
+    runtime: runtime2,
+    logger,
+    cwd,
+    env: { ...env, apiUrl },
+    credentialsFile,
+    credentials,
+    client,
+    assumeYes: options.yes ?? false,
+    persistCredentials
+  };
+};
+
+// src/core/runtime.ts
+var createProcessRuntime = (overrides = {}) => ({
+  cwd: process.cwd(),
+  env: process.env,
+  stdin: process.stdin,
+  stdout: (chunk) => process.stdout.write(chunk),
+  stderr: (chunk) => process.stderr.write(chunk),
+  stderrStream: process.stderr,
+  fetch: ((input, init) => globalThis.fetch(input, init)),
+  now: () => Date.now(),
+  isTTY: Boolean(process.stdout.isTTY),
+  ...overrides
+});
+var installSignalHandlers = (runtime2) => {
+  const controller2 = new AbortController();
+  let interrupts = 0;
+  const onSignal = () => {
+    interrupts += 1;
+    if (interrupts > 1) {
+      runtime2.stderr("\n\u518D\u6B21\u6536\u5230\u4E2D\u65AD\u4FE1\u53F7\uFF0C\u7ACB\u5373\u9000\u51FA\u3002\n");
+      process.exit(130);
+    }
+    runtime2.stderr("\n\u6B63\u5728\u53D6\u6D88\u2026\uFF08\u518D\u6309\u4E00\u6B21 Ctrl-C \u5F3A\u5236\u9000\u51FA\uFF09\n");
+    controller2.abort(new CanceledError("\u5DF2\u53D6\u6D88\uFF08Ctrl-C\uFF09"));
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  return {
+    controller: controller2,
+    dispose: () => {
+      process.removeListener("SIGINT", onSignal);
+      process.removeListener("SIGTERM", onSignal);
+    }
+  };
+};
+
+// src/cli.ts
+var createProgram = (runtime2) => {
+  const program = new Command();
+  program.name(CLI_NAME).description(CLI_DESCRIPTION).version(CLI_VERSION, "-v, --version", "\u67E5\u770B\u7248\u672C\u53F7").option(
+    "--api <url>",
+    "Web \u5E94\u7528\u5730\u5740\uFF08\u9ED8\u8BA4 QUANTA_API_URL \u6216 http://localhost:3000\uFF09"
+  ).option(
+    "--token <token>",
+    "\u76F4\u63A5\u4F7F\u7528\u8BBF\u95EE\u4EE4\u724C\uFF08\u9ED8\u8BA4 QUANTA_TOKEN\uFF1B\u4E0D\u4F1A\u5199\u5165\u51ED\u636E\u6587\u4EF6\uFF09"
+  ).option(
+    "--cwd <dir>",
+    "\u5DE5\u4F5C\u76EE\u5F55\u57FA\u51C6\uFF08\u89E3\u6790\u987A\u5E8F\uFF1A--cwd > INIT_CWD > \u8FDB\u7A0B cwd\uFF09"
+  ).option("--json", "\u8F93\u51FA\u673A\u5668\u53EF\u8BFB JSON\uFF08stdout \u53EA\u6709\u7ED3\u679C\uFF0C\u65E5\u5FD7\u8D70 stderr\uFF09").option("--quiet", "\u9690\u85CF\u8FDB\u5EA6\u4FE1\u606F\uFF0C\u53EA\u4FDD\u7559\u9519\u8BEF\u4E0E\u547D\u4EE4\u7ED3\u679C").option("--verbose", "\u8F93\u51FA\u8C03\u8BD5\u4FE1\u606F").option("--no-color", "\u7981\u7528\u5F69\u8272\u8F93\u51FA").option("-y, --yes", "\u8DF3\u8FC7\u4EA4\u4E92\u786E\u8BA4\uFF08CI \u5FC5\u7ED9\uFF09").showHelpAfterError("\uFF08\u7528 `qpc --help` \u67E5\u770B\u5168\u90E8\u7528\u6CD5\uFF09").configureOutput({
+    writeOut: (chunk) => runtime2.stdout(chunk),
+    writeErr: (chunk) => runtime2.stderr(chunk)
+  }).exitOverride();
+  const globals = () => {
+    const options = program.opts();
+    const colorExplicit = program.getOptionValueSource("color") === "cli";
+    return {
+      api: asString(options.api),
+      token: asString(options.token),
+      cwd: asString(options.cwd),
+      json: Boolean(options.json),
+      quiet: Boolean(options.quiet),
+      verbose: Boolean(options.verbose),
+      yes: Boolean(options.yes),
+      color: colorExplicit ? Boolean(options.color) : void 0
+    };
+  };
+  const registry = {
+    program,
+    context: () => createCommandContext(globals(), runtime2)
+  };
+  registerCommands(registry);
+  return program;
+};
+var runCli = async (argv, runtime2 = createProcessRuntime()) => {
+  const program = createProgram(runtime2);
+  try {
+    await program.parseAsync(argv, { from: "node" });
+    return EXIT.OK;
+  } catch (error) {
+    if (error instanceof CommanderError) {
+      return error.exitCode === 0 ? EXIT.OK : EXIT.USAGE;
+    }
+    const cliError = toCliError(error);
+    const json = argv.includes("--json");
+    const logger = createLogger({
+      level: "debug",
+      json,
+      color: runtime2.isTTY ?? false,
+      stdout: runtime2.stdout,
+      stderr: runtime2.stderr
+    });
+    if (json) {
+      logger.result({
+        ok: false,
+        error: {
+          name: cliError.name,
+          message: cliError.message,
+          hint: cliError.hint,
+          details: cliError.details,
+          exitCode: cliError.exitCode
+        }
+      });
+    } else {
+      logger.error(cliError.message);
+      if (cliError.hint) logger.info(`  ${cliError.hint}`);
+      if (cliError.details && argv.includes("--verbose")) {
+        logger.detail(JSON.stringify(cliError.details, null, 3));
+      }
+      if (!(error instanceof Error) || !(error instanceof CommanderError)) {
+        const cause = cliError.cause;
+        if (argv.includes("--verbose") && cause instanceof Error && cause.stack) {
+          logger.detail(cause.stack);
+        }
+      }
+    }
+    return cliError.exitCode;
+  }
+};
+var asString = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+
+// src/index.ts
+var runtime = createProcessRuntime();
+var { controller, dispose } = installSignalHandlers(runtime);
+var exitCode = await runCli(process.argv, {
+  ...runtime,
+  signal: controller.signal
+});
+dispose();
+process.exitCode = exitCode;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map