#!/usr/bin/env node

import { spawn, spawnSync } from 'node:child_process';
import http from 'node:http';
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import { pathToFileURL as pathToFileUrl } from 'node:url';

const ROOT = process.cwd();
const PORT = Number(process.env.TRUEGROWTH_LOCAL_API_PORT || 48177);
const BASE_URL = `http://127.0.0.1:${PORT}`;
const MOCK_COMFYUI_PORT = Number(
  process.env.TRUEGROWTH_MOCK_COMFYUI_PORT || 58188
);
const MOCK_COMFYUI_BASE_URL = `http://127.0.0.1:${MOCK_COMFYUI_PORT}`;
const TIMEOUT_MS = Number(process.env.TRUEGROWTH_VERIFY_TIMEOUT_MS || 90_000);
const FLUX_EXPECTED_BYTES = 17_236_328_572;
const QWEN_EXPECTED_BYTES = 57_954_375_058;
const COMFYUI_DIR = path.resolve(
  process.env.TRUEGROWTH_COMFYUI_DIR || path.join(ROOT, 'vendor', 'ComfyUI')
);
const FLUX_FILE = path.join(
  COMFYUI_DIR,
  'models',
  'checkpoints',
  'flux1-schnell-fp8.safetensors'
);
const QWEN_DIR = path.join(COMFYUI_DIR, 'models', 'diffusers', 'Qwen-Image');
const STATIC_FILES = [
  'scripts/truegrowth-local-api.mjs',
  'apps/web/src/workbench/WorkbenchShell.tsx',
  'apps/web/src/workbench/local-runtime-client.ts',
  'packages/drawnix/src/utils/runtime-model-discovery.ts',
  'packages/drawnix/src/services/media-executor/fallback-executor.ts',
];
const TINY_PNG = Buffer.from(
  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII=',
  'base64'
);

function createMockComfyUiDir() {
  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'truegrowth-mock-comfyui-'));
  fs.mkdirSync(path.join(root, 'models', 'checkpoints'), { recursive: true });
  fs.mkdirSync(path.join(root, 'models', 'diffusers', 'Qwen-Image'), {
    recursive: true,
  });
  fs.mkdirSync(path.join(root, 'models', 'diffusers', 'Qwen-Image', 'transformer'), {
    recursive: true,
  });
  fs.mkdirSync(path.join(root, 'models', 'diffusers', 'Qwen-Image', 'text_encoder'), {
    recursive: true,
  });
  fs.mkdirSync(path.join(root, 'models', 'diffusers', 'Qwen-Image', 'vae'), {
    recursive: true,
  });
  fs.writeFileSync(path.join(root, 'main.py'), '# mock comfyui\n');
  fs.writeFileSync(path.join(root, 'requirements.txt'), '# mock requirements\n');
  fs.writeFileSync(
    path.join(root, 'models', 'checkpoints', 'flux1-schnell-fp8.safetensors'),
    'mock flux'
  );
  fs.writeFileSync(
    path.join(root, 'models', 'diffusers', 'Qwen-Image', 'model_index.json'),
    '{}\n'
  );
  fs.writeFileSync(
    path.join(
      root,
      'models',
      'diffusers',
      'Qwen-Image',
      'transformer',
      'diffusion_pytorch_model.safetensors.index.json'
    ),
    '{}\n'
  );
  fs.writeFileSync(
    path.join(
      root,
      'models',
      'diffusers',
      'Qwen-Image',
      'text_encoder',
      'model.safetensors.index.json'
    ),
    '{}\n'
  );
  fs.writeFileSync(
    path.join(
      root,
      'models',
      'diffusers',
      'Qwen-Image',
      'vae',
      'diffusion_pytorch_model.safetensors'
    ),
    'mock vae'
  );
  return root;
}

function assert(condition, message) {
  if (!condition) {
    throw new Error(message);
  }
}

function delay(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

function safeJson(text) {
  try {
    return JSON.parse(text);
  } catch {
    return null;
  }
}

async function requestJson(url, options = {}) {
  const response = await fetch(url, options);
  const text = await response.text();
  const json = safeJson(text);
  if (!response.ok) {
    throw new Error(
      `${options.method || 'GET'} ${url} failed ${response.status}: ${text}`
    );
  }
  return json ?? text;
}

async function apiIsReady() {
  try {
    await requestJson(`${BASE_URL}/local-api/health`);
    return true;
  } catch {
    return false;
  }
}

async function waitForApi() {
  const startedAt = Date.now();
  while (Date.now() - startedAt < TIMEOUT_MS) {
    if (await apiIsReady()) {
      return;
    }
    await delay(300);
  }
  throw new Error('Local API did not become ready in time.');
}

function startMockComfyUiServer() {
  const requests = {
    prompts: [],
    views: [],
  };
  const server = http.createServer(async (request, response) => {
    const url = new URL(request.url || '/', MOCK_COMFYUI_BASE_URL);
    const sendJson = (status, payload) => {
      response.writeHead(status, { 'content-type': 'application/json' });
      response.end(JSON.stringify(payload));
    };
    if (request.method === 'GET' && url.pathname === '/system_stats') {
      sendJson(200, {
        system: { os: 'mock', python_version: '3.11' },
        devices: [{ name: 'Mock GPU', type: 'cuda', vram_total: 24_000 }],
      });
      return;
    }
    if (request.method === 'GET' && url.pathname === '/object_info') {
      sendJson(200, {
        CheckpointLoaderSimple: {
          input: {
            required: {
              ckpt_name: [
                ['flux1-schnell-fp8.safetensors', 'sd_xl_base_1.0.safetensors'],
              ],
            },
          },
        },
        CLIPTextEncode: { input: { required: {} } },
        EmptySD3LatentImage: { input: { required: {} } },
        KSampler: { input: { required: {} } },
        VAEDecode: { input: { required: {} } },
        SaveImage: { input: { required: {} } },
        TrueGrowthQwenImageGenerate: {
          input: { required: { model_name: [['Qwen-Image']] } },
        },
      });
      return;
    }
    if (request.method === 'POST' && url.pathname === '/prompt') {
      const chunks = [];
      for await (const chunk of request) chunks.push(chunk);
      const bodyText = Buffer.concat(chunks).toString('utf8');
      const body = safeJson(bodyText) || {};
      requests.prompts.push(body.prompt || body);
      sendJson(200, { prompt_id: `mock-prompt-${requests.prompts.length}` });
      return;
    }
    if (request.method === 'GET' && url.pathname.startsWith('/history/')) {
      const promptId = decodeURIComponent(url.pathname.split('/').pop() || '');
      sendJson(200, {
        [promptId]: {
          outputs: {
            9: {
              images: [
                {
                  filename: 'truegrowth_mock_00001_.png',
                  subfolder: '',
                  type: 'output',
                },
              ],
            },
          },
        },
      });
      return;
    }
    if (request.method === 'GET' && url.pathname === '/view') {
      requests.views.push(Object.fromEntries(url.searchParams.entries()));
      response.writeHead(200, { 'content-type': 'image/png' });
      response.end(TINY_PNG);
      return;
    }
    sendJson(404, { error: 'not_found', path: url.pathname });
  });
  return new Promise((resolve, reject) => {
    server.once('error', reject);
    server.listen(MOCK_COMFYUI_PORT, '127.0.0.1', () => {
      server.off('error', reject);
      resolve({ server, requests });
    });
  });
}

async function waitForTaskCompleted(taskId) {
  const startedAt = Date.now();
  let lastTask = null;
  while (Date.now() - startedAt < TIMEOUT_MS) {
    const payload = await requestJson(`${BASE_URL}/local-api/tasks/${taskId}`);
    const task = payload.task || payload.item || payload;
    lastTask = task;
    if (task.status === 'completed') return task;
    if (task.status === 'failed') {
      throw new Error(`Task failed: ${task.error || 'unknown error'}`);
    }
    await delay(300);
  }
  throw new Error(
    `Task ${taskId} did not complete in time. Last state: ${JSON.stringify(
      lastTask
    )}`
  );
}

function fileSizeLabel(filePath) {
  try {
    const bytes = fs.statSync(filePath).size;
    if (bytes > 1024 ** 3) return `${(bytes / 1024 ** 3).toFixed(2)} GB`;
    if (bytes > 1024 ** 2) return `${(bytes / 1024 ** 2).toFixed(2)} MB`;
    return `${bytes} B`;
  } catch {
    return null;
  }
}

function qwenSizeLabel() {
  if (!fs.existsSync(QWEN_DIR)) return null;
  let bytes = 0;
  const stack = [QWEN_DIR];
  while (stack.length) {
    const current = stack.pop();
    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
      const fullPath = path.join(current, entry.name);
      if (entry.isDirectory()) {
        stack.push(fullPath);
      } else if (entry.isFile()) {
        bytes += fs.statSync(fullPath).size;
      }
    }
  }
  return bytes > 1024 ** 3
    ? `${(bytes / 1024 ** 3).toFixed(2)} GB`
    : `${(bytes / 1024 ** 2).toFixed(2)} MB`;
}

function bytesLabel(bytes) {
  if (!Number.isFinite(Number(bytes))) return null;
  return `${(Number(bytes) / 1024 ** 3).toFixed(2)} GB`;
}

function diskAvailableBytes(targetPath) {
  try {
    const existingPath = fs.existsSync(targetPath)
      ? targetPath
      : path.dirname(targetPath);
    const result = spawnSync('df', ['-k', existingPath], { encoding: 'utf8' });
    if (result.error) throw result.error;
    const output = result.stdout || '';
    const line = output.trim().split(/\r?\n/).pop() || '';
    const parts = line.trim().split(/\s+/);
    const availableKb = Number(parts[3] || 0);
    return Number.isFinite(availableKb) ? availableKb * 1024 : null;
  } catch {
    return null;
  }
}

function runStaticCheck() {
  const contents = Object.fromEntries(
    STATIC_FILES.map((file) => [
      file,
      fs.readFileSync(path.join(ROOT, file), 'utf8'),
    ])
  );
  const api = contents['scripts/truegrowth-local-api.mjs'];
  const discovery =
    contents['packages/drawnix/src/utils/runtime-model-discovery.ts'];
  const executor =
    contents[
      'packages/drawnix/src/services/media-executor/fallback-executor.ts'
    ];
  const workbench = contents['apps/web/src/workbench/WorkbenchShell.tsx'];
  const client = contents['apps/web/src/workbench/local-runtime-client.ts'];

  assert(
    api.includes(
      'https://huggingface.co/Comfy-Org/flux1-schnell/resolve/main/flux1-schnell-fp8.safetensors'
    ),
    'FLUX official download URL is missing from local API.'
  );
  assert(
    api.includes(
      'git clone --depth 1 https://github.com/comfyanonymous/ComfyUI.git vendor/ComfyUI'
    ) &&
      api.includes("'--depth'") &&
      api.includes("'1'"),
    'ComfyUI automatic install should use a shallow official GitHub clone.'
  );
  assert(
    api.includes('function pythonVersionInfo') &&
      api.includes('function resolveComfyUiPythonCommand') &&
      api.includes("path.join(os.homedir(), 'miniconda3', 'bin', 'python3.12')") &&
      api.includes('Python 3.10+') &&
      api.includes('pythonVersion.ok'),
    'ComfyUI setup should auto-select and require Python 3.10+ before automatic install.'
  );
  assert(
    api.includes("repo: 'Qwen/Qwen-Image'"),
    'Qwen-Image official repo is missing from local API.'
  );
  assert(
    api.includes('function getTrueGrowthComfyUiCustomNodeDir') &&
      api.includes('class TrueGrowthQwenImageGenerate') &&
      api.includes('"TrueGrowthQwenImageGenerate": TrueGrowthQwenImageGenerate') &&
      api.includes('huggingface_hub>=0.24.0'),
    'TrueGrowth Qwen-Image ComfyUI custom node is missing.'
  );
  assert(
    api.includes("templateId: 'flux-fp8-checkpoint-text-to-image'"),
    'FLUX FP8 template is missing from local API.'
  );
  assert(
    api.includes("id: 'qwen-image-text-to-image'") &&
      api.includes('function buildQwenImageComfyUiWorkflow'),
    'Qwen-Image ComfyUI template or workflow builder is missing.'
  );
  assert(
    api.includes('function buildFluxFp8CheckpointComfyUiWorkflow'),
    'FLUX FP8 ComfyUI workflow builder is missing.'
  );
  assert(
    api.includes('minFreeBytes: 18 * 1024 * 1024 * 1024') &&
      api.includes('minFreeBytes: 70 * 1024 * 1024 * 1024'),
    'Model download disk preflight thresholds are missing.'
  );
  assert(
    api.includes('expectedBytes: 17_236_328_572') &&
      api.includes('expectedBytes: 57_954_375_058') &&
      api.includes('python3 -m huggingface_hub download Qwen/Qwen-Image'),
    'Official FLUX/Qwen download sizes or manual commands are missing.'
  );
  assert(
    api.includes("'-m',") &&
      api.includes("'huggingface_hub'") &&
      api.includes("'download'") &&
      api.includes("downloadSpec.repo"),
    'Qwen-Image snapshot download does not fall back to python -m huggingface_hub.'
  );
  assert(
    api.includes('function comfyUiModelDownloadPreflight') &&
      api.includes('downloadPreflight:'),
    'Model Center assets do not expose ComfyUI download preflight state.'
  );
  assert(
    api.includes('function getComfyUiVendorDir') &&
      api.includes("pathname === '/local-api/comfyui/setup'") &&
      api.includes('missing_vendor_path') &&
      api.includes('invalid_comfyui_dir'),
    'Local API does not let Model Center register an existing ComfyUI directory.'
  );
  assert(
    api.includes('function installComfyUiImageAssetFromPath') &&
      api.includes('function linkOrCopyComfyUiModelSource') &&
      api.includes('function validateAigcPanelModelAssetLocalPath') &&
      api.includes('function isCompleteQwenImageDiffusersModel') &&
      api.includes("'model_index.json'") &&
      api.includes("path.join('transformer', 'diffusion_pytorch_model.safetensors.index.json')") &&
      api.includes('validate-local') &&
      api.includes("asset.runtimeKind === 'comfyui-image'"),
    'Local API does not install existing FLUX/Qwen files into ComfyUI model directories.'
  );
  assert(
    api.includes('function huggingFaceCacheStatus') &&
      api.includes('cacheStatus,'),
    'ComfyUI model preflight does not report Hugging Face cache status.'
  );
  assert(
    discovery.includes('flux-fp8-checkpoint-text-to-image'),
    'FLUX FP8 model is missing from runtime model discovery.'
  );
  assert(
    discovery.includes('qwen-image-text-to-image') &&
      discovery.includes('Qwen-Image 本地生图'),
    'Qwen-Image model is missing from runtime model discovery.'
  );
  assert(
    !discovery.includes('...LOCAL_COMFYUI_MODEL_IDS'),
    'Local ComfyUI templates should not be selected by default before model files are applied.'
  );
  assert(
    executor.includes("templateId: 'flux-fp8-checkpoint-text-to-image'"),
    'Media executor does not route FLUX FP8 selections to the FLUX FP8 template.'
  );
  assert(
    executor.includes("templateId: 'qwen-image-text-to-image'"),
    'Media executor does not route Qwen-Image selections to the Qwen template.'
  );
  assert(
    workbench.includes('图片模型本地供应商 · ComfyUI') &&
      workbench.includes('文件约 17.2GB'),
    'Model Center ComfyUI guide or FLUX size copy is missing.'
  );
  assert(
    workbench.includes('在模型中心一键安装 ComfyUI') &&
      workbench.includes('没有安装 ComfyUI 时，从这里开始') &&
      workbench.includes('一键安装 ComfyUI'),
    'Model Center does not clearly guide first-time ComfyUI installation.'
  );
  assert(
    workbench.includes('Python 3.10+'),
    'Model Center does not explain the Python 3.10+ ComfyUI requirement.'
  );
  assert(
    workbench.includes('downloadPreflight') && workbench.includes('空间不足'),
    'Model Center does not surface ComfyUI download blockers.'
  );
  assert(
    workbench.includes('检测到未完成缓存') &&
      workbench.includes('downloadPreflight.cacheStatus'),
    'Model Center does not surface partial Hugging Face cache state.'
  );
  assert(
    workbench.includes('官方大小') &&
      workbench.includes('tg-comfy-download-guide') &&
      workbench.includes('python3 -m huggingface_hub download Qwen/Qwen-Image'),
    'Model Center does not show official model sizes and manual ComfyUI download commands.'
  );
  assert(
    workbench.includes('已有 ComfyUI 目录') &&
      workbench.includes('configureComfyUiRuntime') &&
      workbench.includes('登记目录'),
    'Model Center does not expose existing ComfyUI directory registration.'
  );
  assert(
    workbench.includes('FLUX safetensors 文件或 Qwen-Image 目录') &&
      workbench.includes('.safetensors') &&
      workbench.includes('检查路径') &&
      workbench.includes('ComfyUI 接入预览'),
    'Model Center import guide does not explain existing local image model import.'
  );
  assert(
    client.includes('minFreeBytes?: number') &&
      client.includes('cacheStatus?:'),
    'Frontend client type does not expose model disk/cache requirement.'
  );
  const availableBytes = diskAvailableBytes(COMFYUI_DIR);
  console.log(
    JSON.stringify(
      {
        ok: true,
        mode: 'static',
        officialDownloads: {
          flux: {
            repo: 'https://huggingface.co/Comfy-Org/flux1-schnell',
            file: 'https://huggingface.co/Comfy-Org/flux1-schnell/resolve/main/flux1-schnell-fp8.safetensors',
            expectedSize: bytesLabel(FLUX_EXPECTED_BYTES),
            templateId: 'flux-fp8-checkpoint-text-to-image',
          },
          qwenImage: {
            repo: 'https://huggingface.co/Qwen/Qwen-Image',
            expectedRepoSize: bytesLabel(QWEN_EXPECTED_BYTES),
            target: 'models/diffusers/Qwen-Image',
            templateId: 'qwen-image-text-to-image',
            customNode: 'TrueGrowthQwenImageGenerate',
            runnable: true,
          },
        },
        disk: {
          comfyUiDir: COMFYUI_DIR,
          available: bytesLabel(availableBytes),
          canDownloadFlux: Boolean(
            availableBytes && availableBytes >= 18 * 1024 ** 3
          ),
          canDownloadQwenImage: Boolean(
            availableBytes && availableBytes >= 70 * 1024 ** 3
          ),
        },
      },
      null,
      2
    )
  );
}

async function runWorkflowCheck() {
  const {
    assertComfyUiWorkflowDimensionsForVerification,
    createComfyUiWorkflowForVerification,
    getComfyUiImageSizeForVerification,
  } = await import(
    pathToFileUrl(path.join(ROOT, 'scripts', 'truegrowth-local-api.mjs')).href
  );
  const dimensionCases = [
    { size: '16:9', expected: { width: 1824, height: 1024 } },
    { size: '16x9', expected: { width: 1824, height: 1024 } },
    { size: '9:16', expected: { width: 1024, height: 1824 } },
    { size: '1x1', expected: { width: 1024, height: 1024 } },
    { size: '1536x1024', expected: { width: 1536, height: 1024 } },
  ];
  for (const item of dimensionCases) {
    const actual = getComfyUiImageSizeForVerification(item.size, '1024x1024');
    assert(
      actual.width === item.expected.width &&
        actual.height === item.expected.height,
      `ComfyUI size ${item.size} resolved to ${actual.width}x${actual.height}, expected ${item.expected.width}x${item.expected.height}.`
    );
  }
  const fluxWorkflow = createComfyUiWorkflowForVerification({
    templateId: 'flux-fp8-checkpoint-text-to-image',
    modelId: 'flux1-schnell-fp8.safetensors',
    prompt: 'orange product poster',
    size: '1024x1024',
    steps: 4,
    cfg: 1,
    seed: 42,
  });
  const qwenWorkflow = createComfyUiWorkflowForVerification({
    templateId: 'qwen-image-text-to-image',
    modelId: 'Qwen-Image',
    prompt: '中文海报，标题为增长引擎',
    negativePrompt: '低清晰度',
    size: '1024x1024',
    steps: 20,
    cfg: 4,
    seed: 42,
  });
  assertComfyUiWorkflowDimensionsForVerification(
    {
      templateId: 'flux-fp8-checkpoint-text-to-image',
      modelId: 'flux1-schnell-fp8.safetensors',
      prompt: 'orange product poster',
      size: '16x9',
      steps: 4,
      cfg: 1,
      seed: 42,
    },
    { width: 1824, height: 1024 }
  );
  assertComfyUiWorkflowDimensionsForVerification(
    {
      templateId: 'qwen-image-text-to-image',
      modelId: 'Qwen-Image',
      prompt: '中文竖版海报',
      aspectRatio: '9:16',
      steps: 20,
      cfg: 4,
      seed: 42,
    },
    { width: 1024, height: 1824 }
  );
  assertComfyUiWorkflowDimensionsForVerification(
    {
      templateId: 'qwen-image-text-to-image',
      modelId: 'Qwen-Image',
      prompt: '固定尺寸海报',
      width: 1280,
      height: 720,
      steps: 20,
      cfg: 4,
      seed: 42,
    },
    { width: 1280, height: 720 }
  );
  assert(
    Object.values(fluxWorkflow).some(
      (node) =>
        node.class_type === 'CheckpointLoaderSimple' &&
        node.inputs?.ckpt_name === 'flux1-schnell-fp8.safetensors'
    ),
    'FLUX workflow does not load the FP8 checkpoint.'
  );
  assert(
    Object.values(fluxWorkflow).some((node) => node.class_type === 'KSampler'),
    'FLUX workflow is missing KSampler.'
  );
  assert(
    Object.values(qwenWorkflow).some(
      (node) =>
        node.class_type === 'TrueGrowthQwenImageGenerate' &&
        node.inputs?.model_name === 'Qwen-Image' &&
        node.inputs?.negative_prompt === '低清晰度'
    ),
    'Qwen workflow does not use the TrueGrowth Qwen-Image node.'
  );
  assert(
    Object.values(qwenWorkflow).some(
      (node) =>
        node.class_type === 'SaveImage' &&
        String(node.inputs?.filename_prefix || '').includes('qwen_image')
    ),
    'Qwen workflow does not save generated image output.'
  );
  console.log(
    JSON.stringify(
      {
        ok: true,
        mode: 'workflow',
        dimensionCases,
        fluxNodes: Object.values(fluxWorkflow).map((node) => node.class_type),
        qwenNodes: Object.values(qwenWorkflow).map((node) => node.class_type),
      },
      null,
      2
    )
  );
}

async function main() {
  if (process.argv.includes('--static')) {
    runStaticCheck();
    return;
  }
  if (process.argv.includes('--workflow')) {
    await runWorkflowCheck();
    return;
  }
  if (process.argv.includes('--mock-comfyui')) {
    let mock = null;
    let child = null;
    let stderr = '';
    let stdout = '';
    let childExit = null;
    let mockComfyUiDir = null;
    try {
      mockComfyUiDir = createMockComfyUiDir();
      mock = await startMockComfyUiServer();
      child = spawn(process.execPath, ['scripts/truegrowth-local-api.mjs'], {
        cwd: ROOT,
        env: {
          ...process.env,
          TRUEGROWTH_LOCAL_API_PORT: String(PORT),
          TRUEGROWTH_COMFYUI_BASE_URL: MOCK_COMFYUI_BASE_URL,
          TRUEGROWTH_COMFYUI_DIR: mockComfyUiDir,
          TRUEGROWTH_COMFYUI_HISTORY_ATTEMPTS: '10',
        },
        stdio: ['ignore', 'pipe', 'pipe'],
      });
      child.stdout.on('data', (chunk) => {
        stdout += String(chunk);
      });
      child.stderr.on('data', (chunk) => {
        stderr += String(chunk);
      });
      child.on('exit', (code, signal) => {
        childExit = { code, signal };
      });
      try {
        await waitForApi();
      } catch (error) {
        if (/listen EPERM|EACCES|operation not permitted/i.test(stderr)) {
          throw new Error(
            `Local API could not listen on ${BASE_URL}. Current environment blocked localhost binding. Raw error: ${stderr.trim()}`
          );
        }
        throw new Error(
          `Local API did not become ready in time. exit: ${
            childExit ? JSON.stringify(childExit) : 'still running'
          } stdout: ${stdout.trim()} stderr: ${stderr.trim()}`
        );
      }

      const status = await requestJson(`${BASE_URL}/local-api/comfyui/status`);
      const statusConnection = status.connection || status;
      const statusTemplates = statusConnection.templates || status.templates || [];
      assert(
        statusConnection.connected,
        `Mock ComfyUI status should be connected. Payload: ${JSON.stringify(
          status
        )}`
      );
      assert(
        statusTemplates.some(
          (item) =>
            item.id === 'flux-fp8-checkpoint-text-to-image' && item.available
        ),
        'FLUX FP8 template should be available against mock ComfyUI.'
      );
      assert(
        statusTemplates.some(
          (item) =>
            item.id === 'qwen-image-text-to-image' && item.available
        ),
        'Qwen-Image template should be available against mock ComfyUI.'
      );

      const generated = [];
      for (const input of [
        {
          label: 'flux',
          templateId: 'flux-fp8-checkpoint-text-to-image',
          modelId: 'flux1-schnell-fp8.safetensors',
          prompt: 'a clean orange product poster',
        },
        {
          label: 'qwen',
          templateId: 'qwen-image-text-to-image',
          modelId: 'Qwen-Image',
          prompt: '中文海报，标题为增长引擎',
        },
      ]) {
        const submit = await requestJson(
          `${BASE_URL}/local-api/comfyui/generate-image`,
          {
            method: 'POST',
            headers: { 'content-type': 'application/json' },
            body: JSON.stringify({
              title: `Mock ${input.label}`,
              payload: {
                prompt: input.prompt,
                templateId: input.templateId,
                modelId: input.modelId,
                size: '1024x1024',
                steps: input.label === 'flux' ? 4 : 20,
                cfg: input.label === 'flux' ? 1 : 4,
                seed: 42,
              },
            }),
          }
        );
        assert(submit.task?.id, `${input.label} task was not created.`);
        const task = await waitForTaskCompleted(submit.task.id);
        assert(
          Array.isArray(task.assetIds) && task.assetIds.length > 0,
          `${input.label} task did not create an asset.`
        );
        generated.push({
          label: input.label,
          taskId: task.id,
          assetIds: task.assetIds,
        });
      }
      const assets = await requestJson(`${BASE_URL}/local-api/assets`);
      for (const item of generated) {
        const assetId = item.assetIds[0];
        const asset = assets.items?.find((candidate) => candidate.id === assetId);
        assert(asset, `${item.label} generated asset is missing from library.`);
        assert(
          asset.type === 'image',
          `${item.label} generated asset should be an image.`
        );
      }
      assert(
        mock.requests.prompts.some((workflow) =>
          Object.values(workflow || {}).some(
            (node) => node?.class_type === 'TrueGrowthQwenImageGenerate'
          )
        ),
        'Mock ComfyUI did not receive the Qwen custom node workflow.'
      );
      assert(
        mock.requests.prompts.some((workflow) =>
          Object.values(workflow || {}).some(
            (node) => node?.class_type === 'CheckpointLoaderSimple'
          )
        ),
        'Mock ComfyUI did not receive the FLUX checkpoint workflow.'
      );
      console.log(
        JSON.stringify(
          {
            ok: true,
            mode: 'mock-comfyui',
            baseUrl: BASE_URL,
            comfyUiBaseUrl: MOCK_COMFYUI_BASE_URL,
            generated,
            promptCount: mock.requests.prompts.length,
            viewCount: mock.requests.views.length,
          },
          null,
          2
        )
      );
    } finally {
      if (child) child.kill('SIGTERM');
      if (mock) await new Promise((resolve) => mock.server.close(resolve));
      if (mockComfyUiDir) {
        fs.rmSync(mockComfyUiDir, { recursive: true, force: true });
      }
    }
    return;
  }
  let child = null;
  let stderr = '';
  try {
    if (!(await apiIsReady())) {
      child = spawn(process.execPath, ['scripts/truegrowth-local-api.mjs'], {
        cwd: ROOT,
        env: { ...process.env, TRUEGROWTH_LOCAL_API_PORT: String(PORT) },
        stdio: ['ignore', 'pipe', 'pipe'],
      });
      child.stderr.on('data', (chunk) => {
        stderr += String(chunk);
      });
    }
    try {
      await waitForApi();
    } catch (error) {
      if (/listen EPERM|EACCES|operation not permitted/i.test(stderr)) {
        throw new Error(
          `Local API could not listen on ${BASE_URL}. Current environment blocked localhost binding. Raw error: ${stderr.trim()}`
        );
      }
      throw error;
    }

    const setup = await requestJson(`${BASE_URL}/local-api/comfyui/setup`);
    const assets = await requestJson(
      `${BASE_URL}/local-api/aigcpanel/model-assets`
    );
    const templates = await requestJson(
      `${BASE_URL}/local-api/comfyui/templates`
    );
    const comfyModels = await requestJson(
      `${BASE_URL}/local-api/comfyui/models`
    );

    const imageAssets = Array.isArray(assets.items)
      ? assets.items.filter((item) => item.family === 'image')
      : [];
    const fluxAsset = imageAssets.find(
      (item) => item.id === 'flux-1-schnell-local'
    );
    const qwenAsset = imageAssets.find(
      (item) => item.id === 'qwen-image-local'
    );
    const installedImageModels = Array.isArray(assets.installedModels)
      ? assets.installedModels.filter((item) => item.family === 'image')
      : [];

    const fluxExists = fs.existsSync(FLUX_FILE);
    const qwenExists = fs.existsSync(QWEN_DIR);
    const fluxLoaded = Object.values(comfyModels.models || {})
      .flat()
      .includes('flux1-schnell-fp8.safetensors');
    const qwenLoaded = Object.values(comfyModels.models || {})
      .flat()
      .includes('Qwen-Image');

    assert(
      setup.setup?.vendorPath || setup.connection?.setup?.vendorPath,
      'ComfyUI setup payload is missing.'
    );
    assert(fluxAsset, 'FLUX model asset is missing from model center data.');
    assert(
      qwenAsset,
      'Qwen-Image model asset is missing from model center data.'
    );
    assert(
      fluxAsset.comfyUiDownload?.url?.includes('Comfy-Org/flux1-schnell'),
      'FLUX download URL is not wired to the ComfyUI official checkpoint.'
    );
    assert(
      fluxAsset.comfyUiDownload?.templateId ===
        'flux-fp8-checkpoint-text-to-image',
      'FLUX FP8 checkpoint is not wired to the dedicated ComfyUI workflow template.'
    );
    assert(
      fluxAsset.comfyUiDownload?.minFreeBytes >= 18 * 1024 ** 3,
      'FLUX download preflight does not require enough free disk space.'
    );
    assert(
      qwenAsset.comfyUiDownload?.repo === 'Qwen/Qwen-Image',
      'Qwen-Image download spec is not wired to the official Hugging Face repo.'
    );
    assert(
      qwenAsset.comfyUiDownload?.runnable === true,
      'Qwen-Image should be marked runnable because TrueGrowth installs a ComfyUI Qwen-Image node and workflow template.'
    );
    assert(
      qwenAsset.comfyUiDownload?.minFreeBytes >= 70 * 1024 ** 3,
      'Qwen-Image download preflight does not require enough free disk space.'
    );

    const availableBytes = diskAvailableBytes(COMFYUI_DIR);

    const result = {
      ok: true,
      localApi: BASE_URL,
      comfyUi: {
        installed: Boolean(setup.setup?.installed),
        running: Boolean(setup.connected),
        baseUrl: setup.setup?.baseUrl || setup.connection?.baseUrl,
        vendorPath:
          setup.setup?.vendorPath || setup.connection?.setup?.vendorPath,
        nodeCount: setup.connection?.nodeCount || 0,
      },
      models: {
        flux: {
          expectedPath: FLUX_FILE,
          officialRepo: 'https://huggingface.co/Comfy-Org/flux1-schnell',
          officialDownload:
            'https://huggingface.co/Comfy-Org/flux1-schnell/resolve/main/flux1-schnell-fp8.safetensors',
          expectedSize: bytesLabel(FLUX_EXPECTED_BYTES),
          requiredFreeSpace: bytesLabel(
            fluxAsset.comfyUiDownload?.minFreeBytes
          ),
          exists: fluxExists,
          size: fluxExists ? fileSizeLabel(FLUX_FILE) : null,
          loadedByComfyUi: fluxLoaded,
          assetInstalled: Boolean(fluxAsset.installed),
          serviceStatus: fluxAsset.installedModel?.service?.status || null,
        },
        qwenImage: {
          expectedPath: QWEN_DIR,
          officialRepo: 'https://huggingface.co/Qwen/Qwen-Image',
          expectedRepoSize: bytesLabel(QWEN_EXPECTED_BYTES),
          requiredFreeSpace: bytesLabel(
            qwenAsset.comfyUiDownload?.minFreeBytes
          ),
          exists: qwenExists,
          size: qwenExists ? qwenSizeLabel() : null,
          loadedByComfyUi: qwenLoaded,
          assetInstalled: Boolean(qwenAsset.installed),
          serviceStatus: qwenAsset.installedModel?.service?.status || null,
          runnable: qwenAsset.comfyUiDownload?.runnable !== false,
          note: qwenAsset.comfyUiDownload?.note || null,
        },
      },
      disk: {
        comfyUiDir: COMFYUI_DIR,
        available: bytesLabel(availableBytes),
        canDownloadFlux: Boolean(
          availableBytes &&
            availableBytes >=
              Number(fluxAsset.comfyUiDownload?.minFreeBytes || 0)
        ),
        canDownloadQwenImage: Boolean(
          availableBytes &&
            availableBytes >=
              Number(qwenAsset.comfyUiDownload?.minFreeBytes || 0)
        ),
      },
      modelCenter: {
        installedImageModelCount: installedImageModels.length,
        templates: Array.isArray(templates.items)
          ? templates.items.map((item) => ({
              id: item.id,
              available: item.available,
              modelChoices: item.modelChoices || [],
              missingNodes: item.missingNodes || [],
            }))
          : [],
      },
      nextSteps: [
        fluxExists
          ? 'FLUX 文件已在 ComfyUI 目录，启动 ComfyUI 后刷新模型中心并应用到生图。'
          : availableBytes &&
            availableBytes <
              Number(fluxAsset.comfyUiDownload?.minFreeBytes || 0)
          ? `当前磁盘可用约 ${bytesLabel(
              availableBytes
            )}，不足以下载 FLUX FP8。请先清理到至少 ${bytesLabel(
              fluxAsset.comfyUiDownload?.minFreeBytes
            )}。`
          : '在模型中心下载 FLUX，或把 flux1-schnell-fp8.safetensors 放入 models/checkpoints。',
        qwenExists
          ? 'Qwen-Image 已在 diffusers 目录；生成前确认已安装 Qwen-Image 专用 ComfyUI 节点或工作流。'
          : availableBytes &&
            availableBytes <
              Number(qwenAsset.comfyUiDownload?.minFreeBytes || 0)
          ? `当前磁盘可用约 ${bytesLabel(
              availableBytes
            )}，不足以下载 Qwen-Image。请先清理到至少 ${bytesLabel(
              qwenAsset.comfyUiDownload?.minFreeBytes
            )}。`
          : '如需中文海报能力，在模型中心下载 Qwen-Image 到 models/diffusers/Qwen-Image。',
      ],
    };

    console.log(JSON.stringify(result, null, 2));
    if (stderr.trim()) {
      console.error(stderr.trim());
    }
  } finally {
    if (child && !child.killed) {
      child.kill('SIGTERM');
    }
  }
}

main().catch((error) => {
  console.error(
    error instanceof Error ? error.stack || error.message : String(error)
  );
  process.exit(1);
});