mnote/scripts/desktop-hot.js

#!/usr/bin/env node

/**
 * 同时热启动前端、FastAPI 与 Celery。
 * 可使用以下环境变量调整行为：
 * - FRONTEND_CMD：覆盖前端启动命令，默认为 "pnpm dev"
 * - BACKEND_CMD：覆盖 FastAPI 启动命令，默认为 "python -m uvicorn app.main:app --reload --port 8000"
 * - CELERY_CMD：覆盖 Celery 启动命令，默认为 "celery -A app.workers.celery_app worker --loglevel=info"
 * - PYTHON_BIN：只在 BACKEND_CMD 未覆盖时，设置 Python 可执行文件，默认 "python"
 * - CELERY_BIN：只在 CELERY_CMD 未覆盖时，设置 Celery 可执行文件，默认 "celery"
 * - REDIS_URL：仅用于探测 Redis 是否就绪，默认 "redis://localhost:6379/0"
 * - SKIP_CELERY：设为 "1" or "true" 可跳过 Celery。
 */

const { spawn } = require("child_process");
const path = require("path");
const net = require("net");
const { URL } = require("url");
const fs = require("fs");

const rootDir = path.resolve(__dirname, "..");
const frontendDir = path.join(rootDir, "wolai-frontend");
const backendDir = path.join(rootDir, "wolai-backend");
const mineruDir = path.join(rootDir, "services", "mineru");
const baseEnv = { ...process.env };
const frontendEnv = { ...baseEnv };
const backendEnv = { ...baseEnv };
const mineruEnv = { ...baseEnv };

function loadEnvFile(filePath, targetEnv, { overrideSupabase = false } = {}) {
  if (!fs.existsSync(filePath)) {
    return;
  }
  const content = fs.readFileSync(filePath, "utf8");
  content.split(/\r?\n/).forEach((line) => {
    const trimmed = line.trim();
    if (!trimmed || trimmed.startsWith("#")) return;
    const eqIndex = trimmed.indexOf("=");
    if (eqIndex <= 0) return;
    const key = trimmed.slice(0, eqIndex).trim();
    const value = trimmed.slice(eqIndex + 1).trim();
    const hasValue = Boolean(targetEnv[key]);
    const shouldForce =
      overrideSupabase && key.startsWith("SUPABASE_") && (!hasValue || targetEnv[key].includes("supabase.co"));
    if (!hasValue || shouldForce) {
      targetEnv[key] = value;
    }
  });
}

// 强制后端优先使用本地 .env 中的 Supabase 配置，避免系统环境变量指向线上实例。
loadEnvFile(path.join(backendDir, ".env"), backendEnv, { overrideSupabase: true });
loadEnvFile(path.join(rootDir, ".env.local"), backendEnv);
loadEnvFile(path.join(rootDir, ".env.local"), frontendEnv);
loadEnvFile(path.join(rootDir, ".env.local"), mineruEnv);

function resolvePythonBin() {
  const suffixes =
    process.platform === "win32"
      ? [
          ["venv", "Scripts", "python.exe"],
          [".venv", "Scripts", "python.exe"],
        ]
      : [
          ["venv", "bin", "python3"],
          ["venv", "bin", "python"],
          [".venv", "bin", "python3"],
          [".venv", "bin", "python"],
        ];
  const candidates = suffixes.map((parts) => path.join(backendDir, ...parts));
  for (const candidate of candidates) {
    if (fs.existsSync(candidate)) {
      return candidate;
    }
  }
  return null;
}

const pythonBin = process.env.PYTHON_BIN || resolvePythonBin() || "python";
const celeryBin = process.env.CELERY_BIN || "celery";
const skipCelery =
  (process.env.SKIP_CELERY || "").toLowerCase() === "1" ||
  (process.env.SKIP_CELERY || "").toLowerCase() === "true";
const celeryCmdFromEnv = process.env.CELERY_CMD;
const redisUrl = process.env.REDIS_URL || "redis://localhost:6379/0";

const tasks = [
  {
    name: "frontend",
    command: process.env.FRONTEND_CMD || "pnpm dev",
    cwd: frontendDir,
    env: frontendEnv,
  },
  {
    name: "backend",
    command:
      process.env.BACKEND_CMD ||
      `${pythonBin} -m uvicorn app.main:app --reload --port 8000`,
    cwd: backendDir,
    env: backendEnv,
  },
];

function resolveMineru() {
  // 优先使用带 ROCm 的全局 venv，找不到再回退 services/mineru/.venv
  const rocmPython = path.join("F:\\", "rocm", ".venv-rocm312", "Scripts", "python.exe");
  const localVenvPython = path.join(mineruDir, ".venv", "Scripts", "python.exe");
  const pythonCandidates = [rocmPython, localVenvPython].filter((p) => fs.existsSync(p));
  const venvPython = pythonCandidates[0];
  const srcDir = path.join(mineruDir, "src");
  if (!venvPython || !fs.existsSync(srcDir)) {
    logPrefix(
      "mineru",
      "未找到 MinerU 虚拟环境或源码，已跳过自动启动。请先运行 services/mineru/setup.ps1",
    );
    return null;
  }
  const endpoint = mineruEnv.MINERU_ENDPOINT || "http://127.0.0.1:18888";
  const url = new URL(endpoint);
  const host = url.hostname || "127.0.0.1";
  const port = url.port || "18888";
  const command =
    process.env.MINERU_CMD ||
    `${venvPython} -m uvicorn mineru.cli.fast_api:app --host ${host} --port ${port}`;
  const modelPath = path.join(mineruDir, "models", "MinerU2.5-2509-1.2B");
  const configPath = path.join(mineruDir, "mineru.json");
  return {
    name: "mineru",
    command,
    cwd: srcDir,
    env: {
      ...mineruEnv,
      PYTHONPATH: srcDir,
      MINERU_ENDPOINT: endpoint,
       // 默认使用本地 VLM 模型
      MINERU_TOOLS_CONFIG_JSON: configPath,
      MINERU_MODEL_SOURCE: "local",
      MINERU_MODEL_PATH: modelPath,
      MINERU_DEFAULT_BACKEND: "vlm-transformers",
      MINERU_TIMEOUT_SECONDS: mineruEnv.MINERU_TIMEOUT_SECONDS || "600",
    },
  };
}

const mineruTask = resolveMineru();
if (mineruTask) {
  tasks.unshift(mineruTask);
  backendEnv.MINERU_ENDPOINT = mineruTask.env.MINERU_ENDPOINT;
}

console.log(`[system] Python 解释器：${pythonBin}`);

const children = [];
let shuttingDown = false;

function logPrefix(name, message) {
  console.log(`[${name}] ${message}`);
}

function startTask(task) {
  logPrefix(task.name, `启动命令：${task.command}`);
  const child = spawn(task.command, {
    cwd: task.cwd,
    stdio: "inherit",
    shell: true,
    env: task.env ? { ...task.env } : { ...process.env },
  });

  child.on("exit", (code, signal) => {
    if (shuttingDown) {
      return;
    }
    const status =
      signal !== null ? `因信号 ${signal} 退出` : `退出码 ${code ?? "null"}`;
    logPrefix(task.name, `进程结束（${status}），准备清理其它任务。`);
    shutdown(code ?? 0);
  });

  child.on("error", (err) => {
    logPrefix(task.name, `启动失败：${err.message}`);
    shutdown(1);
  });

  children.push(child);
}

function shutdown(code) {
  if (shuttingDown) {
    return;
  }
  shuttingDown = true;
  logPrefix("system", "收到终止信号，正在关闭所有子进程…");

  for (const child of children) {
    if (!child.killed) {
      child.kill("SIGINT");
      setTimeout(() => {
        if (!child.killed) {
          child.kill("SIGTERM");
        }
      }, 5000);
    }
  }

  setTimeout(() => process.exit(code), 200);
}

process.on("SIGINT", () => shutdown(0));
process.on("SIGTERM", () => shutdown(0));

async function checkRedisReachable(urlString, timeoutMs = 2000) {
  try {
    const url = new URL(urlString);
    const host = url.hostname || "localhost";
    const port = Number(url.port) || 6379;

    return await new Promise((resolve) => {
      const socket = net.createConnection({ host, port });
      const timer = setTimeout(() => {
        socket.destroy();
        resolve(false);
      }, timeoutMs);

      socket.once("connect", () => {
        clearTimeout(timer);
        socket.end();
        resolve(true);
      });

      socket.once("error", () => {
        clearTimeout(timer);
        resolve(false);
      });
    });
  } catch (error) {
    logPrefix("celery", `REDIS_URL (${urlString}) 解析失败：${error.message}，跳过连通性检查。`);
    return true;
  }
}

async function main() {
  let celeryScheduled = false;
  if (!skipCelery) {
    const celeryTask = {
      name: "celery",
      command: celeryCmdFromEnv || `${celeryBin} -A app.workers.celery_app worker --loglevel=info`,
      cwd: backendDir,
    };

    if (celeryCmdFromEnv) {
      tasks.push(celeryTask);
      celeryScheduled = true;
    } else if (await checkRedisReachable(redisUrl)) {
      tasks.push(celeryTask);
      celeryScheduled = true;
    } else {
      // Redis 未就绪时直接跳过 Celery，避免热调试流程整体退出。
      logPrefix(
        "celery",
        `检测到 ${redisUrl} 无法连接，自动跳过 Celery。请先启动 Redis 或设置 SKIP_CELERY=1 显式跳过。`,
      );
    }
  }

  if (!celeryScheduled) {
    backendEnv.CELERY_TASK_ALWAYS_EAGER = "1";
    backendEnv.CELERY_TASK_EAGER_PROPAGATES = backendEnv.CELERY_TASK_EAGER_PROPAGATES || "1";
    logPrefix(
      "backend",
      "未启动 Celery，自动启用 task_always_eager 模式用于同步执行后台任务。",
    );
  }

  if (tasks.length === 0) {
    console.error("未配置任何可运行的任务，检查环境变量设置。");
    process.exit(1);
  }

  for (const task of tasks) {
    startTask(task);
  }
}

main().catch((error) => {
  logPrefix("system", `启动失败：${error.message}`);
  process.exit(1);
});