@ulpi/cli 0.1.5 → 0.1.7

package/dist/portal-JYWVHXDU.js

@@ -0,0 +1,210 @@
+import {
+  API_LOCK_FILE,
+  ULPI_GLOBAL_DIR
+} from "./chunk-C7CLUQI6.js";
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/portal.ts
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { execFileSync, spawn } from "child_process";
+import chalk from "chalk";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var PID_FILE = path.join(ULPI_GLOBAL_DIR, "portal.pid");
+function findNextBinary(portalDir) {
+  const localNext = path.join(portalDir, "node_modules", ".bin", "next");
+  if (fs.existsSync(localNext)) return localNext;
+  try {
+    const whichResult = execFileSync("which", ["next"], {
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+    if (whichResult) return whichResult;
+  } catch {
+  }
+  return null;
+}
+function findPortalDir() {
+  const candidates = [
+    // apps/cli/dist/ → ../../portal (sibling app in apps/)
+    path.resolve(__dirname, "..", "..", "portal"),
+    // From cwd
+    path.join(process.cwd(), "apps", "portal")
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(path.join(candidate, "package.json")) && fs.existsSync(path.join(candidate, "src"))) {
+      try {
+        const pkg = JSON.parse(
+          fs.readFileSync(path.join(candidate, "package.json"), "utf-8")
+        );
+        if (pkg.name === "@ulpi/portal") return candidate;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function writePidFile(pid) {
+  fs.mkdirSync(path.dirname(PID_FILE), { recursive: true });
+  fs.writeFileSync(PID_FILE, String(pid), "utf-8");
+}
+function readPidFile() {
+  try {
+    const content = fs.readFileSync(PID_FILE, "utf-8").trim();
+    const pid = parseInt(content, 10);
+    if (isNaN(pid)) return null;
+    try {
+      process.kill(pid, 0);
+      return pid;
+    } catch {
+      fs.unlinkSync(PID_FILE);
+      return null;
+    }
+  } catch {
+    return null;
+  }
+}
+function removePidFile() {
+  try {
+    fs.unlinkSync(PID_FILE);
+  } catch {
+  }
+}
+async function startPortal(args, projectDir) {
+  const portIndex = args.indexOf("--port");
+  let port = 9801;
+  if (portIndex !== -1 && args[portIndex + 1]) {
+    const parsed = parseInt(args[portIndex + 1], 10);
+    if (isNaN(parsed) || parsed < 1 || parsed > 65535) {
+      console.log(chalk.red("Invalid port number. Must be between 1 and 65535."));
+      process.exit(1);
+    }
+    port = parsed;
+  }
+  const devMode = args.includes("--dev");
+  const existingPid = readPidFile();
+  if (existingPid) {
+    console.log(chalk.yellow(`Portal is already running (PID ${existingPid}).`));
+    console.log(chalk.dim("Run 'ulpi portal stop' to stop it first."));
+    return;
+  }
+  const portalDir = findPortalDir();
+  if (!portalDir) {
+    console.log(chalk.red("Could not find the @ulpi/portal app directory."));
+    console.log(chalk.dim("Make sure you are in the ULPI monorepo, or the portal package is installed."));
+    process.exit(1);
+  }
+  const nextBin = findNextBinary(portalDir);
+  if (!nextBin) {
+    console.log(chalk.red("Could not find the 'next' binary."));
+    console.log(chalk.dim(`Install dependencies: cd ${portalDir} && pnpm install`));
+    process.exit(1);
+  }
+  const hasBuild = fs.existsSync(path.join(portalDir, ".next"));
+  if (!devMode && !hasBuild) {
+    console.log(chalk.yellow("No build output found. Starting in dev mode."));
+    console.log(chalk.dim(`Build first with: pnpm --filter @ulpi/portal build`));
+    console.log("");
+  }
+  const useDevMode = devMode || !hasBuild;
+  const nextCommand = useDevMode ? "dev" : "start";
+  let apiSecret = "";
+  let apiPort = 9800;
+  try {
+    const lock = JSON.parse(fs.readFileSync(API_LOCK_FILE, "utf-8"));
+    if (lock.secret) apiSecret = lock.secret;
+    if (lock.port) apiPort = lock.port;
+  } catch {
+    console.log(chalk.yellow("Warning: API server not running or lock file missing."));
+    console.log(chalk.dim("Start the API server first: ulpi ui\n"));
+  }
+  console.log(chalk.bold("\nULPI Portal \u2014 Local Mode\n"));
+  console.log(`  Mode:    ${useDevMode ? chalk.yellow("development") : chalk.green("production")}`);
+  console.log(`  Port:    ${chalk.cyan(String(port))}`);
+  console.log(`  API:     ${chalk.cyan(`http://localhost:${apiPort}`)}`);
+  console.log(`  Portal:  ${chalk.cyan(`apps/portal`)}`);
+  console.log("");
+  const env = {
+    ...process.env,
+    ULPI_MODE: "local",
+    NEXT_PUBLIC_ULPI_MODE: "local",
+    NEXT_PUBLIC_API_URL: `http://localhost:${apiPort}`,
+    NEXT_PUBLIC_ULPI_API_SECRET: apiSecret,
+    PORT: String(port)
+  };
+  const child = spawn(nextBin, [nextCommand, "--port", String(port)], {
+    cwd: portalDir,
+    env,
+    stdio: "inherit"
+  });
+  if (child.pid) {
+    writePidFile(child.pid);
+  }
+  const cleanup = () => {
+    removePidFile();
+    child.kill("SIGTERM");
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  child.on("error", (err) => {
+    console.error(chalk.red(`Failed to start portal: ${err.message}`));
+    removePidFile();
+    process.exit(1);
+  });
+  child.on("close", (code) => {
+    removePidFile();
+    if (code !== 0 && code !== null) {
+      console.error(chalk.red(`Portal exited with code ${code}`));
+      process.exit(code);
+    }
+  });
+  console.log(chalk.green(`Portal starting at http://localhost:${port}`));
+  console.log(chalk.dim("Press Ctrl+C to stop.\n"));
+}
+function stopPortal() {
+  const pid = readPidFile();
+  if (!pid) {
+    console.log(chalk.yellow("No running portal instance found."));
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    removePidFile();
+    console.log(chalk.green(`Portal stopped (PID ${pid}).`));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.log(chalk.red(`Failed to stop portal: ${message}`));
+    removePidFile();
+  }
+}
+function runPortalCommand(args, projectDir) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "stop":
+      return stopPortal();
+    case "start":
+      return startPortal(args.slice(1), projectDir);
+    case void 0:
+      return startPortal(args, projectDir);
+    default:
+      if (subcommand?.startsWith("--")) {
+        return startPortal(args, projectDir);
+      }
+      console.log(`
+Usage: ulpi portal [subcommand] [options]
+
+Subcommands:
+  start              Start Portal in local mode (default)
+  stop               Stop running Portal instance
+
+Options:
+  --port <number>    Port to run on (default: 3000)
+  --dev              Force development mode
+`.trim());
+  }
+}
+export {
+  runPortalCommand
+};

package/dist/prd-Q4J5NVAR.js

@@ -0,0 +1,408 @@
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/prd.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+async function runPrd(args, projectDir) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "create":
+      return await createSubcommand(args.slice(1), projectDir);
+    case "convert":
+      return await convertSubcommand(args.slice(1), projectDir);
+    case "show":
+      return await showSubcommand(args.slice(1), projectDir);
+    default:
+      console.log(`
+Usage: ulpi prd <subcommand> [options]
+
+Subcommands:
+  create [file] [--chat]     Create or parse a PRD
+  convert <file> [--output]  Convert markdown PRD to JSON tasks
+  show <file>                Show parsed PRD summary
+
+Options:
+  --chat              Interactive AI mode for PRD creation
+  --agent <name>      AI agent to use (default: claude)
+  --model <id>        Model override for the agent
+  --output, -o        Output file path for conversion
+  --prefix            Task ID prefix (default: "TASK-")
+`.trim());
+  }
+}
+async function createSubcommand(args, projectDir) {
+  const isChat = args.includes("--chat");
+  const fileArg = args.find((a) => !a.startsWith("--"));
+  if (isChat) {
+    return await runChatMode(args, projectDir);
+  }
+  if (!fileArg) {
+    console.log(chalk.yellow("Provide a markdown file to parse, or use --chat for interactive mode."));
+    console.log(chalk.dim("  ulpi prd create <file.md>"));
+    console.log(chalk.dim("  ulpi prd create --chat"));
+    return;
+  }
+  const filePath = path.isAbsolute(fileArg) ? fileArg : path.resolve(projectDir, fileArg);
+  if (!fs.existsSync(filePath)) {
+    console.error(chalk.red(`File not found: ${filePath}`));
+    process.exit(1);
+  }
+  const markdown = fs.readFileSync(filePath, "utf-8");
+  const { parsePrdMarkdown } = await import("./dist-3EIQTZHT.js");
+  const result = parsePrdMarkdown(markdown);
+  console.log(chalk.bold(`
+PRD: ${result.document.title}
+`));
+  console.log(chalk.dim(`Description: ${result.document.description}
+`));
+  if (result.document.tasks.length > 0) {
+    console.log(chalk.bold(`Tasks (${result.document.tasks.length}):`));
+    for (const task of result.document.tasks) {
+      const priorityColor = task.priority <= 1 ? "red" : task.priority <= 2 ? "yellow" : "green";
+      const priorityStr = chalk[priorityColor](`P${task.priority}`);
+      console.log(`  ${chalk.cyan(task.id)} ${task.title} ${priorityStr}`);
+      if (task.acceptanceCriteria.length > 0) {
+        console.log(chalk.dim(`    ${task.acceptanceCriteria.length} acceptance criteria`));
+      }
+      if (task.dependsOn.length > 0) {
+        console.log(chalk.dim(`    depends on: ${task.dependsOn.join(", ")}`));
+      }
+    }
+  } else {
+    console.log(chalk.yellow("No tasks found in PRD."));
+  }
+  if (result.warnings.length > 0) {
+    console.log(chalk.yellow(`
+Warnings (${result.warnings.length}):`));
+    for (const warning of result.warnings) {
+      console.log(chalk.yellow(`  - ${warning}`));
+    }
+  }
+  console.log("");
+}
+async function convertSubcommand(args, projectDir) {
+  const fileArg = args.find((a) => !a.startsWith("--") && !a.startsWith("-"));
+  const outputIdx = args.findIndex((a) => a === "--output" || a === "-o");
+  const outputArg = outputIdx !== -1 ? args[outputIdx + 1] : void 0;
+  const prefixIdx = args.findIndex((a) => a === "--prefix");
+  const prefix = prefixIdx !== -1 ? args[prefixIdx + 1] : void 0;
+  if (!fileArg) {
+    console.error(chalk.red("Provide a markdown PRD file to convert."));
+    console.log(chalk.dim("  ulpi prd convert <file.md> [--output tasks.json]"));
+    process.exit(1);
+  }
+  const filePath = path.isAbsolute(fileArg) ? fileArg : path.resolve(projectDir, fileArg);
+  if (!fs.existsSync(filePath)) {
+    console.error(chalk.red(`File not found: ${filePath}`));
+    process.exit(1);
+  }
+  const markdown = fs.readFileSync(filePath, "utf-8");
+  const { parsePrdMarkdown, convertPrdToTasks, convertPrdToJson } = await import("./dist-3EIQTZHT.js");
+  const result = parsePrdMarkdown(markdown, { taskPrefix: prefix });
+  if (result.document.tasks.length === 0) {
+    console.error(chalk.red("No tasks found in PRD. Cannot convert."));
+    if (result.warnings.length > 0) {
+      for (const warning of result.warnings) {
+        console.error(chalk.yellow(`  - ${warning}`));
+      }
+    }
+    process.exit(1);
+  }
+  const tasks = convertPrdToTasks(result.document, true);
+  const jsonOutput = convertPrdToJson(result.document);
+  const outputPath = outputArg ? path.isAbsolute(outputArg) ? outputArg : path.resolve(projectDir, outputArg) : path.resolve(projectDir, ".ulpi", "prds", `${path.basename(filePath, path.extname(filePath))}.json`);
+  const outputDir = path.dirname(outputPath);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+  fs.writeFileSync(outputPath, JSON.stringify(jsonOutput, null, 2) + "\n", "utf-8");
+  console.log(chalk.green(`Converted ${tasks.length} tasks to: ${outputPath}`));
+  for (const task of tasks) {
+    console.log(chalk.dim(`  ${task.id}: ${task.title} (P${task.priority})`));
+  }
+}
+async function showSubcommand(args, projectDir) {
+  const fileArg = args.find((a) => !a.startsWith("--"));
+  if (!fileArg) {
+    console.error(chalk.red("Provide a markdown PRD file to show."));
+    console.log(chalk.dim("  ulpi prd show <file.md>"));
+    process.exit(1);
+  }
+  const filePath = path.isAbsolute(fileArg) ? fileArg : path.resolve(projectDir, fileArg);
+  if (!fs.existsSync(filePath)) {
+    console.error(chalk.red(`File not found: ${filePath}`));
+    process.exit(1);
+  }
+  const markdown = fs.readFileSync(filePath, "utf-8");
+  const { parsePrdMarkdown } = await import("./dist-3EIQTZHT.js");
+  const result = parsePrdMarkdown(markdown);
+  const doc = result.document;
+  console.log(chalk.bold(`
+${doc.title}`));
+  console.log(chalk.dim("=".repeat(doc.title.length)));
+  console.log("");
+  if (doc.metadata.branchName) {
+    console.log(`Branch: ${chalk.cyan(String(doc.metadata.branchName))}`);
+  }
+  if (doc.metadata.createdAt) {
+    console.log(`Created: ${chalk.dim(String(doc.metadata.createdAt))}`);
+  }
+  console.log("");
+  console.log(doc.description);
+  console.log("");
+  if (doc.sections.length > 0) {
+    console.log(chalk.bold("Sections:"));
+    for (const section of doc.sections) {
+      const indent = "  ".repeat(Math.max(0, section.level - 1));
+      console.log(`${indent}${"#".repeat(section.level)} ${section.heading}`);
+    }
+    console.log("");
+  }
+  if (doc.tasks.length > 0) {
+    console.log(chalk.bold(`Tasks (${doc.tasks.length}):`));
+    console.log("");
+    for (const task of doc.tasks) {
+      const priorityColor = task.priority <= 1 ? "red" : task.priority <= 2 ? "yellow" : "green";
+      console.log(`  ${chalk.bold.cyan(task.id)}: ${chalk.bold(task.title)} ${chalk[priorityColor](`P${task.priority}`)}`);
+      if (task.description !== task.title) {
+        console.log(chalk.dim(`    ${task.description.slice(0, 120)}${task.description.length > 120 ? "..." : ""}`));
+      }
+      if (task.acceptanceCriteria.length > 0) {
+        console.log(`    ${chalk.dim("Criteria:")} ${task.acceptanceCriteria.length} items`);
+        for (const ac of task.acceptanceCriteria.slice(0, 3)) {
+          console.log(chalk.dim(`      - ${ac}`));
+        }
+        if (task.acceptanceCriteria.length > 3) {
+          console.log(chalk.dim(`      ... and ${task.acceptanceCriteria.length - 3} more`));
+        }
+      }
+      if (task.dependsOn.length > 0) {
+        console.log(`    ${chalk.dim("Depends on:")} ${task.dependsOn.join(", ")}`);
+      }
+      if (task.labels.length > 0) {
+        console.log(`    ${chalk.dim("Labels:")} ${task.labels.map((l) => `[${l}]`).join(" ")}`);
+      }
+      console.log("");
+    }
+  }
+  if (result.warnings.length > 0) {
+    console.log(chalk.yellow(`Warnings (${result.warnings.length}):`));
+    for (const warning of result.warnings) {
+      console.log(chalk.yellow(`  - ${warning}`));
+    }
+    console.log("");
+  }
+}
+async function runChatMode(args, projectDir) {
+  console.log(chalk.bold("\n  PRD Generator -- AI-Powered\n"));
+  console.log(chalk.dim("  Describe a feature and the AI will help you build a structured PRD."));
+  console.log(chalk.dim("  Type 'quit' or press Ctrl+C to exit.\n"));
+  const agentIdx = args.findIndex((a) => a === "--agent");
+  const agentName = agentIdx !== -1 && args[agentIdx + 1] ? args[agentIdx + 1] : "claude";
+  const modelIdx = args.findIndex((a) => a === "--model");
+  const model = modelIdx !== -1 && args[modelIdx + 1] ? args[modelIdx + 1] : "";
+  const {
+    getPrdSystemPrompt,
+    buildConversationPrompt,
+    detectPrd,
+    parsePrdMarkdown,
+    slugify
+  } = await import("./dist-3EIQTZHT.js");
+  const { getAgentRegistry } = await import("./dist-7QOEYLFX.js");
+  const readline = await import("readline/promises");
+  const registry = getAgentRegistry();
+  await registry.initialize();
+  if (!registry.hasPlugin(agentName)) {
+    console.error(chalk.red(`Unknown agent: ${agentName}`));
+    console.log(chalk.dim(`Available agents: ${registry.getRegisteredPlugins().map((p) => p.name).join(", ")}`));
+    return;
+  }
+  const plugin = await registry.getInstance({
+    name: `prd-chat-${agentName}`,
+    plugin: agentName,
+    options: model ? { model } : {}
+  });
+  const detection = await plugin.detect();
+  if (!detection.available) {
+    console.error(chalk.red(`Agent ${agentName} is not available: ${detection.error ?? "not found in PATH"}`));
+    return;
+  }
+  console.log(chalk.dim(`  Agent: ${agentName}${model ? ` (model: ${model})` : ""}${detection.executablePath ? ` (${detection.executablePath})` : ""}`));
+  console.log("");
+  const history = [];
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  rl.on("close", () => {
+    console.log(chalk.yellow("\n  PRD creation cancelled."));
+  });
+  try {
+    while (true) {
+      let userInput;
+      try {
+        userInput = await rl.question(chalk.cyan("  You: "));
+      } catch {
+        break;
+      }
+      const trimmed = userInput.trim();
+      if (!trimmed) continue;
+      if (trimmed.toLowerCase() === "quit" || trimmed.toLowerCase() === "exit") {
+        console.log(chalk.dim("\n  Goodbye!"));
+        break;
+      }
+      history.push({
+        role: "user",
+        content: trimmed,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const prompt = buildConversationPrompt(history, trimmed);
+      process.stdout.write(chalk.dim("  AI: thinking..."));
+      try {
+        let responseText = "";
+        const handle = plugin.execute(prompt, {
+          cwd: projectDir,
+          timeout: 12e4,
+          onStdout: (data) => {
+            responseText += data;
+          }
+        });
+        const result = await handle.promise;
+        process.stdout.write("\r" + " ".repeat(40) + "\r");
+        if (result.status !== "completed") {
+          const errorDetail = result.error ?? result.stderr?.slice(0, 200) ?? "unknown error";
+          console.log(chalk.red(`  AI: Error - ${errorDetail}`));
+          history.pop();
+          continue;
+        }
+        const aiResponse = extractTextFromAgentOutput(responseText);
+        if (!aiResponse.trim()) {
+          console.log(chalk.red("  AI: (empty response)"));
+          history.pop();
+          continue;
+        }
+        history.push({
+          role: "assistant",
+          content: aiResponse,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const lines = aiResponse.split("\n");
+        console.log(chalk.white(`  AI: ${lines[0]}`));
+        for (const line of lines.slice(1)) {
+          console.log(chalk.white(`      ${line}`));
+        }
+        console.log("");
+        const prdDetection = detectPrd(aiResponse);
+        if (prdDetection.found && prdDetection.content) {
+          const parsed = parsePrdMarkdown(prdDetection.content);
+          const doc = parsed.document;
+          console.log(chalk.green.bold("  PRD detected!"));
+          console.log(chalk.green(`  Title: ${doc.title}`));
+          console.log(chalk.green(`  Tasks: ${doc.tasks.length}`));
+          if (doc.tasks.length > 0) {
+            for (const task of doc.tasks) {
+              const priorityColor = task.priority <= 1 ? "red" : task.priority <= 2 ? "yellow" : "green";
+              console.log(`    ${chalk.cyan(task.id)} ${task.title} ${chalk[priorityColor](`P${task.priority}`)}`);
+            }
+          }
+          console.log("");
+          let saveAnswer;
+          try {
+            saveAnswer = await rl.question(chalk.cyan("  Save this PRD? [Y/n] "));
+          } catch {
+            break;
+          }
+          if (saveAnswer.trim().toLowerCase() !== "n") {
+            const slug = slugify(doc.title || "untitled");
+            const filename = `prd-${slug}.md`;
+            const prdsDir = path.join(projectDir, ".ulpi", "prds");
+            if (!fs.existsSync(prdsDir)) {
+              fs.mkdirSync(prdsDir, { recursive: true });
+            }
+            const outputPath = path.join(prdsDir, filename);
+            fs.writeFileSync(outputPath, prdDetection.content, "utf-8");
+            console.log(chalk.green(`  Saved to: ${outputPath}`));
+            console.log("");
+            let runAnswer;
+            try {
+              runAnswer = await rl.question(chalk.cyan("  Run this PRD? [y/N] "));
+            } catch {
+              break;
+            }
+            if (runAnswer.trim().toLowerCase() === "y") {
+              const modelArgs = model ? ` --model ${model}` : "";
+              console.log(chalk.dim(`
+  Starting: ulpi run --prd ${outputPath} --agent ${agentName}${modelArgs}
+`));
+              rl.close();
+              try {
+                const { runRunCommand } = await import("./run-VPNXEIBY.js");
+                const runArgs = ["--prd", outputPath, "--agent", agentName];
+                if (model) runArgs.push("--model", model);
+                await runRunCommand(runArgs, projectDir);
+              } catch (runErr) {
+                const msg = runErr instanceof Error ? runErr.message : String(runErr);
+                console.error(chalk.red(`  Failed to start run: ${msg}`));
+              }
+              return;
+            }
+          }
+          break;
+        }
+      } catch (err) {
+        process.stdout.write("\r" + " ".repeat(40) + "\r");
+        const message = err instanceof Error ? err.message : String(err);
+        console.log(chalk.red(`  Error: ${message}`));
+        history.pop();
+      }
+    }
+  } finally {
+    try {
+      rl.close();
+    } catch {
+    }
+    try {
+      await registry.disposeInstance(`prd-chat-${agentName}`);
+    } catch {
+    }
+  }
+}
+function extractTextFromAgentOutput(raw) {
+  const lines = raw.split("\n").filter((l) => l.trim());
+  const textParts = [];
+  let isStreamJson = false;
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+      isStreamJson = true;
+      if (parsed.type === "assistant" && parsed.message) {
+        const msg = parsed.message;
+        if (Array.isArray(msg.content)) {
+          for (const block of msg.content) {
+            if (block.type === "text") {
+              textParts.push(block.text);
+            }
+          }
+        }
+      }
+      if (parsed.type === "content_block_delta") {
+        const delta = parsed.delta;
+        if (delta && delta.type === "text_delta" && typeof delta.text === "string") {
+          textParts.push(delta.text);
+        }
+      }
+      if (parsed.type === "result" && typeof parsed.result === "string") {
+        textParts.push(parsed.result);
+      }
+    } catch {
+      if (!isStreamJson) {
+        textParts.push(line);
+      }
+    }
+  }
+  return textParts.join("").trim() || raw.trim();
+}
+export {
+  runPrd
+};