project-runner 0.1.2 → 0.3.0

package/README.md

@@ -104,10 +104,35 @@ pr info
 |------|------|
 | `-v, --verbose` | 显示详细检测过程 |
 | `-d, --dir <path>` | 指定项目目录（默认：当前目录）|
+| `-i, --install` | 强制执行依赖安装 |
 | `--no-install` | 跳过依赖安装步骤 |
+| `-e, --entry <name>` | 指定 MPA 入口（也可用 `PR_ENTRY`） |
 | `-h, --help` | 显示帮助信息 |
 | `-V, --version` | 显示版本号 |
 
+## MPA 项目支持
+
+`pr run` 会自动检测是否存在 `dev:<entry>` 形式的多入口脚本。
+
+- 在交互终端中：自动弹出入口列表并让你选择。
+- 在 CI / 非交互环境中：按优先级选择入口
+  1. `--entry <name>`
+  2. `PR_ENTRY=<name>`
+  3. `.pr.local.json` 中的 `defaultEntry`
+  4. 若仍无法确定则报错并提示可选入口
+
+本地配置文件（推荐）：
+
+```json
+{
+  "entries": ["main", "formengine", "design", "approve"],
+  "defaultEntry": "main"
+}
+```
+
+- 文件名固定：`.pr.local.json`
+- 当该文件存在时，`pr` 会自动确保 `.gitignore` 包含 `.pr.local.json`
+
 ## 示例输出
 
 ### `pr info`

package/dist/index.js

@@ -17,6 +17,13 @@ var colors = {
   white: "\x1B[37m",
   gray: "\x1B[90m"
 };
+var CliError = class extends Error {
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CliError";
+  }
+};
 var isVerbose = false;
 function setVerbose(verbose) {
   isVerbose = verbose;
@@ -74,6 +81,34 @@ async function execute(cmd, options = {}) {
     });
   });
 }
+async function executeCapture(cmd, options = {}) {
+  const { cwd = process.cwd(), env } = options;
+  return new Promise((resolve2, reject) => {
+    const isWindows = process.platform === "win32";
+    const command = cmd[0] || "";
+    const args = cmd.slice(1);
+    const proc = spawn(command, args, {
+      cwd,
+      env: { ...process.env, ...env },
+      shell: isWindows,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      resolve2({ stdout, stderr, exitCode: code ?? 0 });
+    });
+    proc.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
 function setupSignalHandlers() {
   process.on("SIGINT", () => {
     if (currentProcess) {
@@ -89,13 +124,36 @@ function setupSignalHandlers() {
   });
 }
 
+// src/cli/run.ts
+import { createInterface as createInterface2 } from "node:readline/promises";
+
 // src/analyzer/index.ts
-import { readFile as readFile3, stat as stat4 } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import { join as join4 } from "path";
 
 // src/analyzer/package-manager.ts
-import { readFile, stat } from "fs/promises";
 import { join } from "path";
+
+// src/utils/fs.ts
+import { stat } from "fs/promises";
+async function fileExists(path) {
+  try {
+    const stats = await stat(path);
+    return stats.isFile();
+  } catch {
+    return false;
+  }
+}
+async function directoryExists(path) {
+  try {
+    const stats = await stat(path);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/analyzer/package-manager.ts
 var LOCKFILE_MAP = {
   "bun.lockb": "bun",
   "bun.lock": "bun",
@@ -103,9 +161,7 @@ var LOCKFILE_MAP = {
   "yarn.lock": "yarn",
   "package-lock.json": "npm"
 };
-async function detectPackageManager(projectDir) {
-  const packageJsonPath = join(projectDir, "package.json");
-  const packageJson = await readPackageJson(packageJsonPath);
+async function detectPackageManager(projectDir, packageJson) {
   if (!packageJson) {
     return { name: "npm", source: "default" };
   }
@@ -164,46 +220,18 @@ function getInstallCommand(pm) {
       return ["npm", "install"];
   }
 }
-async function fileExists(path) {
-  try {
-    const stats = await stat(path);
-    return stats.isFile();
-  } catch {
-    return false;
-  }
-}
-async function readPackageJson(path) {
-  try {
-    const content = await readFile(path, "utf-8");
-    return JSON.parse(content);
-  } catch {
-  }
-  return null;
-}
 
 // src/analyzer/scripts.ts
-import { readFile as readFile2, stat as stat2 } from "fs/promises";
-import { join as join2 } from "path";
 var DEV_PATTERNS = ["dev", "serve", "start:dev", "develop", "watch"];
 var TEST_PATTERNS = ["test", "test:unit", "test:all", "spec"];
 var BUILD_PATTERNS = ["build", "compile", "bundle", "dist"];
-var START_PATTERNS = ["start", "serve", "preview", "production"];
-async function fileExists2(path) {
-  try {
-    const stats = await stat2(path);
-    return stats.isFile();
-  } catch {
-    return false;
+var START_PATTERNS = ["start", "preview", "production"];
+var STANDARD_TYPES = ["dev", "test", "build", "start"];
+function analyzeScripts(packageJson, localConfig) {
+  if (!packageJson) {
+    return null;
   }
-}
-async function analyzeScripts(projectDir) {
-  const packageJsonPath = join2(projectDir, "package.json");
   try {
-    if (!await fileExists2(packageJsonPath)) {
-      return null;
-    }
-    const content = await readFile2(packageJsonPath, "utf-8");
-    const packageJson = JSON.parse(content);
     const scripts = packageJson.scripts || {};
     const detected = {
       dev: findMatchingScript(scripts, DEV_PATTERNS),
@@ -211,11 +239,81 @@ async function analyzeScripts(projectDir) {
       build: findMatchingScript(scripts, BUILD_PATTERNS),
       start: findMatchingScript(scripts, START_PATTERNS)
     };
-    return { scripts, detected };
+    const mpa = analyzeMpa(packageJson, scripts, localConfig);
+    return { scripts, detected, mpa };
   } catch {
     return null;
   }
 }
+function analyzeMpa(packageJson, scripts, localConfig) {
+  const configuredEntriesFromLocal = normalizeEntryList(localConfig?.entries);
+  const configuredEntriesFromPackage = normalizeEntryList(packageJson?.pr?.entries);
+  const configuredEntries = configuredEntriesFromLocal.length > 0 ? configuredEntriesFromLocal : configuredEntriesFromPackage;
+  const scriptEntries = collectEntriesByPrefix(scripts, "dev");
+  let entries = configuredEntries.length > 0 ? configuredEntries : scriptEntries;
+  let source = "scripts";
+  if (configuredEntriesFromLocal.length > 0) {
+    source = "local-config";
+  } else if (configuredEntriesFromPackage.length > 0) {
+    source = "package-json";
+  }
+  const defaultEntry = normalizeEntryName(localConfig?.defaultEntry ?? packageJson?.pr?.defaultEntry);
+  if (defaultEntry && !entries.includes(defaultEntry) && scripts[`dev:${defaultEntry}`]) {
+    entries = [...entries, defaultEntry];
+  }
+  entries = dedupe(entries);
+  if (entries.length === 0) {
+    source = "none";
+  }
+  const scriptsByType = {};
+  for (const type of STANDARD_TYPES) {
+    const mapping = {};
+    for (const entry of entries) {
+      const scriptName = `${type}:${entry}`;
+      if (scripts[scriptName]) {
+        mapping[entry] = scriptName;
+      }
+    }
+    if (Object.keys(mapping).length > 0) {
+      scriptsByType[type] = mapping;
+    }
+  }
+  return {
+    isMpa: entries.length > 0,
+    entries,
+    defaultEntry: defaultEntry && entries.includes(defaultEntry) ? defaultEntry : void 0,
+    source,
+    scriptsByType
+  };
+}
+function normalizeEntryList(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return dedupe(value.map(normalizeEntryName).filter((item) => Boolean(item)));
+}
+function normalizeEntryName(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function collectEntriesByPrefix(scripts, prefix) {
+  const prefixWithColon = `${prefix}:`;
+  const entries = [];
+  for (const name of Object.keys(scripts)) {
+    if (!name.startsWith(prefixWithColon)) {
+      continue;
+    }
+    const entry = name.slice(prefixWithColon.length).trim();
+    if (!entry) {
+      continue;
+    }
+    entries.push(entry);
+  }
+  return dedupe(entries);
+}
 function findMatchingScript(scripts, patterns) {
   const scriptNames = Object.keys(scripts);
   for (const pattern of patterns) {
@@ -228,8 +326,12 @@ function findMatchingScript(scripts, patterns) {
       if (!name.toLowerCase().includes(pattern.toLowerCase())) {
         return false;
       }
-      const scriptContent = scripts[name].toLowerCase();
-      if (scriptContent.includes("npm i") || scriptContent.includes("npm install") || scriptContent.includes("yarn install") || scriptContent.includes("pnpm install") || scriptContent.includes("bun install")) {
+      const scriptContent = scripts[name];
+      if (!scriptContent) {
+        return false;
+      }
+      const content = scriptContent.toLowerCase();
+      if (content.includes("npm i") || content.includes("npm install") || content.includes("yarn install") || content.includes("pnpm install") || content.includes("bun install")) {
         return false;
       }
       return true;
@@ -240,10 +342,13 @@ function findMatchingScript(scripts, patterns) {
   }
   return void 0;
 }
+function dedupe(items) {
+  return [...new Set(items)];
+}
 
 // src/analyzer/dependencies.ts
-import { stat as stat3 } from "fs/promises";
-import { join as join3 } from "path";
+import { stat as stat2 } from "fs/promises";
+import { join as join2 } from "path";
 var LOCKFILES = [
   "bun.lockb",
   "bun.lock",
@@ -252,7 +357,7 @@ var LOCKFILES = [
   "package-lock.json"
 ];
 async function checkDependencyStatus(projectDir) {
-  const nodeModulesPath = join3(projectDir, "node_modules");
+  const nodeModulesPath = join2(projectDir, "node_modules");
   const nodeModulesExists = await directoryExists(nodeModulesPath);
   if (!nodeModulesExists) {
     return {
@@ -261,11 +366,11 @@ async function checkDependencyStatus(projectDir) {
       reason: "node_modules \u4E0D\u5B58\u5728"
     };
   }
+  const nodeModulesMtime = await getModifiedTime(nodeModulesPath);
   const lockfilePath = await findLockfile(projectDir);
   if (lockfilePath) {
     const lockfileMtime = await getModifiedTime(lockfilePath);
-    const nodeModulesMtime2 = await getModifiedTime(nodeModulesPath);
-    if (lockfileMtime && nodeModulesMtime2 && lockfileMtime > nodeModulesMtime2) {
+    if (lockfileMtime && nodeModulesMtime && lockfileMtime > nodeModulesMtime) {
       return {
         hasNodeModules: true,
         needsInstall: true,
@@ -273,9 +378,8 @@ async function checkDependencyStatus(projectDir) {
       };
     }
   }
-  const packageJsonPath = join3(projectDir, "package.json");
+  const packageJsonPath = join2(projectDir, "package.json");
   const packageJsonMtime = await getModifiedTime(packageJsonPath);
-  const nodeModulesMtime = await getModifiedTime(nodeModulesPath);
   if (packageJsonMtime && nodeModulesMtime && packageJsonMtime > nodeModulesMtime) {
     return {
       hasNodeModules: true,
@@ -290,8 +394,8 @@ async function checkDependencyStatus(projectDir) {
 }
 async function findLockfile(projectDir) {
   for (const lockfile of LOCKFILES) {
-    const lockfilePath = join3(projectDir, lockfile);
-    if (await fileExists3(lockfilePath)) {
+    const lockfilePath = join2(projectDir, lockfile);
+    if (await fileExists(lockfilePath)) {
       return lockfilePath;
     }
   }
@@ -299,93 +403,210 @@ async function findLockfile(projectDir) {
 }
 async function getModifiedTime(path) {
   try {
-    const stats = await stat3(path);
+    const stats = await stat2(path);
     return stats.mtimeMs;
   } catch {
     return null;
   }
 }
-async function directoryExists(path) {
+
+// src/analyzer/local-config.ts
+import { appendFile, readFile, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+var LOCAL_CONFIG_FILENAME = ".pr.local.json";
+async function loadPrLocalConfig(projectDir) {
+  const configPath = join3(projectDir, LOCAL_CONFIG_FILENAME);
+  if (!await fileExists(configPath)) {
+    return null;
+  }
+  let parsed;
   try {
-    const stats = await stat3(path);
-    return stats.isDirectory();
+    const content = await readFile(configPath, "utf-8");
+    parsed = JSON.parse(content.replace(/^\uFEFF/, ""));
   } catch {
-    return false;
+    return null;
+  }
+  await ensureLocalConfigGitignored(projectDir);
+  if (!parsed || typeof parsed !== "object") {
+    return null;
+  }
+  const config = {};
+  if (Array.isArray(parsed.entries)) {
+    config.entries = parsed.entries.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item.length > 0);
   }
+  if (typeof parsed.defaultEntry === "string" && parsed.defaultEntry.trim()) {
+    config.defaultEntry = parsed.defaultEntry.trim();
+  }
+  return config;
 }
-async function fileExists3(path) {
-  try {
-    const stats = await stat3(path);
-    return stats.isFile();
-  } catch {
-    return false;
+async function ensureLocalConfigGitignored(projectDir) {
+  const gitignorePath = join3(projectDir, ".gitignore");
+  const ignoreEntry = LOCAL_CONFIG_FILENAME;
+  if (!await fileExists(gitignorePath)) {
+    await writeFile(gitignorePath, `${ignoreEntry}
+`, "utf-8");
+    return;
   }
+  const content = await readFile(gitignorePath, "utf-8");
+  const lines = content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (lines.includes(ignoreEntry) || lines.includes(`/${ignoreEntry}`)) {
+    return;
+  }
+  const suffix = content.endsWith("\n") || content.length === 0 ? "" : "\n";
+  await appendFile(gitignorePath, `${suffix}${ignoreEntry}
+`, "utf-8");
 }
 
 // src/analyzer/index.ts
-async function fileExists4(path) {
-  try {
-    const stats = await stat4(path);
-    return stats.isFile();
-  } catch {
-    return false;
-  }
-}
 async function analyzeProject(projectDir) {
   const packageJsonPath = join4(projectDir, "package.json");
-  const hasPackageJson = await fileExists4(packageJsonPath);
+  const hasPackageJson = await fileExists(packageJsonPath);
   if (!hasPackageJson) {
     return {
       type: "unknown",
       packageManager: { name: "npm", source: "default" },
       scripts: null,
-      dependencies: { hasNodeModules: false, needsInstall: false }
+      dependencies: { hasNodeModules: false, needsInstall: false },
+      localConfig: null
     };
   }
   let packageJson = {};
   try {
-    const content = await readFile3(packageJsonPath, "utf-8");
-    packageJson = JSON.parse(content);
+    const content = await readFile2(packageJsonPath, "utf-8");
+    packageJson = JSON.parse(content.replace(/^\uFEFF/, ""));
   } catch {
   }
-  const [packageManager, scripts, dependencies] = await Promise.all([
-    detectPackageManager(projectDir),
-    analyzeScripts(projectDir),
-    checkDependencyStatus(projectDir)
+  const [packageManager, dependencies, localConfig] = await Promise.all([
+    detectPackageManager(projectDir, packageJson),
+    checkDependencyStatus(projectDir),
+    loadPrLocalConfig(projectDir)
   ]);
+  const scripts = analyzeScripts(packageJson, localConfig);
   return {
     type: "nodejs",
     packageManager,
     scripts,
     dependencies,
+    localConfig,
     name: packageJson.name,
     version: packageJson.version,
     description: packageJson.description
   };
 }
 
+// src/utils/pm-availability.ts
+import { createInterface } from "node:readline/promises";
+var availabilityCache = /* @__PURE__ */ new Map();
+async function isPmAvailable(pm) {
+  if (availabilityCache.has(pm)) {
+    return availabilityCache.get(pm);
+  }
+  try {
+    const result = await executeCapture([pm, "--version"]);
+    const available = result.exitCode === 0 && result.stdout.trim().length > 0;
+    availabilityCache.set(pm, available);
+    return available;
+  } catch {
+    availabilityCache.set(pm, false);
+    return false;
+  }
+}
+async function ensurePmAvailable(pm) {
+  if (pm === "npm") {
+    return pm;
+  }
+  const available = await isPmAvailable(pm);
+  if (available) {
+    return pm;
+  }
+  warn(`\u5305\u7BA1\u7406\u5668 ${pm} \u672A\u5B89\u88C5`);
+  if (!process.stdin.isTTY) {
+    warn("\u975E\u4EA4\u4E92\u73AF\u5883\uFF0C\u81EA\u52A8\u56DE\u9000\u5230 npm");
+    return "npm";
+  }
+  return await promptPmResolution(pm);
+}
+async function promptPmResolution(pm) {
+  console.log();
+  console.log(`  \u68C0\u6D4B\u5230\u9879\u76EE\u4F7F\u7528 ${colors.cyan}${pm}${colors.reset}\uFF0C\u4F46\u7CFB\u7EDF\u672A\u5B89\u88C5\u3002`);
+  console.log();
+  console.log(`  ${colors.bold}\u8BF7\u9009\u62E9\u64CD\u4F5C:${colors.reset}`);
+  console.log(`    ${colors.cyan}1${colors.reset}) \u81EA\u52A8\u5B89\u88C5 ${pm} ${colors.dim}(npm install -g ${pm})${colors.reset}`);
+  console.log(`    ${colors.cyan}2${colors.reset}) \u4F7F\u7528 npm \u4EE3\u66FF`);
+  console.log(`    ${colors.cyan}3${colors.reset}) \u9000\u51FA\uFF0C\u624B\u52A8\u5904\u7406`);
+  console.log();
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(`  \u8BF7\u8F93\u5165\u9009\u9879 ${colors.dim}[1/2/3]${colors.reset}: `);
+    const choice = answer.trim();
+    switch (choice) {
+      case "1":
+        return await autoInstallPm(pm);
+      case "2":
+        warn(`\u4F7F\u7528 npm \u4EE3\u66FF ${pm}`);
+        return "npm";
+      case "3":
+      default:
+        throw new CliError(`\u8BF7\u5148\u5B89\u88C5 ${pm}: npm install -g ${pm}`);
+    }
+  } finally {
+    rl.close();
+  }
+}
+async function autoInstallPm(pm) {
+  info(`\u6B63\u5728\u5B89\u88C5 ${pm}...`);
+  console.log();
+  try {
+    const result = await executeCapture(["npm", "install", "-g", pm]);
+    if (result.exitCode !== 0) {
+      error(`\u5B89\u88C5 ${pm} \u5931\u8D25`);
+      if (result.stderr.trim()) {
+        console.error(result.stderr.trim());
+      }
+      throw new CliError(`\u65E0\u6CD5\u81EA\u52A8\u5B89\u88C5 ${pm}\uFF0C\u8BF7\u624B\u52A8\u8FD0\u884C: npm install -g ${pm}`);
+    }
+  } catch (err) {
+    if (err instanceof CliError)
+      throw err;
+    throw new CliError(`\u5B89\u88C5 ${pm} \u65F6\u51FA\u9519\uFF0C\u8BF7\u624B\u52A8\u8FD0\u884C: npm install -g ${pm}`);
+  }
+  availabilityCache.delete(pm);
+  const nowAvailable = await isPmAvailable(pm);
+  if (!nowAvailable) {
+    throw new CliError(`${pm} \u5DF2\u5B89\u88C5\u4F46\u65E0\u6CD5\u6267\u884C\u3002\u8BF7\u68C0\u67E5 PATH \u6216\u91CD\u65B0\u6253\u5F00\u7EC8\u7AEF\u540E\u91CD\u8BD5\u3002`);
+  }
+  success(`${pm} \u5B89\u88C5\u5B8C\u6210`);
+  console.log();
+  return pm;
+}
+
 // src/cli/run.ts
 async function runCommand(projectDir, options = {}) {
-  const { noInstall = false, forceInstall = false, scriptType = "dev" } = options;
+  const { noInstall = false, forceInstall = false, scriptType = "dev", entry } = options;
   log("\u6B63\u5728\u5206\u6790\u9879\u76EE...");
   const project = await analyzeProject(projectDir);
   if (project.type === "unknown") {
-    error("\u672A\u68C0\u6D4B\u5230\u9879\u76EE\u7C7B\u578B\u3002\u8BF7\u786E\u4FDD\u5F53\u524D\u76EE\u5F55\u5305\u542B package.json");
-    process.exit(1);
+    throw new CliError("\u672A\u68C0\u6D4B\u5230\u9879\u76EE\u7C7B\u578B\u3002\u8BF7\u786E\u4FDD\u5F53\u524D\u76EE\u5F55\u5305\u542B package.json");
   }
   log(`\u9879\u76EE\u7C7B\u578B: ${project.type}`);
   log(`\u5305\u7BA1\u7406\u5668: ${project.packageManager.name} (from ${project.packageManager.source})`);
   if (!project.scripts) {
-    error("\u65E0\u6CD5\u8BFB\u53D6 package.json \u7684 scripts");
-    process.exit(1);
+    throw new CliError("\u65E0\u6CD5\u8BFB\u53D6 package.json \u7684 scripts");
   }
-  const scriptName = findScript(project, scriptType);
+  const resolvedEntry = await resolveEntry(project, scriptType, entry);
+  const scriptName = findScript(project, scriptType, resolvedEntry);
   if (!scriptName) {
-    error(`\u672A\u627E\u5230 ${scriptType} \u76F8\u5173\u7684\u811A\u672C`);
-    showAvailableScripts(project);
-    process.exit(1);
+    showAvailableScripts(project, scriptType, resolvedEntry);
+    throw new CliError(`\u672A\u627E\u5230 ${scriptType}${resolvedEntry ? `:${resolvedEntry}` : ""} \u76F8\u5173\u7684\u811A\u672C`);
+  }
+  if (resolvedEntry) {
+    log(`\u5165\u53E3: ${resolvedEntry}`);
   }
   log(`\u5C06\u6267\u884C\u811A\u672C: ${scriptName}`);
+  const resolvedPm = await ensurePmAvailable(project.packageManager.name);
+  if (resolvedPm !== project.packageManager.name) {
+    log(`\u4F7F\u7528 ${resolvedPm} \u4EE3\u66FF ${project.packageManager.name}`);
+  }
   const shouldInstall = !noInstall && (forceInstall || project.dependencies.needsInstall);
   if (shouldInstall) {
     if (forceInstall) {
@@ -394,27 +615,32 @@ async function runCommand(projectDir, options = {}) {
       log(`\u4F9D\u8D56\u72B6\u6001: ${project.dependencies.reason || "\u9700\u8981\u5B89\u88C5"}`);
     }
     newline();
-    const installCmd = getInstallCommand(project.packageManager.name);
+    const installCmd = getInstallCommand(resolvedPm);
     const installExitCode = await execute(installCmd, { cwd: projectDir });
     if (installExitCode !== 0) {
-      error("\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25");
-      process.exit(installExitCode);
+      throw new CliError("\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25", installExitCode);
     }
     success("\u4F9D\u8D56\u5B89\u88C5\u5B8C\u6210");
     newline();
   } else if (!noInstall) {
     log("\u4F9D\u8D56\u72B6\u6001: \u5DF2\u662F\u6700\u65B0");
   }
-  const runCmd = getRunCommand(project.packageManager.name, scriptName);
+  const runCmd = getRunCommand(resolvedPm, scriptName);
   const exitCode = await execute(runCmd, { cwd: projectDir });
   if (exitCode !== 0) {
-    process.exit(exitCode);
+    throw new CliError("\u811A\u672C\u6267\u884C\u5931\u8D25", exitCode);
   }
 }
-function findScript(project, scriptType) {
+function findScript(project, scriptType, entry) {
   const scripts = project.scripts;
   if (!scripts)
     return void 0;
+  if (entry) {
+    const entryScript = `${scriptType}:${entry}`;
+    if (scripts.scripts[entryScript]) {
+      return entryScript;
+    }
+  }
   const detected = scripts.detected[scriptType];
   if (detected) {
     return detected;
@@ -424,9 +650,115 @@ function findScript(project, scriptType) {
   }
   return void 0;
 }
-function showAvailableScripts(project) {
+async function resolveEntry(project, scriptType, entry) {
+  if (!project.scripts) {
+    return entry;
+  }
+  if (entry) {
+    validateEntry(project, scriptType, entry);
+    return entry;
+  }
+  if (scriptType !== "dev") {
+    return void 0;
+  }
+  const { mpa } = project.scripts;
+  if (!mpa.isMpa || mpa.entries.length === 0) {
+    return void 0;
+  }
+  if (mpa.entries.length === 1) {
+    const onlyEntry = mpa.entries[0];
+    if (onlyEntry) {
+      return onlyEntry;
+    }
+    return void 0;
+  }
+  const envEntry = process.env.PR_ENTRY?.trim();
+  if (envEntry) {
+    validateEntry(project, scriptType, envEntry);
+    return envEntry;
+  }
+  const defaultEntry = mpa.defaultEntry && hasEntryScript(project, scriptType, mpa.defaultEntry) ? mpa.defaultEntry : void 0;
+  if (!process.stdin.isTTY) {
+    if (defaultEntry) {
+      return defaultEntry;
+    }
+    throw new CliError(
+      `\u68C0\u6D4B\u5230 MPA \u5165\u53E3: ${mpa.entries.join(", ")}\u3002\u975E\u4EA4\u4E92\u73AF\u5883\u8BF7\u4F7F\u7528 --entry <name> \u6216\u8BBE\u7F6E PR_ENTRY\u3002`
+    );
+  }
+  return promptSelectEntry(project, scriptType, defaultEntry);
+}
+function validateEntry(project, scriptType, entry) {
+  if (!hasEntryScript(project, scriptType, entry)) {
+    const available = getAvailableEntriesByType(project, scriptType);
+    if (available.length > 0) {
+      throw new CliError(`\u5165\u53E3 "${entry}" \u4E0D\u5B58\u5728\u3002\u53EF\u9009\u5165\u53E3: ${available.join(", ")}`);
+    }
+    throw new CliError(`\u5165\u53E3 "${entry}" \u4E0D\u5B58\u5728\uFF0C\u4E14\u672A\u627E\u5230 ${scriptType}:<entry> \u811A\u672C`);
+  }
+}
+function hasEntryScript(project, scriptType, entry) {
+  const scripts = project.scripts;
+  if (!scripts)
+    return false;
+  return Boolean(scripts.scripts[`${scriptType}:${entry}`]);
+}
+function getAvailableEntriesByType(project, scriptType) {
+  const scripts = project.scripts;
+  if (!scripts)
+    return [];
+  const mapping = scripts.mpa.scriptsByType[scriptType];
+  if (!mapping)
+    return [];
+  return Object.keys(mapping);
+}
+async function promptSelectEntry(project, scriptType, defaultEntry) {
+  const entries = getAvailableEntriesByType(project, scriptType);
+  if (entries.length === 0) {
+    throw new CliError(`\u672A\u627E\u5230 ${scriptType}:<entry> \u811A\u672C\uFF0C\u65E0\u6CD5\u9009\u62E9 MPA \u5165\u53E3`);
+  }
+  const defaultResolved = defaultEntry && entries.includes(defaultEntry) ? defaultEntry : entries[0];
+  if (!defaultResolved) {
+    throw new CliError("\u672A\u627E\u5230\u53EF\u7528\u5165\u53E3\uFF0C\u65E0\u6CD5\u7EE7\u7EED\u6267\u884C");
+  }
+  info("\u68C0\u6D4B\u5230 MPA \u9879\u76EE\uFF0C\u8BF7\u9009\u62E9\u542F\u52A8\u5165\u53E3\uFF1A");
+  entries.forEach((item, index) => {
+    const marker = item === defaultResolved ? " (\u9ED8\u8BA4)" : "";
+    console.log(`  ${index + 1}) ${item}${marker}`);
+  });
+  console.log();
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(`\u8BF7\u8F93\u5165\u5E8F\u53F7 [1-${entries.length}]\uFF0C\u56DE\u8F66\u9ED8\u8BA4 ${defaultResolved}: `);
+    const trimmed = answer.trim();
+    if (!trimmed) {
+      return defaultResolved;
+    }
+    const number = Number(trimmed);
+    if (Number.isInteger(number) && number >= 1 && number <= entries.length) {
+      const selectedByNumber = entries[number - 1];
+      if (selectedByNumber) {
+        return selectedByNumber;
+      }
+    }
+    if (entries.includes(trimmed)) {
+      return trimmed;
+    }
+  } finally {
+    rl.close();
+  }
+  throw new CliError("\u65E0\u6548\u7684\u5165\u53E3\u9009\u62E9\uFF0C\u8BF7\u91CD\u65B0\u8FD0\u884C\u5E76\u8F93\u5165\u6B63\u786E\u5E8F\u53F7");
+}
+function showAvailableScripts(project, scriptType, entry) {
   if (!project.scripts)
     return;
+  if (entry) {
+    const availableEntries = getAvailableEntriesByType(project, scriptType);
+    if (availableEntries.length > 0) {
+      info(`\u53EF\u9009 ${scriptType} \u5165\u53E3: ${availableEntries.join(", ")}`);
+      return;
+    }
+  }
   const scriptNames = Object.keys(project.scripts.scripts);
   if (scriptNames.length === 0) {
     warn("package.json \u4E2D\u6CA1\u6709\u5B9A\u4E49\u4EFB\u4F55 scripts");
@@ -437,15 +769,15 @@ function showAvailableScripts(project) {
     console.log(`  - ${name}`);
   }
   console.log();
-  info("\u4F7F\u7528 qy <script> \u8FD0\u884C\u4EFB\u610F\u811A\u672C");
+  info("\u4F7F\u7528 pr <script> \u8FD0\u884C\u4EFB\u610F\u811A\u672C");
 }
 
 // src/cli/info.ts
 async function infoCommand(projectDir) {
   const project = await analyzeProject(projectDir);
   if (project.type === "unknown") {
-    console.log(`${colors.red}\u2717${colors.reset} \u672A\u68C0\u6D4B\u5230\u9879\u76EE\u7C7B\u578B`);
-    console.log("  \u8BF7\u786E\u4FDD\u5F53\u524D\u76EE\u5F55\u5305\u542B package.json \u6216\u5176\u4ED6\u9879\u76EE\u914D\u7F6E\u6587\u4EF6");
+    console.log(`${colors.red}\xD7${colors.reset} \u672A\u68C0\u6D4B\u5230\u9879\u76EE\u7C7B\u578B`);
+    console.log("  \u8BF7\u786E\u8BA4\u5F53\u524D\u76EE\u5F55\u5305\u542B package.json");
     return;
   }
   console.log();
@@ -467,10 +799,28 @@ async function infoCommand(projectDir) {
     pmInfo += `@${pm.version}`;
   }
   pmInfo += ` ${colors.dim}(${pm.source})${colors.reset}`;
-  console.log(`${colors.bold}\u5305\u7BA1\u7406\u5668:${colors.reset} ${pmInfo}`);
+  const pmAvailable = await isPmAvailable(pm.name);
+  const pmStatus = pmAvailable ? `${colors.green}\u5DF2\u5B89\u88C5${colors.reset}` : `${colors.red}\u672A\u5B89\u88C5${colors.reset}`;
+  console.log(`${colors.bold}\u5305\u7BA1\u7406\u5668:${colors.reset} ${pmInfo} [${pmStatus}]`);
   const deps = project.dependencies;
   const depsStatus = deps.needsInstall ? `${colors.yellow}\u9700\u8981\u5B89\u88C5${colors.reset} (${deps.reason})` : `${colors.green}\u5DF2\u5C31\u7EEA${colors.reset}`;
   console.log(`${colors.bold}\u4F9D\u8D56\u72B6\u6001:${colors.reset} ${depsStatus}`);
+  if (project.scripts) {
+    const { mpa } = project.scripts;
+    if (mpa.isMpa) {
+      const sourceLabel = mpa.source === "local-config" ? ".pr.local.json" : mpa.source === "package-json" ? "package.json#pr" : "scripts";
+      console.log(`${colors.bold}MPA \u6A21\u5F0F:${colors.reset} \u662F ${colors.dim}(${sourceLabel})${colors.reset}`);
+      console.log(`${colors.bold}\u53EF\u9009\u5165\u53E3:${colors.reset} ${mpa.entries.join(", ")}`);
+      if (mpa.defaultEntry) {
+        console.log(`${colors.bold}\u9ED8\u8BA4\u5165\u53E3:${colors.reset} ${mpa.defaultEntry}`);
+      }
+      if (project.localConfig) {
+        console.log(`${colors.bold}\u672C\u5730\u914D\u7F6E:${colors.reset} .pr.local.json ${colors.dim}(\u81EA\u52A8\u52A0\u5165 .gitignore)${colors.reset}`);
+      }
+    } else {
+      console.log(`${colors.bold}MPA \u6A21\u5F0F:${colors.reset} \u5426`);
+    }
+  }
   console.log();
   if (project.scripts) {
     const { scripts, detected } = project.scripts;
@@ -493,7 +843,10 @@ async function infoCommand(projectDir) {
       console.log(`${colors.bold}\u6240\u6709\u811A\u672C:${colors.reset}`);
       for (const name of allScripts) {
         const cmd = scripts[name];
-        const displayCmd = cmd.length > 40 ? cmd.slice(0, 40) + "..." : cmd;
+        if (!cmd) {
+          continue;
+        }
+        const displayCmd = cmd.length > 60 ? cmd.slice(0, 60) + "..." : cmd;
         console.log(`  ${colors.cyan}${name}${colors.reset} ${colors.dim}\u2192 ${displayCmd}${colors.reset}`);
       }
     }
@@ -505,26 +858,23 @@ async function infoCommand(projectDir) {
 async function scriptCommand(projectDir, scriptName) {
   const project = await analyzeProject(projectDir);
   if (project.type === "unknown") {
-    error("\u672A\u68C0\u6D4B\u5230\u9879\u76EE\u7C7B\u578B\u3002\u8BF7\u786E\u4FDD\u5F53\u524D\u76EE\u5F55\u5305\u542B package.json");
-    process.exit(1);
+    throw new CliError("\u672A\u68C0\u6D4B\u5230\u9879\u76EE\u7C7B\u578B\u3002\u8BF7\u786E\u4FDD\u5F53\u524D\u76EE\u5F55\u5305\u542B package.json");
   }
   if (!project.scripts) {
-    error("\u65E0\u6CD5\u8BFB\u53D6 package.json \u7684 scripts");
-    process.exit(1);
+    throw new CliError("\u65E0\u6CD5\u8BFB\u53D6 package.json \u7684 scripts");
   }
   const scripts = project.scripts.scripts;
   if (!(scriptName in scripts)) {
-    error(`\u811A\u672C "${scriptName}" \u4E0D\u5B58\u5728`);
-    console.log();
     showAvailableScripts2(scripts);
-    process.exit(1);
+    throw new CliError(`\u811A\u672C "${scriptName}" \u4E0D\u5B58\u5728`);
   }
   log(`\u5305\u7BA1\u7406\u5668: ${project.packageManager.name}`);
   log(`\u6267\u884C\u811A\u672C: ${scriptName}`);
-  const runCmd = getRunCommand(project.packageManager.name, scriptName);
+  const resolvedPm = await ensurePmAvailable(project.packageManager.name);
+  const runCmd = getRunCommand(resolvedPm, scriptName);
   const exitCode = await execute(runCmd, { cwd: projectDir });
   if (exitCode !== 0) {
-    process.exit(exitCode);
+    throw new CliError("\u811A\u672C\u6267\u884C\u5931\u8D25", exitCode);
   }
 }
 function showAvailableScripts2(scripts) {
@@ -540,7 +890,7 @@ function showAvailableScripts2(scripts) {
 }
 
 // src/index.ts
-var VERSION = "0.1.2";
+var VERSION = true ? "0.3.0" : "0.0.0-dev";
 function parseArgs(args) {
   const options = {
     verbose: false,
@@ -553,14 +903,30 @@ function parseArgs(args) {
   let i = 0;
   while (i < args.length) {
     const arg = args[i];
+    if (!arg) {
+      i++;
+      continue;
+    }
     if (arg === "-v" || arg === "--verbose") {
       options.verbose = true;
     } else if (arg === "-d" || arg === "--dir") {
-      options.dir = resolve(args[++i] || ".");
+      const dirArg = args[i + 1];
+      if (!dirArg || dirArg.startsWith("-")) {
+        throw new CliError("--dir \u9700\u8981\u4E00\u4E2A\u76EE\u5F55\u53C2\u6570");
+      }
+      options.dir = resolve(dirArg);
+      i++;
     } else if (arg === "--no-install") {
       options.noInstall = true;
     } else if (arg === "-i" || arg === "--install") {
       options.install = true;
+    } else if (arg === "-e" || arg === "--entry") {
+      const entryArg = args[i + 1];
+      if (!entryArg || entryArg.startsWith("-")) {
+        throw new CliError("--entry \u9700\u8981\u4E00\u4E2A\u5165\u53E3\u540D\u53C2\u6570");
+      }
+      options.entry = entryArg.trim();
+      i++;
     } else if (arg === "-h" || arg === "--help") {
       command = "help";
     } else if (arg === "-V" || arg === "--version") {
@@ -571,6 +937,8 @@ function parseArgs(args) {
       } else {
         remainingArgs.push(arg);
       }
+    } else {
+      warn(`\u672A\u77E5\u9009\u9879: ${arg}`);
     }
     i++;
   }
@@ -583,7 +951,7 @@ ${"\x1B[36m"}pr${"\x1B[0m"} v${VERSION} - \u96F6\u914D\u7F6E\u667A\u80FD\u9879\u
 ${"\x1B[1m"}\u7528\u6CD5:${"\x1B[0m"} pr <command> [options]
 
 ${"\x1B[1m"}\u547D\u4EE4:${"\x1B[0m"}
-  run              \u5B8C\u6574\u6D41\u7A0B\uFF1A\u68C0\u6D4B \u2192 install \u2192 \u542F\u52A8\u5F00\u53D1\u670D\u52A1\u5668
+  run              \u5B8C\u6574\u6D41\u7A0B\uFF1A\u68C0\u6D4B -> install -> \u542F\u52A8\u5F00\u53D1\u811A\u672C
   test             \u8FD0\u884C\u6D4B\u8BD5
   build            \u6784\u5EFA\u9879\u76EE
   start            \u751F\u4EA7\u6A21\u5F0F\u542F\u52A8
@@ -595,16 +963,16 @@ ${"\x1B[1m"}\u9009\u9879:${"\x1B[0m"}
   -d, --dir <path> \u6307\u5B9A\u9879\u76EE\u76EE\u5F55 (\u9ED8\u8BA4: \u5F53\u524D\u76EE\u5F55)
   -i, --install    \u5F3A\u5236\u6267\u884C\u4F9D\u8D56\u5B89\u88C5
   --no-install     \u8DF3\u8FC7\u4F9D\u8D56\u5B89\u88C5\u6B65\u9AA4
+  -e, --entry      \u6307\u5B9A MPA \u5165\u53E3 (\u4E5F\u53EF\u7528\u73AF\u5883\u53D8\u91CF PR_ENTRY)
   -h, --help       \u663E\u793A\u5E2E\u52A9\u4FE1\u606F
   -V, --version    \u663E\u793A\u7248\u672C\u53F7
 
 ${"\x1B[1m"}\u793A\u4F8B:${"\x1B[0m"}
-  pr run           \u4E00\u952E\u542F\u52A8\u9879\u76EE
-  pr run -i        \u5F3A\u5236\u5B89\u88C5\u4F9D\u8D56\u540E\u542F\u52A8
-  pr run -v        \u663E\u793A\u8BE6\u7EC6\u68C0\u6D4B\u8FC7\u7A0B
-  pr test          \u8FD0\u884C\u6D4B\u8BD5
-  pr lint          \u8FD0\u884C lint \u811A\u672C
-  pr info          \u67E5\u770B\u9879\u76EE\u4FE1\u606F
+  pr run
+  pr run --entry main
+  PR_ENTRY=formengine pr run
+  pr build --entry approve
+  pr info
 `);
 }
 function showVersion() {
@@ -612,7 +980,7 @@ function showVersion() {
 }
 async function main() {
   setupSignalHandlers();
-  const { command, options, args } = parseArgs(process.argv.slice(2));
+  const { command, options } = parseArgs(process.argv.slice(2));
   setVerbose(options.verbose);
   switch (command) {
     case "":
@@ -623,16 +991,33 @@ async function main() {
       showVersion();
       break;
     case "run":
-      await runCommand(options.dir, { noInstall: options.noInstall, forceInstall: options.install, scriptType: "dev" });
+      await runCommand(options.dir, {
+        noInstall: options.noInstall,
+        forceInstall: options.install,
+        scriptType: "dev",
+        entry: options.entry
+      });
       break;
     case "test":
-      await runCommand(options.dir, { noInstall: true, scriptType: "test" });
+      await runCommand(options.dir, {
+        noInstall: true,
+        scriptType: "test",
+        entry: options.entry
+      });
       break;
     case "build":
-      await runCommand(options.dir, { noInstall: true, scriptType: "build" });
+      await runCommand(options.dir, {
+        noInstall: true,
+        scriptType: "build",
+        entry: options.entry
+      });
       break;
     case "start":
-      await runCommand(options.dir, { noInstall: true, scriptType: "start" });
+      await runCommand(options.dir, {
+        noInstall: true,
+        scriptType: "start",
+        entry: options.entry
+      });
       break;
     case "info":
       await infoCommand(options.dir);
@@ -643,6 +1028,10 @@ async function main() {
   }
 }
 main().catch((err) => {
-  error(err.message);
+  if (err instanceof CliError) {
+    error(err.message);
+    process.exit(err.exitCode);
+  }
+  error(err.message || "\u672A\u77E5\u9519\u8BEF");
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-runner",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "零配置智能项目运行器 - 一键运行任意 Node.js 项目",
   "author": "liangzhenqi",
   "license": "MIT",