@ulpi/cli 0.1.5 → 0.1.6

package/dist/mcp-setup-OA7IB3H3.js

@@ -0,0 +1,263 @@
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/mcp-setup.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { execFileSync } from "child_process";
+import chalk from "chalk";
+function isCommandAvailable(command) {
+  try {
+    execFileSync("which", [command], { encoding: "utf-8", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectAgents() {
+  const agents = [];
+  const home = os.homedir();
+  if (isCommandAvailable("claude")) {
+    agents.push({
+      name: "Claude Code",
+      binary: "claude",
+      configPath: path.join(home, ".claude", "settings.json"),
+      format: "json"
+    });
+  }
+  if (isCommandAvailable("opencode")) {
+    const xdgConfig = process.env.XDG_CONFIG_HOME ?? path.join(home, ".config");
+    const opencodePath = path.join(xdgConfig, "opencode", "config.json");
+    agents.push({
+      name: "OpenCode",
+      binary: "opencode",
+      configPath: opencodePath,
+      format: "json"
+    });
+  }
+  if (isCommandAvailable("gemini")) {
+    const xdgConfig = process.env.XDG_CONFIG_HOME ?? path.join(home, ".config");
+    agents.push({
+      name: "Gemini CLI",
+      binary: "gemini",
+      configPath: path.join(xdgConfig, "gemini", "settings.json"),
+      format: "json"
+    });
+  }
+  if (isCommandAvailable("codex")) {
+    agents.push({
+      name: "Codex",
+      binary: "codex",
+      configPath: path.join(home, ".codex", "config.json"),
+      format: "json"
+    });
+  }
+  if (isCommandAvailable("kiro")) {
+    agents.push({
+      name: "Kiro",
+      binary: "kiro",
+      configPath: path.join(home, ".kiro", "settings", "mcp.json"),
+      format: "json-nested"
+    });
+  }
+  if (isCommandAvailable("droid")) {
+    const xdgConfig = process.env.XDG_CONFIG_HOME ?? path.join(home, ".config");
+    agents.push({
+      name: "Droid",
+      binary: "droid",
+      configPath: path.join(xdgConfig, "droid", "mcp.json"),
+      format: "json"
+    });
+  }
+  return agents;
+}
+function buildMcpEntries() {
+  return {
+    codemap: {
+      command: "ulpi",
+      args: ["codemap", "serve"]
+    },
+    memory: {
+      command: "ulpi",
+      args: ["memory", "serve"]
+    },
+    gateway: {
+      command: "ulpi",
+      args: ["mcp", "gateway"]
+    }
+  };
+}
+function writeJsonMcpConfig(configPath, agentName) {
+  const entries = [];
+  const mcpEntries = buildMcpEntries();
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    } catch {
+    }
+  }
+  const mcpServers = config.mcpServers ?? {};
+  let changed = false;
+  if (!mcpServers["ulpi-codemap"]) {
+    mcpServers["ulpi-codemap"] = mcpEntries.codemap;
+    entries.push("ulpi-codemap");
+    changed = true;
+  }
+  if (!mcpServers["ulpi-memory"]) {
+    mcpServers["ulpi-memory"] = mcpEntries.memory;
+    entries.push("ulpi-memory");
+    changed = true;
+  }
+  if (!mcpServers["tools"]) {
+    mcpServers["tools"] = mcpEntries.gateway;
+    entries.push("tools");
+    changed = true;
+  }
+  if (changed) {
+    config.mcpServers = mcpServers;
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  }
+  return { written: changed, entries };
+}
+function writeKiroMcpConfig(configPath) {
+  const entries = [];
+  const mcpEntries = buildMcpEntries();
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    } catch {
+    }
+  }
+  const mcpServers = config.mcpServers ?? {};
+  let changed = false;
+  if (!mcpServers["ulpi-codemap"]) {
+    mcpServers["ulpi-codemap"] = {
+      command: mcpEntries.codemap.command,
+      args: mcpEntries.codemap.args,
+      transportType: "stdio"
+    };
+    entries.push("ulpi-codemap");
+    changed = true;
+  }
+  if (!mcpServers["ulpi-memory"]) {
+    mcpServers["ulpi-memory"] = {
+      command: mcpEntries.memory.command,
+      args: mcpEntries.memory.args,
+      transportType: "stdio"
+    };
+    entries.push("ulpi-memory");
+    changed = true;
+  }
+  if (!mcpServers["tools"]) {
+    mcpServers["tools"] = {
+      command: mcpEntries.gateway.command,
+      args: mcpEntries.gateway.args,
+      transportType: "stdio"
+    };
+    entries.push("tools");
+    changed = true;
+  }
+  if (changed) {
+    config.mcpServers = mcpServers;
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  }
+  return { written: changed, entries };
+}
+function suggestAdditionalMcpServers(projectDir) {
+  const suggestions = [];
+  suggestions.push(
+    `${chalk.cyan("context7")} - Library documentation lookup (npx -y @upstash/context7-mcp@latest)`
+  );
+  const claudeSettingsPath = path.join(projectDir, ".claude", "settings.local.json");
+  if (fs.existsSync(claudeSettingsPath)) {
+    try {
+      const settings = JSON.parse(fs.readFileSync(claudeSettingsPath, "utf-8"));
+      const mcpServers = settings.mcpServers;
+      if (mcpServers) {
+        const projectServers = Object.keys(mcpServers).filter(
+          (k) => !k.startsWith("ulpi-") && k !== "codemap" && k !== "memory"
+        );
+        if (projectServers.length > 0) {
+          suggestions.push(
+            `${chalk.dim("Project MCP servers detected:")} ${projectServers.join(", ")}`
+          );
+        }
+      }
+    } catch {
+    }
+  }
+  if (suggestions.length > 0) {
+    console.log(chalk.bold("\nSuggested additional MCP servers:"));
+    for (const suggestion of suggestions) {
+      console.log(`  ${suggestion}`);
+    }
+  }
+}
+async function runMcpSetup(projectDir) {
+  console.log(chalk.bold("\nULPI MCP Setup\n"));
+  const agents = detectAgents();
+  if (agents.length === 0) {
+    console.log(chalk.yellow("No supported agent CLIs detected on PATH."));
+    console.log(chalk.dim("\nSupported agents: claude, opencode, gemini, codex, kiro, droid"));
+    console.log(chalk.dim("Install one and run this command again."));
+    return;
+  }
+  console.log(`Detected ${chalk.cyan(String(agents.length))} agent CLI(s):
+`);
+  let totalWritten = 0;
+  let totalSkipped = 0;
+  for (const agent of agents) {
+    console.log(`  ${chalk.bold(agent.name)} (${chalk.dim(agent.binary)})`);
+    console.log(`    Config: ${chalk.dim(agent.configPath)}`);
+    let result;
+    if (agent.format === "json-nested") {
+      result = writeKiroMcpConfig(agent.configPath);
+    } else {
+      result = writeJsonMcpConfig(agent.configPath, agent.name);
+    }
+    if (result.written) {
+      console.log(
+        `    ${chalk.green("Added:")} ${result.entries.join(", ")}`
+      );
+      totalWritten += result.entries.length;
+    } else {
+      console.log(`    ${chalk.dim("Already configured")}`);
+      totalSkipped++;
+    }
+    console.log("");
+  }
+  if (totalWritten > 0) {
+    console.log(
+      chalk.green(`Registered ${totalWritten} MCP server(s) across ${agents.length} agent(s).`)
+    );
+  } else if (totalSkipped > 0) {
+    console.log(chalk.dim("All agents already have ULPI MCP servers configured."));
+  }
+  try {
+    const { installMcpForAllClis } = await import("./mcp-installer-PQU3XOGO.js");
+    const cliResults = installMcpForAllClis(projectDir);
+    if (cliResults.length > 0) {
+      console.log(chalk.bold("Project-level MCP configs:\n"));
+      for (const result of cliResults) {
+        console.log(`  ${chalk.green("\u2713")} ${result.cli} \u2014 ${result.file} (${result.servers.join(", ")})`);
+      }
+      console.log("");
+    }
+  } catch {
+  }
+  suggestAdditionalMcpServers(projectDir);
+  console.log("");
+}
+export {
+  runMcpSetup
+};

package/dist/{memory-D6ZFFCI2.js → memory-ZNAEAK3B.js}

@@ -50,8 +50,8 @@ Subcommands:
 }
 async function initSubcommand(projectDir) {
   console.log(chalk.bold("\nAgent Memory -- Initialize\n"));
-  const { isMemoryInitialized, saveMemoryConfig, DEFAULT_MEMORY_CONFIG } = await import("./dist-7WLLPWWB.js");
-  const { projectMemoryDir } = await import("./dist-GWGTAHNM.js");
+  const { isMemoryInitialized, saveMemoryConfig, DEFAULT_MEMORY_CONFIG } = await import("./dist-JLU26AB6.js");
+  const { projectMemoryDir } = await import("./dist-NUXMDXZ3.js");
   const fs = await import("fs");
   if (isMemoryInitialized(projectDir)) {
     console.log(chalk.yellow("Memory is already initialized for this project."));
@@ -67,7 +67,7 @@ async function initSubcommand(projectDir) {
   console.log(chalk.dim(`  Capture mode: ${config.captureMode}`));
   console.log(chalk.dim(`  Classifier:   ${config.classifier.enabled ? "enabled" : "disabled"}`));
   console.log(chalk.dim(`  Surface:      ${config.surfaceOnStart ? `on start (limit ${config.surfaceLimit})` : "disabled"}`));
-  const { installMemoryMcpServer } = await import("./mcp-installer-TOYDP77X.js");
+  const { installMemoryMcpServer } = await import("./mcp-installer-PQU3XOGO.js");
   const mcp = installMemoryMcpServer(projectDir);
   if (mcp.installed) {
     console.log(chalk.green("\u2713 MCP server registered"));
@@ -104,7 +104,7 @@ async function searchSubcommand(args, projectDir) {
   const ora = (await import("ora")).default;
   const spinner = ora("Searching memories...").start();
   try {
-    const { searchMemory, isMemoryInitialized } = await import("./dist-7WLLPWWB.js");
+    const { searchMemory, isMemoryInitialized } = await import("./dist-JLU26AB6.js");
     if (!isMemoryInitialized(projectDir)) {
       spinner.fail("Memory not initialized");
       console.log(chalk.dim("Run 'ulpi memory init' first."));
@@ -170,7 +170,7 @@ async function rememberSubcommand(args, projectDir) {
     console.log(chalk.dim('\nExample: ulpi memory remember "Always run tests before committing" --type PREFERENCE --importance high'));
     return;
   }
-  const { isMemoryInitialized } = await import("./dist-7WLLPWWB.js");
+  const { isMemoryInitialized } = await import("./dist-JLU26AB6.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
@@ -190,7 +190,7 @@ async function rememberSubcommand(args, projectDir) {
   const ora = (await import("ora")).default;
   const spinner = ora("Storing memory...").start();
   try {
-    const { generateMemoryId, rememberMemory } = await import("./dist-7WLLPWWB.js");
+    const { generateMemoryId, rememberMemory } = await import("./dist-JLU26AB6.js");
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const entry = {
       id: generateMemoryId(memType, text),
@@ -216,7 +216,7 @@ async function rememberSubcommand(args, projectDir) {
   }
 }
 async function statusSubcommand(projectDir) {
-  const { isMemoryInitialized, getMemoryStats, isMemoryEnabled, loadMemoryConfig } = await import("./dist-7WLLPWWB.js");
+  const { isMemoryInitialized, getMemoryStats, isMemoryEnabled, loadMemoryConfig } = await import("./dist-JLU26AB6.js");
   console.log(chalk.bold("\nAgent Memory Status\n"));
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.yellow("  Not initialized"));
@@ -257,7 +257,7 @@ async function statusSubcommand(projectDir) {
 }
 async function exportSubcommand(projectDir) {
   console.log(chalk.bold("\nAgent Memory -- Export\n"));
-  const { isMemoryInitialized, exportMemories } = await import("./dist-7WLLPWWB.js");
+  const { isMemoryInitialized, exportMemories } = await import("./dist-JLU26AB6.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
@@ -277,7 +277,7 @@ async function exportSubcommand(projectDir) {
 }
 async function importSubcommand(projectDir) {
   console.log(chalk.bold("\nAgent Memory -- Import\n"));
-  const { importMemories } = await import("./dist-7WLLPWWB.js");
+  const { importMemories } = await import("./dist-JLU26AB6.js");
   try {
     const result = await importMemories(projectDir);
     if (!result.success) {
@@ -295,18 +295,18 @@ async function importSubcommand(projectDir) {
   }
 }
 async function serveSubcommand(projectDir) {
-  const { isMemoryInitialized } = await import("./dist-7WLLPWWB.js");
+  const { isMemoryInitialized } = await import("./dist-JLU26AB6.js");
   if (!isMemoryInitialized(projectDir)) {
     console.error(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     process.exit(1);
   }
   console.error(chalk.dim("[memory-mcp] Starting MCP server..."));
   console.error(chalk.dim(`[memory-mcp] Project: ${projectDir}`));
-  const { startMemoryMcpServer } = await import("./dist-U7ZIJMZD.js");
+  const { startMemoryMcpServer } = await import("./dist-FKFEJRPX.js");
   await startMemoryMcpServer({ projectDir });
 }
 async function classifySubcommand(args, projectDir) {
-  const { isMemoryInitialized, listCapturedSessions, classifySession, loadWatermark, writeClassifyBatchProgress, clearClassifyBatchProgress } = await import("./dist-7WLLPWWB.js");
+  const { isMemoryInitialized, listCapturedSessions, classifySession, loadWatermark, writeClassifyBatchProgress, clearClassifyBatchProgress } = await import("./dist-JLU26AB6.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
@@ -341,7 +341,7 @@ async function classifySubcommand(args, projectDir) {
       }
       if (doExport) {
         try {
-          const { exportMemories } = await import("./dist-7WLLPWWB.js");
+          const { exportMemories } = await import("./dist-JLU26AB6.js");
           await exportMemories(projectDir);
         } catch {
         }
@@ -351,7 +351,7 @@ async function classifySubcommand(args, projectDir) {
     await classifySingleSession(projectDir, sessionId, classifySession);
     if (doExport) {
       try {
-        const { exportMemories } = await import("./dist-7WLLPWWB.js");
+        const { exportMemories } = await import("./dist-JLU26AB6.js");
         const result = await exportMemories(projectDir);
         console.log(chalk.green(`\u2713 Exported ${result.memoriesExported} memories to ${result.branchName}`));
       } catch (err) {
@@ -526,7 +526,7 @@ Agent Memory -- Classify Session
   }
 }
 async function enableSubcommand(projectDir) {
-  const { loadMemoryConfig, saveMemoryConfig, isMemoryInitialized } = await import("./dist-7WLLPWWB.js");
+  const { loadMemoryConfig, saveMemoryConfig, isMemoryInitialized } = await import("./dist-JLU26AB6.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
@@ -537,7 +537,7 @@ async function enableSubcommand(projectDir) {
   console.log(chalk.green("\u2713 Memory capture enabled"));
 }
 async function disableSubcommand(projectDir) {
-  const { loadMemoryConfig, saveMemoryConfig, isMemoryInitialized } = await import("./dist-7WLLPWWB.js");
+  const { loadMemoryConfig, saveMemoryConfig, isMemoryInitialized } = await import("./dist-JLU26AB6.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
@@ -548,7 +548,7 @@ async function disableSubcommand(projectDir) {
   console.log(chalk.yellow("\u2713 Memory capture disabled"));
 }
 async function reindexSubcommand(projectDir) {
-  const { isMemoryInitialized, reindexMemories } = await import("./dist-7WLLPWWB.js");
+  const { isMemoryInitialized, reindexMemories } = await import("./dist-JLU26AB6.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;

package/dist/{ollama-3XCUZMZT-FYKHW4TZ.js → ollama-3XCUZMZT-4JMH6B7P.js}

@@ -1,6 +1,6 @@
 import {
   OllamaEmbedder
-} from "./chunk-KLEASXUR.js";
+} from "./chunk-6ZL6NXMV.js";
 import "./chunk-4VNS5WPM.js";
 export {
   OllamaEmbedder

package/dist/{openai-E7G2YAHU-IG33BFYF.js → openai-E7G2YAHU-T3HMBPH7.js}

@@ -1,7 +1,7 @@
 import {
   OpenAIEmbedder
-} from "./chunk-K4OVPFY2.js";
-import "./chunk-DDRLI6JU.js";
+} from "./chunk-4UCJIAOU.js";
+import "./chunk-C7CLUQI6.js";
 import "./chunk-4VNS5WPM.js";
 export {
   OpenAIEmbedder

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
+};