@josephyan/qingflow-cli 0.2.0-beta.1000

package/README.md

@@ -0,0 +1,31 @@
+# Qingflow CLI
+
+Install:
+
+```bash
+npm install @josephyan/qingflow-cli@0.2.0-beta.1000
+```
+
+Run:
+
+```bash
+npx -y -p @josephyan/qingflow-cli@0.2.0-beta.1000 qingflow
+```
+
+Environment:
+
+- `QINGFLOW_MCP_DEFAULT_BASE_URL`
+- `QINGFLOW_MCP_DEFAULT_QF_VERSION`
+- `QINGFLOW_MCP_HOME`
+
+This package bootstraps a local Python runtime on first install and then starts the `qingflow` command line interface.
+
+Bundled skills:
+
+- none
+
+Note:
+
+- The skill files are included in the npm package.
+- On install, the package copies them to `$CODEX_HOME/skills` (or `~/.codex/skills` if `CODEX_HOME` is unset).
+- If a stdio MCP client reports `Transport closed`, delete `.npm-python`, reinstall the package, and make sure CLI/user/builder packages are on the same version. The stdio entrypoints refuse runtime bootstrap so install logs never corrupt MCP stdout.

package/docs/local-agent-install.md

@@ -0,0 +1,309 @@
+# 本地智能体安装
+
+这个目录下现在有三个本地命令入口：
+
+1. 统一 CLI：`qingflow`
+2. 记录/待办优先的 `qingflow-app-user-mcp`
+3. 精简 builder 的 `qingflow-app-builder-mcp`
+
+## 本地鉴权推荐方案
+
+本地模式现在推荐优先使用 `credential` 建立会话，而不是直接注入 `token`。
+
+推荐链路：
+
+1. createClaw 或其它本地宿主为当前实例保存 `credential`
+2. 本地 MCP 调用 `auth_use_credential`
+3. MCP 用该 `credential` 请求 apaas `/mcp/auth/context`
+4. 解析并保存 `token / wsId / qfVersion / uid`
+5. 业务工具直接使用这份上下文
+
+`auth_use_credential` 是本地唯一鉴权主路径。
+
+补充说明：
+
+- 对 stdio MCP 来说，主路径仍然只有 `auth_use_credential`。
+- 如果你是在终端里直接使用 `qingflow` CLI，可以额外使用 `qingflow auth login` 作为“人类登录”入口；默认会提示轻流邮箱和隐藏密码，拿到 `token` 后建立本地 CLI 会话。
+- 也就是说，这次新增的是 CLI 的登录入口，不是给 MCP 增加第二套会话模型。
+
+## npm 安装器适用场景
+
+适合这类本地 agent / gateway：
+
+- Claude Desktop
+- Cline / Roo / Cursor 这类本地 MCP 客户端
+- OpenClaw 风格的本地 agent 容器或本地 gateway
+- 任何支持 `command + args + env` 的 stdio MCP 客户端
+
+## 前置条件
+
+- Node.js >= 16.16
+- Python >= 3.11
+- 安装过程中可以访问 PyPI
+
+如果机器上没有默认 `python3` / `python`，可以先设置：
+
+```bash
+export QINGFLOW_MCP_PYTHON=/path/to/python3.11
+```
+
+## 安装方式
+
+### 方式 1：在源码目录预热运行环境
+
+```bash
+cd qingflow-support/mcp-server
+npm install
+```
+
+这个模式适合你已经有源码 checkout，只想让当前目录具备本地 agent 可调用的运行时。
+
+### 方式 2：全局安装到当前机器
+
+```bash
+cd qingflow-support/mcp-server
+npm install -g .
+```
+
+### 方式 3：安装到某个本地 agent workspace
+
+```bash
+npm install /absolute/path/to/qingflow-support/mcp-server
+```
+
+### 方式 4：离线分发 tgz 安装包
+
+先在源码目录打包：
+
+```bash
+cd qingflow-support/mcp-server
+npm run pack:npm
+```
+
+会生成：
+
+```bash
+dist/npm/qingflow-tech-qingflow-cli-<version>.tgz
+dist/npm/qingflow-tech-qingflow-app-user-mcp-<version>.tgz
+dist/npm/qingflow-tech-qingflow-app-builder-mcp-<version>.tgz
+```
+
+然后在目标机器安装：
+
+```bash
+npm install /absolute/path/to/dist/npm/qingflow-tech-qingflow-cli-<version>.tgz
+npm install /absolute/path/to/dist/npm/qingflow-tech-qingflow-app-user-mcp-<version>.tgz
+npm install /absolute/path/to/dist/npm/qingflow-tech-qingflow-app-builder-mcp-<version>.tgz
+```
+
+安装时会自动：
+
+1. 创建 `.npm-python/`
+2. 在其中建立 Python 虚拟环境
+3. 执行 `pip install .`
+4. 在安装位置暴露 `qingflow`、`qingflow-app-user-mcp`、`qingflow-app-builder-mcp` 命令
+
+## 本地验证
+
+如果你在源码目录执行了 `npm install`，可直接这样启动：
+
+```bash
+cd qingflow-support/mcp-server
+node ./npm/bin/qingflow.mjs --help
+node ./npm/bin/qingflow-app-user-mcp.mjs
+node ./npm/bin/qingflow-app-builder-mcp.mjs
+```
+
+如果你是全局安装：
+
+```bash
+qingflow --help
+qingflow-app-user-mcp
+qingflow-app-builder-mcp
+```
+
+如果你是把包安装到了某个本地 agent workspace，命令通常位于：
+
+```bash
+/absolute/path/to/agent-workspace/node_modules/.bin/qingflow
+/absolute/path/to/agent-workspace/node_modules/.bin/qingflow-app-user-mcp
+/absolute/path/to/agent-workspace/node_modules/.bin/qingflow-app-builder-mcp
+```
+
+如果你是从 tgz 安装到某个空目录，命令通常位于：
+
+```bash
+/absolute/path/to/install-dir/node_modules/.bin/qingflow
+/absolute/path/to/install-dir/node_modules/.bin/qingflow-app-user-mcp
+/absolute/path/to/install-dir/node_modules/.bin/qingflow-app-builder-mcp
+```
+
+这是 stdio MCP server，正常情况下不会输出欢迎信息，而是等待客户端连接。
+
+## 客户端配置
+
+### 通用 stdio MCP 客户端
+
+如果你直接使用源码 checkout：
+
+```json
+{
+  "mcpServers": {
+    "qingflow": {
+      "command": "node",
+      "args": [
+        "/absolute/path/to/qingflow-support/mcp-server/npm/bin/qingflow-app-user-mcp.mjs"
+      ],
+      "env": {
+        "QINGFLOW_MCP_DEFAULT_BASE_URL": "https://qingflow.com/api",
+        "QINGFLOW_MCP_HOME": "/absolute/path/to/.qingflow-mcp",
+        "QINGFLOW_MCP_CREDIT_METER_ENABLED": "true",
+        "QINGFLOW_MCP_CREDIT_APAAS_BASE_URL": "https://apaas.internal.example.com",
+        "QINGFLOW_MCP_CREDIT_APAAS_PATH": "/user/credit/usage"
+      }
+    }
+  }
+}
+```
+
+如果你已经全局安装：
+
+```json
+{
+  "mcpServers": {
+    "qingflow": {
+      "command": "qingflow-app-user-mcp",
+      "args": [],
+      "env": {
+        "QINGFLOW_MCP_DEFAULT_BASE_URL": "https://qingflow.com/api",
+        "QINGFLOW_MCP_HOME": "/absolute/path/to/.qingflow-mcp",
+        "QINGFLOW_MCP_CREDIT_METER_ENABLED": "true",
+        "QINGFLOW_MCP_CREDIT_APAAS_BASE_URL": "https://apaas.internal.example.com",
+        "QINGFLOW_MCP_CREDIT_APAAS_PATH": "/user/credit/usage"
+      }
+    }
+  }
+}
+```
+
+如果你把包安装到了某个本地 agent workspace：
+
+```json
+{
+  "mcpServers": {
+    "qingflow": {
+      "command": "/absolute/path/to/agent-workspace/node_modules/.bin/qingflow-app-user-mcp",
+      "args": [],
+      "env": {
+        "QINGFLOW_MCP_DEFAULT_BASE_URL": "https://qingflow.com/api",
+        "QINGFLOW_MCP_HOME": "/absolute/path/to/.qingflow-mcp",
+        "QINGFLOW_MCP_CREDIT_METER_ENABLED": "true",
+        "QINGFLOW_MCP_CREDIT_APAAS_BASE_URL": "https://apaas.internal.example.com",
+        "QINGFLOW_MCP_CREDIT_APAAS_PATH": "/user/credit/usage"
+      }
+    }
+  }
+}
+```
+
+### 使用 npx
+
+如果不做全局安装，也可以直接运行独立包：
+
+```json
+{
+  "mcpServers": {
+    "qingflow-user": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@josephyan/qingflow-app-user-mcp"
+      ],
+      "env": {
+        "QINGFLOW_MCP_DEFAULT_BASE_URL": "https://qingflow.com/api",
+        "QINGFLOW_MCP_CREDIT_METER_ENABLED": "true",
+        "QINGFLOW_MCP_CREDIT_APAAS_BASE_URL": "https://apaas.internal.example.com",
+        "QINGFLOW_MCP_CREDIT_APAAS_PATH": "/user/credit/usage"
+      }
+    },
+    "qingflow-builder": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@josephyan/qingflow-app-builder-mcp"
+      ],
+      "env": {
+        "QINGFLOW_MCP_DEFAULT_BASE_URL": "https://qingflow.com/api",
+        "QINGFLOW_MCP_CREDIT_METER_ENABLED": "true",
+        "QINGFLOW_MCP_CREDIT_APAAS_BASE_URL": "https://apaas.internal.example.com",
+        "QINGFLOW_MCP_CREDIT_APAAS_PATH": "/user/credit/usage"
+      }
+    }
+  }
+}
+```
+
+说明：
+- 源码目录 `npm install` 不会把命令加到全局 PATH；这种模式请用 `node ./npm/bin/qingflow.mjs`、`node ./npm/bin/qingflow-app-user-mcp.mjs` 或 `node ./npm/bin/qingflow-app-builder-mcp.mjs`
+- `npx` 方式适合临时安装或容器化本地 agent
+- 全局安装方式更适合长期固定使用的本机开发环境
+- 计费接口使用当前登录会话的 `token` 与 `wsId` 请求头，可通过 `QINGFLOW_MCP_CREDIT_APAAS_BASE_URL/PATH` 覆盖调用记录接口地址
+
+## 排障
+
+如果安装失败，优先检查：
+
+1. `node -v`
+2. `python3 --version`
+3. `pip` 是否能访问 PyPI
+4. 是否设置了错误的 `QINGFLOW_MCP_PYTHON`
+
+如果需要重装 Python 侧运行环境，可以删掉：
+
+```bash
+rm -rf .npm-python
+```
+
+然后重新执行：
+
+```bash
+npm install
+```
+
+如果 MCP 客户端一调用工具就报 `Transport closed`，优先检查这几件事：
+
+1. 不要混用不同版本的 `@josephyan/qingflow-cli`、`@josephyan/qingflow-app-user-mcp`、`@josephyan/qingflow-app-builder-mcp`
+2. 删除安装目录下的 `.npm-python`
+3. 重新执行 `npm install` 或重新安装对应 tgz/npm 包
+4. 再启动 MCP 客户端
+
+现在 stdio MCP 入口会拒绝在启动瞬间“边启动边重建 Python 运行时”，因为安装日志一旦写进 stdout，就会破坏 MCP 握手并表现成 `Transport closed`。如果运行时缺失或版本不一致，入口会直接报错并提示重装，而不是静默自修复。
+
+## createClaw 本地接入示例
+
+如果 createClaw 已经为当前本地实例保存了 `credential`，推荐在首次建链时调用：
+
+```bash
+qingflow auth use-credential \
+  --base-url https://qingflow.com/api \
+  --credential-stdin
+```
+
+然后把 `credential` 写到 stdin。
+
+等价 MCP 工具调用参数：
+
+```json
+{
+  "profile": "default",
+  "base_url": "https://qingflow.com/api",
+  "credential": "1602853_277941",
+  "persist": false
+}
+```
+
+说明：
+
+- 本地会把解析后的 `token` 和原始 `credential` 写入 profile 文件，用于后续 CLI 命令恢复会话
+- `persist=true` 时，本地还会优先把解析后的 `token` 和原始 `credential` 同步写入系统 keychain
+- 当前工作区以 `/mcp/auth/context` 返回的 `wsId` 为准，不再通过本地 MCP 显式切换

package/entry_point.py

@@ -0,0 +1,13 @@
+import sys
+import os
+
+# Ensure the 'src' directory is in the Python search path
+# PyInstaller will pick up everything in src/qingflow_mcp as the package
+src_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "src"))
+if src_path not in sys.path:
+    sys.path.insert(0, src_path)
+
+from qingflow_mcp.server import main
+
+if __name__ == "__main__":
+    main()

package/npm/bin/qingflow.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { spawnServer, getPackageRoot } from "../lib/runtime.mjs";
+
+const packageRoot = getPackageRoot(import.meta.url);
+spawnServer(packageRoot, process.argv.slice(2), "qingflow", { allowRuntimeBootstrap: true, stdio: "inherit" });

package/npm/lib/runtime.mjs

@@ -0,0 +1,346 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const WINDOWS = process.platform === "win32";
+
+function runChecked(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    ...options,
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    const details = [result.stderr, result.stdout].filter((value) => typeof value === "string" && value.trim()).join("\n");
+    throw new Error(details ? `Command failed: ${command} ${args.join(" ")}\n${details}` : `Command failed: ${command} ${args.join(" ")}`);
+  }
+}
+
+function commandWorks(command, args) {
+  const result = spawnSync(command, args, {
+    stdio: "ignore",
+  });
+  return result.status === 0;
+}
+
+export function getPackageRoot(metaUrl) {
+  return path.resolve(path.dirname(fileURLToPath(metaUrl)), "..", "..");
+}
+
+export function getCodexHome() {
+  const configured = process.env.CODEX_HOME?.trim();
+  if (configured) {
+    return path.resolve(configured);
+  }
+  const home = process.env.HOME || process.env.USERPROFILE;
+  if (!home) {
+    throw new Error("Cannot resolve CODEX_HOME because HOME is not set.");
+  }
+  return path.join(home, ".codex");
+}
+
+export function installBundledSkills(packageRoot) {
+  const skillsSrc = path.join(packageRoot, "skills");
+  if (!fs.existsSync(skillsSrc)) {
+    return { installed: [], skipped: true, destination: null };
+  }
+
+  const codexHome = getCodexHome();
+  const skillsDestRoot = path.join(codexHome, "skills");
+  fs.mkdirSync(skillsDestRoot, { recursive: true });
+
+  const installed = [];
+  for (const entry of fs.readdirSync(skillsSrc, { withFileTypes: true })) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const src = path.join(skillsSrc, entry.name);
+    const dest = path.join(skillsDestRoot, entry.name);
+    fs.rmSync(dest, { recursive: true, force: true });
+    fs.cpSync(src, dest, { recursive: true });
+    installed.push(entry.name);
+  }
+
+  return { installed, skipped: false, destination: skillsDestRoot };
+}
+
+export function getVenvDir(packageRoot) {
+  return path.join(packageRoot, ".npm-python");
+}
+
+export function getVenvPython(packageRoot) {
+  return WINDOWS
+    ? path.join(getVenvDir(packageRoot), "Scripts", "python.exe")
+    : path.join(getVenvDir(packageRoot), "bin", "python");
+}
+
+export function getVenvServerCommand(packageRoot, commandName = "qingflow-mcp") {
+  return WINDOWS
+    ? path.join(getVenvDir(packageRoot), "Scripts", `${commandName}.exe`)
+    : path.join(getVenvDir(packageRoot), "bin", commandName);
+}
+
+function readPackageVersion(packageRoot) {
+  const packageJsonPath = path.join(packageRoot, "package.json");
+  try {
+    const payload = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    return typeof payload.version === "string" && payload.version.trim() ? payload.version.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+function readBootstrapStamp(stampPath) {
+  if (!fs.existsSync(stampPath)) {
+    return { exists: false, version: null };
+  }
+  try {
+    const payload = JSON.parse(fs.readFileSync(stampPath, "utf8"));
+    const version = typeof payload.package_version === "string" && payload.package_version.trim() ? payload.package_version.trim() : null;
+    return { exists: true, version };
+  } catch {
+    return { exists: true, version: null };
+  }
+}
+
+export function inspectPythonEnv(packageRoot, commandName = "qingflow-mcp") {
+  const venvDir = getVenvDir(packageRoot);
+  const serverCommand = getVenvServerCommand(packageRoot, commandName);
+  const stampPath = path.join(venvDir, ".bootstrap.json");
+  const packageVersion = readPackageVersion(packageRoot);
+  const stamp = readBootstrapStamp(stampPath);
+  const problems = [];
+
+  if (!packageVersion) {
+    problems.push("package-version-missing");
+  }
+  if (!fs.existsSync(serverCommand)) {
+    problems.push("server-command-missing");
+  }
+  if (!stamp.exists) {
+    problems.push("bootstrap-stamp-missing");
+  } else if (!stamp.version) {
+    problems.push("bootstrap-stamp-invalid");
+  } else if (packageVersion && stamp.version !== packageVersion) {
+    problems.push("bootstrap-version-mismatch");
+  }
+
+  return {
+    ready: problems.length === 0,
+    packageVersion,
+    stampVersion: stamp.version,
+    stampExists: stamp.exists,
+    stampPath,
+    serverCommand,
+    venvDir,
+    problems,
+  };
+}
+
+function formatRuntimeProblem(runtime, commandName, { allowRuntimeBootstrap = false } = {}) {
+  const problemLines = [];
+  for (const problem of runtime.problems) {
+    switch (problem) {
+      case "package-version-missing":
+        problemLines.push("- package.json is missing a valid version field");
+        break;
+      case "server-command-missing":
+        problemLines.push(`- missing Python entrypoint: ${runtime.serverCommand}`);
+        break;
+      case "bootstrap-stamp-missing":
+        problemLines.push(`- missing bootstrap stamp: ${runtime.stampPath}`);
+        break;
+      case "bootstrap-stamp-invalid":
+        problemLines.push(`- bootstrap stamp is unreadable or invalid: ${runtime.stampPath}`);
+        break;
+      case "bootstrap-version-mismatch":
+        problemLines.push(
+          `- bootstrap version mismatch: package=${runtime.packageVersion ?? "unknown"}, runtime=${runtime.stampVersion ?? "unknown"}`
+        );
+        break;
+      default:
+        problemLines.push(`- ${problem}`);
+        break;
+    }
+  }
+
+  const action = allowRuntimeBootstrap
+    ? "Delete .npm-python and retry, or rerun npm install to rebuild the embedded Python runtime."
+    : "Delete .npm-python and rerun npm install, or reinstall the npm package before starting the MCP server.";
+
+  const bootstrapNote = allowRuntimeBootstrap
+    ? ""
+    : "\nRuntime bootstrap is disabled for stdio MCP entrypoints so install logs can never corrupt the MCP stdout transport.";
+
+  return [
+    `[qingflow-mcp] Python runtime for ${commandName} is not ready.`,
+    ...problemLines,
+    action + bootstrapNote,
+  ].join("\n");
+}
+
+function getVenvPip(packageRoot) {
+  return WINDOWS
+    ? path.join(getVenvDir(packageRoot), "Scripts", "pip.exe")
+    : path.join(getVenvDir(packageRoot), "bin", "pip");
+}
+
+export function findPython() {
+  const preferred = process.env.QINGFLOW_MCP_PYTHON?.trim();
+  const candidates = preferred
+    ? [{ command: preferred, args: [], label: preferred }]
+    : WINDOWS
+      ? [
+          { command: "py", args: ["-3", "-V"], label: "py -3" },
+          { command: "python", args: ["-V"], label: "python" },
+          { command: "python3", args: ["-V"], label: "python3" },
+        ]
+      : [
+          { command: "python3", args: ["-V"], label: "python3" },
+          { command: "python", args: ["-V"], label: "python" },
+        ];
+
+  for (const candidate of candidates) {
+    if (commandWorks(candidate.command, candidate.args)) {
+      if (candidate.command === "py") {
+        return { command: "py", args: ["-3"], label: candidate.label };
+      }
+      return { command: candidate.command, args: [], label: candidate.label };
+    }
+  }
+
+  throw new Error(
+    "Python 3.11+ was not found. Set QINGFLOW_MCP_PYTHON to a Python 3 executable before running npm install."
+  );
+}
+
+export function ensurePythonEnv(packageRoot, { force = false, commandName = "qingflow-mcp" } = {}) {
+  const python = findPython();
+  const runtime = inspectPythonEnv(packageRoot, commandName);
+  const venvPython = getVenvPython(packageRoot);
+  const { packageVersion, serverCommand, stampPath, venvDir, stampVersion } = runtime;
+
+  if (!force && fs.existsSync(serverCommand) && fs.existsSync(stampPath) && stampVersion && stampVersion === packageVersion) {
+    return serverCommand;
+  }
+
+  if (force && fs.existsSync(venvDir)) {
+    fs.rmSync(venvDir, { recursive: true, force: true });
+  }
+
+  if (!fs.existsSync(venvPython)) {
+    runChecked(python.command, [...python.args, "-m", "venv", venvDir], { cwd: packageRoot });
+  }
+
+  const pip = getVenvPip(packageRoot);
+  runChecked(pip, ["install", "--disable-pip-version-check", "."], { cwd: packageRoot });
+
+  fs.writeFileSync(
+    stampPath,
+    JSON.stringify(
+      {
+        installed_at: new Date().toISOString(),
+        installer: "npm",
+        package_version: packageVersion,
+      },
+      null,
+      2
+    )
+  );
+
+  if (!fs.existsSync(serverCommand)) {
+    throw new Error(`Bootstrap finished but ${serverCommand} was not created.`);
+  }
+
+  return serverCommand;
+}
+
+function proxyStreams(child) {
+  if (process.stdin.readable && child.stdin) {
+    process.stdin.pipe(child.stdin);
+    child.stdin.on("error", (error) => {
+      if (error.code !== "EPIPE") {
+        console.error(`[qingflow-mcp] Failed to forward stdin: ${error.message}`);
+      }
+    });
+  } else if (child.stdin) {
+    child.stdin.end();
+  }
+
+  if (child.stdout) {
+    child.stdout.pipe(process.stdout);
+  }
+  if (child.stderr) {
+    child.stderr.pipe(process.stderr);
+  }
+}
+
+function forwardSignal(child, signal) {
+  process.on(signal, () => {
+    if (!child.killed) {
+      child.kill(signal);
+    }
+  });
+}
+
+export function spawnServer(
+  packageRoot,
+  args,
+  commandName = "qingflow-mcp",
+  { allowRuntimeBootstrap = false, stdio = "proxy" } = {},
+) {
+  let runtime = inspectPythonEnv(packageRoot, commandName);
+  let serverCommand = runtime.serverCommand;
+
+  if (!runtime.ready) {
+    if (!allowRuntimeBootstrap) {
+      console.error(formatRuntimeProblem(runtime, commandName, { allowRuntimeBootstrap }));
+      process.exit(1);
+      return;
+    }
+
+    try {
+      serverCommand = ensurePythonEnv(packageRoot, { commandName });
+      runtime = inspectPythonEnv(packageRoot, commandName);
+    } catch (error) {
+      console.error(`[qingflow-mcp] Failed to prepare Python runtime for ${commandName}: ${error.message}`);
+      process.exit(1);
+      return;
+    }
+
+    if (!runtime.ready) {
+      console.error(formatRuntimeProblem(runtime, commandName, { allowRuntimeBootstrap }));
+      process.exit(1);
+      return;
+    }
+  }
+
+  const child = spawn(serverCommand, args, {
+    stdio: stdio === "inherit" ? "inherit" : ["pipe", "pipe", "pipe"],
+    env: process.env,
+    windowsHide: true,
+  });
+
+  if (stdio !== "inherit") {
+    proxyStreams(child);
+  }
+  forwardSignal(child, "SIGINT");
+  forwardSignal(child, "SIGTERM");
+
+  child.on("close", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code ?? 0);
+  });
+
+  child.on("error", (error) => {
+    console.error(`[qingflow-mcp] Failed to start server: ${error.message}`);
+    process.exit(1);
+  });
+}