@ulpi/cli 0.1.5 → 0.1.6

package/dist/{launchd-OYXUAVW6.js → launchd-6AWT54HR.js}

@@ -1,10 +1,10 @@
-import "./chunk-5SCG7UYM.js";
+import "./chunk-VVEDXI7E.js";
 import {
   LAUNCHD_LABEL,
   LOGS_DIR,
   getApiPort,
   getBinaryPath
-} from "./chunk-DDRLI6JU.js";
+} from "./chunk-C7CLUQI6.js";
 import "./chunk-4VNS5WPM.js";
 
 // src/launchd.ts
@@ -30,23 +30,15 @@ function needsLegacyMigration() {
 function generatePlist(options = {}) {
   const port = options.port ?? getApiPort();
   const binary = getBinaryPath();
-  const firstSpace = binary.indexOf(" ");
-  const parts = firstSpace === -1 ? [binary] : [binary.slice(0, firstSpace), binary.slice(firstSpace + 1)];
-  for (let i = 0; i < parts.length; i++) {
-    const p = parts[i].replace(/^"|"$/g, "");
-    if (p && !p.startsWith("/")) {
-      try {
-        const resolved = execFileSync("which", [p], { encoding: "utf-8", timeout: 3e3 }).trim();
-        if (resolved) parts[i] = resolved;
-        else parts[i] = p;
-      } catch {
-        parts[i] = p;
-      }
-    } else {
-      parts[i] = p;
+  let resolvedBinary = binary;
+  if (!binary.startsWith("/")) {
+    try {
+      const resolved = execFileSync("which", [binary], { encoding: "utf-8", timeout: 3e3 }).trim();
+      if (resolved) resolvedBinary = resolved;
+    } catch {
     }
   }
-  const programArgs = parts.map((p) => `      <string>${escapeXml(p)}</string>`).join("\n");
+  const programArgs = `      <string>${escapeXml(resolvedBinary)}</string>`;
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">

package/dist/mcp-PDUD7SGP.js

@@ -0,0 +1,249 @@
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/mcp.ts
+import chalk from "chalk";
+async function runMcp(args, projectDir) {
+  const sub = args[0];
+  switch (sub) {
+    case "gateway":
+      return runGateway(projectDir);
+    case "list":
+      return runList();
+    case "add":
+      return runAdd(args.slice(1));
+    case "remove":
+      return runRemove(args.slice(1));
+    case "enable":
+      return runEnable(args.slice(1), projectDir);
+    case "disable":
+      return runDisable(args.slice(1), projectDir);
+    case "status":
+      return runStatus(projectDir);
+    case "catalog":
+      return runCatalogList(args.slice(1));
+    case "cloud-connect":
+      return runCloudConnect(projectDir);
+    default:
+      printUsage();
+  }
+}
+function printUsage() {
+  console.log(`
+Usage: ulpi mcp <subcommand>
+
+Gateway:
+  gateway              Start the MCP gateway (stdio, blocks until closed)
+
+Library:
+  list                 List global MCP library entries
+  add <name>           Add MCP to library (--from-catalog to use bundled definition)
+  remove <name>        Remove MCP from library
+
+Per-Repo:
+  enable <name>        Enable MCP for current repo
+  disable <name>       Disable MCP for current repo
+  status               Show enabled MCPs for current repo
+
+Catalog:
+  catalog [--search=<q>]   List available catalog entries
+
+Cloud:
+  cloud-connect        Configure .mcp.json to connect to Cloud MCP Gateway
+`.trim());
+}
+async function runGateway(projectDir) {
+  const { startGateway } = await import("./dist-IYE3OBRB.js");
+  await startGateway({ projectDir });
+}
+async function runList() {
+  const { listLibrary } = await import("./dist-EK45QNEM.js");
+  const entries = listLibrary();
+  if (entries.length === 0) {
+    console.log(chalk.dim("No MCPs in library. Run 'ulpi mcp add <name> --from-catalog' to add one."));
+    return;
+  }
+  console.log(chalk.bold(`MCP Library (${entries.length} entries)
+`));
+  for (const entry of entries) {
+    const name = chalk.cyan(entry.name);
+    const display = entry.display_name ? ` (${entry.display_name})` : "";
+    const cat = chalk.dim(`[${entry.category}]`);
+    const desc = entry.description ? chalk.dim(` \u2014 ${entry.description}`) : "";
+    console.log(`  ${name}${display} ${cat}${desc}`);
+    console.log(`    ${chalk.dim(`${entry.command} ${entry.args.join(" ")}`)}`);
+  }
+}
+async function runAdd(args) {
+  const name = args.find((a) => !a.startsWith("-"));
+  const fromCatalog = args.includes("--from-catalog");
+  if (!name) {
+    console.error(chalk.red("Usage: ulpi mcp add <name> [--from-catalog]"));
+    return;
+  }
+  if (!/^[a-z0-9][a-z0-9_-]*$/.test(name) || name.length > 128) {
+    console.error(chalk.red("Name must be lowercase alphanumeric with hyphens/underscores, max 128 chars."));
+    return;
+  }
+  const { addToLibrary, getLibraryEntry } = await import("./dist-EK45QNEM.js");
+  if (getLibraryEntry(name)) {
+    console.log(chalk.yellow(`MCP "${name}" already exists in library. Use 'ulpi mcp remove ${name}' first.`));
+    return;
+  }
+  const projectDir = process.cwd();
+  if (fromCatalog) {
+    const { getCatalogEntry, enableMcp } = await import("./dist-EK45QNEM.js");
+    const entry = getCatalogEntry(name);
+    if (!entry) {
+      console.error(chalk.red(`"${name}" not found in catalog. Run 'ulpi mcp catalog' to see available entries.`));
+      return;
+    }
+    addToLibrary(name, {
+      name: entry.name,
+      display_name: entry.display_name,
+      description: entry.description,
+      command: entry.command,
+      args: entry.args,
+      transport: entry.transport,
+      category: entry.category,
+      config_schema: entry.config_schema,
+      tags: entry.tags,
+      source: "catalog"
+    });
+    enableMcp(projectDir, name);
+    console.log(chalk.green(`Added "${name}" to library and enabled for this repo.`));
+  } else {
+    const commandIdx = args.indexOf("--command");
+    const command = commandIdx !== -1 ? args[commandIdx + 1] : void 0;
+    if (!command) {
+      console.error(chalk.red("For manual add, provide --command: ulpi mcp add <name> --command npx --args '-y,@scope/pkg'"));
+      console.error(chalk.dim("Or use --from-catalog to add from the bundled catalog."));
+      return;
+    }
+    const argsIdx = args.indexOf("--args");
+    const mcpArgs = argsIdx !== -1 ? args[argsIdx + 1]?.split(",") ?? [] : [];
+    const { enableMcp: enableManual } = await import("./dist-EK45QNEM.js");
+    addToLibrary(name, {
+      name,
+      command,
+      args: mcpArgs,
+      transport: "stdio",
+      category: "custom",
+      tags: [],
+      source: "manual"
+    });
+    enableManual(projectDir, name);
+    console.log(chalk.green(`Added "${name}" to library and enabled for this repo.`));
+  }
+}
+async function runRemove(args) {
+  const name = args[0];
+  if (!name) {
+    console.error(chalk.red("Usage: ulpi mcp remove <name>"));
+    return;
+  }
+  const { removeFromLibrary, disableMcp } = await import("./dist-EK45QNEM.js");
+  const removed = removeFromLibrary(name);
+  if (removed) {
+    disableMcp(process.cwd(), name);
+    console.log(chalk.green(`Removed "${name}" from library and disabled for this repo.`));
+  } else {
+    console.log(chalk.yellow(`"${name}" not found in library.`));
+  }
+}
+async function runEnable(args, projectDir) {
+  const name = args[0];
+  if (!name) {
+    console.error(chalk.red("Usage: ulpi mcp enable <name>"));
+    return;
+  }
+  const { getLibraryEntry, enableMcp } = await import("./dist-EK45QNEM.js");
+  if (!getLibraryEntry(name)) {
+    console.error(chalk.red(`"${name}" not in library. Run 'ulpi mcp add ${name} --from-catalog' first.`));
+    return;
+  }
+  const config = {};
+  for (let i = 1; i < args.length; i++) {
+    if (args[i]?.includes("=")) {
+      const [key, ...rest] = args[i].split("=");
+      if (key) config[key] = rest.join("=");
+    }
+  }
+  enableMcp(projectDir, name, Object.keys(config).length > 0 ? config : void 0);
+  console.log(chalk.green(`Enabled "${name}" for this repo.`));
+  if (Object.keys(config).length > 0) {
+    console.log(chalk.dim(`  Config: ${Object.entries(config).map(([k, v]) => `${k}=${v}`).join(", ")}`));
+  }
+}
+async function runDisable(args, projectDir) {
+  const name = args[0];
+  if (!name) {
+    console.error(chalk.red("Usage: ulpi mcp disable <name>"));
+    return;
+  }
+  const { disableMcp } = await import("./dist-EK45QNEM.js");
+  const disabled = disableMcp(projectDir, name);
+  if (disabled) {
+    console.log(chalk.green(`Disabled "${name}" for this repo.`));
+  } else {
+    console.log(chalk.yellow(`"${name}" not enabled for this repo.`));
+  }
+}
+async function runStatus(projectDir) {
+  const { listActivations, getLibraryEntry } = await import("./dist-EK45QNEM.js");
+  const activations = listActivations(projectDir);
+  if (activations.length === 0) {
+    console.log(chalk.dim("No MCPs configured for this repo. Run 'ulpi mcp enable <name>' to add one."));
+    return;
+  }
+  console.log(chalk.bold(`MCPs for this repo (${activations.length})
+`));
+  for (const { name, activation } of activations) {
+    const status = activation.enabled ? chalk.green("ON") : chalk.red("OFF");
+    const def = getLibraryEntry(name);
+    const display = def?.display_name ? ` (${def.display_name})` : "";
+    const missing = !def ? chalk.yellow(" [not in library]") : "";
+    console.log(`  ${status} ${chalk.cyan(name)}${display}${missing}`);
+    const configEntries = Object.entries(activation.config);
+    if (configEntries.length > 0) {
+      for (const [key, value] of configEntries) {
+        const displayValue = typeof value === "string" && value.startsWith("env:") ? chalk.dim(value) : chalk.dim(String(value));
+        console.log(`      ${chalk.dim(key)} = ${displayValue}`);
+      }
+    }
+  }
+}
+async function runCatalogList(args) {
+  const searchFlag = args.find((a) => a.startsWith("--search="));
+  const query = searchFlag ? searchFlag.slice("--search=".length) : void 0;
+  const { loadCatalog, searchCatalog } = await import("./dist-EK45QNEM.js");
+  const entries = query ? searchCatalog(query) : loadCatalog();
+  if (entries.length === 0) {
+    console.log(chalk.dim(query ? `No catalog entries matching "${query}".` : "Catalog is empty."));
+    return;
+  }
+  console.log(chalk.bold(`MCP Catalog (${entries.length} entries)${query ? ` \u2014 search: "${query}"` : ""}
+`));
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const cat = entry.category ?? "custom";
+    if (!byCategory.has(cat)) byCategory.set(cat, []);
+    byCategory.get(cat).push(entry);
+  }
+  for (const [category, items] of byCategory) {
+    console.log(chalk.bold(`  ${category.charAt(0).toUpperCase() + category.slice(1)}`));
+    for (const item of items) {
+      const name = chalk.cyan(item.name);
+      const desc = item.description ? chalk.dim(` \u2014 ${item.description}`) : "";
+      console.log(`    ${name}${desc}`);
+    }
+    console.log("");
+  }
+  console.log(chalk.dim(`Add to library: ulpi mcp add <name> --from-catalog`));
+}
+async function runCloudConnect(projectDir) {
+  const { runCloud } = await import("./cloud-2F3NLVHN.js");
+  await runCloud(["connect"], projectDir);
+}
+export {
+  runMcp
+};

package/dist/mcp-installer-PQU3XOGO.js

@@ -0,0 +1,259 @@
+import {
+  getBinaryPath
+} from "./chunk-C7CLUQI6.js";
+import "./chunk-4VNS5WPM.js";
+
+// src/mcp-installer.ts
+import * as fs from "fs";
+import * as path from "path";
+import { execFileSync } from "child_process";
+function mcpJsonPath(projectDir) {
+  return path.join(projectDir, ".mcp.json");
+}
+function readMcpJson(projectDir) {
+  const filePath = mcpJsonPath(projectDir);
+  if (fs.existsSync(filePath)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      return { mcpServers: data.mcpServers ?? {} };
+    } catch {
+    }
+  }
+  return { mcpServers: {} };
+}
+function writeMcpJson(projectDir, mcpServers) {
+  const filePath = mcpJsonPath(projectDir);
+  fs.writeFileSync(filePath, JSON.stringify({ mcpServers }, null, 2) + "\n", "utf-8");
+}
+function buildMcpEntry(subcommandArgs, description) {
+  return { command: getBinaryPath(), args: subcommandArgs, description };
+}
+function installMcpServer(projectDir) {
+  const { mcpServers } = readMcpJson(projectDir);
+  if (mcpServers["codemap"]) {
+    return { installed: false, message: "CodeMap MCP server already registered" };
+  }
+  mcpServers["codemap"] = buildMcpEntry(["codemap", "serve"], "Semantic code search (hybrid vector + BM25), symbol lookup, file summaries, dependency graph analysis (PageRank, cycles, coupling). Use search_code for concept-based queries, search_symbols to find functions/types by name.");
+  writeMcpJson(projectDir, mcpServers);
+  return { installed: true, message: "CodeMap MCP server registered in .mcp.json" };
+}
+function uninstallMcpServer(projectDir) {
+  const filePath = mcpJsonPath(projectDir);
+  if (!fs.existsSync(filePath)) return;
+  try {
+    const { mcpServers } = readMcpJson(projectDir);
+    if (mcpServers["codemap"]) {
+      delete mcpServers["codemap"];
+      writeMcpJson(projectDir, mcpServers);
+    }
+  } catch {
+  }
+}
+function isMcpServerInstalled(projectDir) {
+  const { mcpServers } = readMcpJson(projectDir);
+  return !!mcpServers["codemap"];
+}
+function installMemoryMcpServer(projectDir) {
+  const { mcpServers } = readMcpJson(projectDir);
+  if (mcpServers["memory"]) {
+    return { installed: false, message: "Memory MCP server already registered" };
+  }
+  mcpServers["memory"] = buildMcpEntry(["memory", "serve"], "Persistent agent memory across sessions. Search past decisions, patterns, and learnings. Save new memories, browse timeline, get session context, and manage retention.");
+  writeMcpJson(projectDir, mcpServers);
+  return { installed: true, message: "Memory MCP server registered in .mcp.json" };
+}
+function uninstallMemoryMcpServer(projectDir) {
+  const filePath = mcpJsonPath(projectDir);
+  if (!fs.existsSync(filePath)) return;
+  try {
+    const { mcpServers } = readMcpJson(projectDir);
+    if (mcpServers["memory"]) {
+      delete mcpServers["memory"];
+      writeMcpJson(projectDir, mcpServers);
+    }
+  } catch {
+  }
+}
+function isMemoryMcpServerInstalled(projectDir) {
+  const { mcpServers } = readMcpJson(projectDir);
+  return !!mcpServers["memory"];
+}
+function installGatewayMcpServer(projectDir) {
+  const { mcpServers } = readMcpJson(projectDir);
+  if (mcpServers["tools"]) {
+    return { installed: false, message: "MCP Gateway server already registered" };
+  }
+  mcpServers["tools"] = buildMcpEntry(["mcp", "gateway"], "MCP gateway proxy \u2014 aggregates tools from third-party MCP servers (databases, APIs, services) enabled for this project. Tool names are prefixed with the server name (e.g. postgres__query, stripe__list_customers).");
+  writeMcpJson(projectDir, mcpServers);
+  return { installed: true, message: "MCP Gateway server registered in .mcp.json" };
+}
+function isCommandAvailable(command) {
+  try {
+    execFileSync("which", [command], { encoding: "utf-8", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getProjectMcpEntries() {
+  const binary = getBinaryPath();
+  return {
+    codemap: { command: binary, args: ["codemap", "serve"] },
+    memory: { command: binary, args: ["memory", "serve"] },
+    gateway: { command: binary, args: ["mcp", "gateway"] }
+  };
+}
+function readJsonConfig(filePath) {
+  if (fs.existsSync(filePath)) {
+    try {
+      return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    } catch {
+    }
+  }
+  return {};
+}
+function writeJsonConfig(filePath, config) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function writeCodexProjectMcp(projectDir) {
+  const filePath = path.join(projectDir, ".codex", "config.toml");
+  const entries = getProjectMcpEntries();
+  const added = [];
+  let content = "";
+  if (fs.existsSync(filePath)) {
+    content = fs.readFileSync(filePath, "utf-8");
+  }
+  const servers = {
+    "ulpi-codemap": entries.codemap,
+    "ulpi-memory": entries.memory,
+    "tools": entries.gateway
+  };
+  for (const [name, entry] of Object.entries(servers)) {
+    const sectionHeader = `[mcp_servers.${name}]`;
+    if (content.includes(sectionHeader)) continue;
+    const argsToml = entry.args.map((a) => `"${a}"`).join(", ");
+    content += `
+${sectionHeader}
+command = "${entry.command}"
+args = [${argsToml}]
+`;
+    added.push(name);
+  }
+  if (added.length === 0) return null;
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, content, "utf-8");
+  return { cli: "Codex", file: ".codex/config.toml", servers: added };
+}
+function writeKiroProjectMcp(projectDir) {
+  const filePath = path.join(projectDir, ".kiro", "settings", "mcp.json");
+  const entries = getProjectMcpEntries();
+  const added = [];
+  const config = readJsonConfig(filePath);
+  const mcpServers = config.mcpServers ?? {};
+  const servers = {
+    "ulpi-codemap": entries.codemap,
+    "ulpi-memory": entries.memory,
+    "tools": entries.gateway
+  };
+  for (const [name, entry] of Object.entries(servers)) {
+    if (mcpServers[name]) continue;
+    mcpServers[name] = { command: entry.command, args: entry.args, transportType: "stdio" };
+    added.push(name);
+  }
+  if (added.length === 0) return null;
+  config.mcpServers = mcpServers;
+  writeJsonConfig(filePath, config);
+  return { cli: "Kiro", file: ".kiro/settings/mcp.json", servers: added };
+}
+function writeGeminiProjectMcp(projectDir) {
+  const filePath = path.join(projectDir, ".gemini", "settings.json");
+  const entries = getProjectMcpEntries();
+  const added = [];
+  const config = readJsonConfig(filePath);
+  const mcpServers = config.mcpServers ?? {};
+  const servers = {
+    "ulpi-codemap": entries.codemap,
+    "ulpi-memory": entries.memory,
+    "tools": entries.gateway
+  };
+  for (const [name, entry] of Object.entries(servers)) {
+    if (mcpServers[name]) continue;
+    mcpServers[name] = { command: entry.command, args: entry.args };
+    added.push(name);
+  }
+  if (added.length === 0) return null;
+  config.mcpServers = mcpServers;
+  writeJsonConfig(filePath, config);
+  return { cli: "Gemini", file: ".gemini/settings.json", servers: added };
+}
+function writeOpenCodeProjectMcp(projectDir) {
+  const filePath = path.join(projectDir, "opencode.json");
+  const entries = getProjectMcpEntries();
+  const added = [];
+  const config = readJsonConfig(filePath);
+  const mcp = config.mcp ?? {};
+  const servers = {
+    "ulpi-codemap": entries.codemap,
+    "ulpi-memory": entries.memory,
+    "tools": entries.gateway
+  };
+  for (const [name, entry] of Object.entries(servers)) {
+    if (mcp[name]) continue;
+    mcp[name] = { command: [entry.command, ...entry.args], type: "local" };
+    added.push(name);
+  }
+  if (added.length === 0) return null;
+  config.mcp = mcp;
+  writeJsonConfig(filePath, config);
+  return { cli: "OpenCode", file: "opencode.json", servers: added };
+}
+function writeDroidProjectMcp(projectDir) {
+  const filePath = path.join(projectDir, ".factory", "mcp.json");
+  const entries = getProjectMcpEntries();
+  const added = [];
+  const config = readJsonConfig(filePath);
+  const mcpServers = config.mcpServers ?? {};
+  const servers = {
+    "ulpi-codemap": entries.codemap,
+    "ulpi-memory": entries.memory,
+    "tools": entries.gateway
+  };
+  for (const [name, entry] of Object.entries(servers)) {
+    if (mcpServers[name]) continue;
+    mcpServers[name] = { command: entry.command, args: entry.args, type: "stdio" };
+    added.push(name);
+  }
+  if (added.length === 0) return null;
+  config.mcpServers = mcpServers;
+  writeJsonConfig(filePath, config);
+  return { cli: "Droid", file: ".factory/mcp.json", servers: added };
+}
+function installMcpForAllClis(projectDir) {
+  const results = [];
+  const clis = [
+    { binary: "codex", writer: writeCodexProjectMcp },
+    { binary: "kiro", writer: writeKiroProjectMcp },
+    { binary: "gemini", writer: writeGeminiProjectMcp },
+    { binary: "opencode", writer: writeOpenCodeProjectMcp },
+    { binary: "droid", writer: writeDroidProjectMcp }
+  ];
+  for (const { binary, writer } of clis) {
+    if (!isCommandAvailable(binary)) continue;
+    const result = writer(projectDir);
+    if (result) results.push(result);
+  }
+  return results;
+}
+export {
+  installGatewayMcpServer,
+  installMcpForAllClis,
+  installMcpServer,
+  installMemoryMcpServer,
+  isMcpServerInstalled,
+  isMemoryMcpServerInstalled,
+  uninstallMcpServer,
+  uninstallMemoryMcpServer
+};