@polterware/polter 0.2.4 → 0.3.1

package/dist/{chunk-2B2UWOVQ.js → chunk-7MIUDIAI.js}

@@ -673,12 +673,42 @@ var gitCommands = [
   { id: "git:merge", tool: "git", base: ["merge"], label: "merge", hint: "Merge branches" }
 ];
 
+// src/data/commands/pkg.ts
+var pkgCommands = [
+  // Build & Publish
+  { id: "pkg:build", tool: "pkg", base: ["run", "build"], label: "build", hint: "Run build script" },
+  { id: "pkg:publish", tool: "pkg", base: ["publish"], label: "publish", hint: "Publish package to registry" },
+  { id: "pkg:pack", tool: "pkg", base: ["pack"], label: "pack", hint: "Create tarball from package" },
+  { id: "pkg:version:patch", tool: "pkg", base: ["version", "patch"], label: "version patch", hint: "Bump patch version" },
+  { id: "pkg:version:minor", tool: "pkg", base: ["version", "minor"], label: "version minor", hint: "Bump minor version" },
+  { id: "pkg:version:major", tool: "pkg", base: ["version", "major"], label: "version major", hint: "Bump major version" },
+  { id: "pkg:login", tool: "pkg", base: ["login"], label: "login", hint: "Log in to registry" },
+  { id: "pkg:logout", tool: "pkg", base: ["logout"], label: "logout", hint: "Log out from registry" },
+  // Dependency Management
+  { id: "pkg:install", tool: "pkg", base: ["install"], label: "install", hint: "Install all dependencies" },
+  { id: "pkg:add", tool: "pkg", base: ["add"], label: "add", hint: "Add a dependency" },
+  { id: "pkg:remove", tool: "pkg", base: ["remove"], label: "remove", hint: "Remove a dependency" },
+  { id: "pkg:update", tool: "pkg", base: ["update"], label: "update", hint: "Update dependencies" },
+  { id: "pkg:outdated", tool: "pkg", base: ["outdated"], label: "outdated", hint: "List outdated packages" },
+  { id: "pkg:audit", tool: "pkg", base: ["audit"], label: "audit", hint: "Run security audit" },
+  { id: "pkg:ls", tool: "pkg", base: ["ls"], label: "ls", hint: "List installed packages" },
+  // Registry & Config
+  { id: "pkg:config:list", tool: "pkg", base: ["config", "list"], label: "config list", hint: "Show config" },
+  { id: "pkg:whoami", tool: "pkg", base: ["whoami"], label: "whoami", hint: "Show logged-in user" },
+  // Scripts & Info
+  { id: "pkg:run", tool: "pkg", base: ["run"], label: "run", hint: "Run a package script" },
+  { id: "pkg:info", tool: "pkg", base: ["info"], label: "info", hint: "Show package info" },
+  { id: "pkg:search", tool: "pkg", base: ["search"], label: "search", hint: "Search packages in registry" },
+  { id: "pkg:init", tool: "pkg", base: ["init"], label: "init", hint: "Initialize a new package.json" }
+];
+
 // src/data/commands/index.ts
 var allCommands = [
   ...supabaseCommands,
   ...ghCommands,
   ...vercelCommands,
-  ...gitCommands
+  ...gitCommands,
+  ...pkgCommands
 ];
 var commandById = new Map(allCommands.map((cmd) => [cmd.id, cmd]));
 var commandByValue = new Map(
@@ -703,11 +733,10 @@ function findCommandByValue(value) {
 }
 
 // src/data/features.ts
+var allSources = [...supabaseCommands, ...ghCommands, ...vercelCommands, ...gitCommands, ...pkgCommands];
 function pick(ids) {
   const idSet = new Set(ids);
-  return [...supabaseCommands, ...ghCommands, ...vercelCommands, ...gitCommands].filter(
-    (cmd) => idSet.has(cmd.id)
-  );
+  return allSources.filter((cmd) => idSet.has(cmd.id));
 }
 var features = [
   {
@@ -746,7 +775,7 @@ var features = [
   },
   {
     id: "repo",
-    icon: "\u{1F4E6}",
+    icon: "\u{1F5C3}\uFE0F",
     label: "Repo",
     commands: pick([
       "git:status",
@@ -822,6 +851,34 @@ var features = [
       "vercel:domains:rm"
     ])
   },
+  {
+    id: "packages",
+    icon: "\u{1F4CB}",
+    label: "Packages",
+    commands: pick([
+      "pkg:install",
+      "pkg:add",
+      "pkg:remove",
+      "pkg:update",
+      "pkg:outdated",
+      "pkg:audit",
+      "pkg:ls",
+      "pkg:build",
+      "pkg:run",
+      "pkg:publish",
+      "pkg:pack",
+      "pkg:version:patch",
+      "pkg:version:minor",
+      "pkg:version:major",
+      "pkg:login",
+      "pkg:logout",
+      "pkg:config:list",
+      "pkg:whoami",
+      "pkg:info",
+      "pkg:search",
+      "pkg:init"
+    ])
+  },
   {
     id: "setup",
     icon: "\u2699\uFE0F",
@@ -864,7 +921,12 @@ var toolFlags = {
     { value: "--yes", label: "--yes", hint: "Skip confirmation prompts" },
     { value: "--debug", label: "--debug", hint: "Debug mode" }
   ],
-  git: []
+  git: [],
+  pkg: [
+    { value: "--save-dev", label: "--save-dev", hint: "Save as dev dependency" },
+    { value: "--global", label: "--global", hint: "Install globally" },
+    { value: "--dry-run", label: "--dry-run", hint: "Show what would happen" }
+  ]
 };
 function getFlagsForTool(toolId) {
   return toolFlags[toolId] ?? globalFlags;
@@ -923,20 +985,20 @@ function resolveSupabaseCommand(startDir = process.cwd(), env = process.env) {
     localBinDir
   };
 }
-async function runCommand(execution, args, cwd = process.cwd(), options) {
-  return new Promise((resolve3) => {
-    let stdout = "";
-    let stderr = "";
-    const resolvedExecution = typeof execution === "string" ? { command: execution } : execution;
-    const child = spawn(resolvedExecution.command, args, {
-      cwd,
-      env: resolvedExecution.env,
-      shell: true,
-      stdio: [options?.quiet ? "pipe" : "inherit", "pipe", "pipe"]
-    });
-    if (options?.quiet) {
-      child.stdin?.end();
-    }
+function runCommand(execution, args, cwd = process.cwd(), options) {
+  let stdout = "";
+  let stderr = "";
+  const resolvedExecution = typeof execution === "string" ? { command: execution } : execution;
+  const child = spawn(resolvedExecution.command, args, {
+    cwd,
+    env: resolvedExecution.env,
+    shell: true,
+    stdio: [options?.quiet ? "pipe" : "inherit", "pipe", "pipe"]
+  });
+  if (options?.quiet) {
+    child.stdin?.end();
+  }
+  const promise = new Promise((resolve3) => {
     child.stdout?.on("data", (data) => {
       const text = data.toString();
       stdout += text;
@@ -960,6 +1022,10 @@ async function runCommand(execution, args, cwd = process.cwd(), options) {
       resolve3({ exitCode: code, signal, stdout, stderr });
     });
   });
+  return {
+    promise,
+    abort: () => child.kill("SIGTERM")
+  };
 }
 function runInteractiveCommand(execution, args, cwd = process.cwd()) {
   const resolved = typeof execution === "string" ? { command: execution } : execution;
@@ -978,12 +1044,126 @@ function runInteractiveCommand(execution, args, cwd = process.cwd()) {
   };
 }
 async function runSupabaseCommand(args, cwd = process.cwd()) {
-  return runCommand(resolveSupabaseCommand(cwd), args, cwd);
+  return runCommand(resolveSupabaseCommand(cwd), args, cwd).promise;
+}
+
+// src/lib/pkgManager.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+var LOCK_FILES = [
+  { file: "bun.lockb", id: "bun" },
+  { file: "bun.lock", id: "bun" },
+  { file: "pnpm-lock.yaml", id: "pnpm" },
+  { file: "yarn.lock", id: "yarn" },
+  { file: "package-lock.json", id: "npm" }
+];
+var MANAGER_META = {
+  npm: { lockFile: "package-lock.json", command: "npm" },
+  pnpm: { lockFile: "pnpm-lock.yaml", command: "pnpm" },
+  yarn: { lockFile: "yarn.lock", command: "yarn" },
+  bun: { lockFile: "bun.lockb", command: "bun" }
+};
+function detectPkgManager(cwd = process.cwd()) {
+  let dir = cwd;
+  const root = dirname2(dir) === dir ? dir : void 0;
+  while (true) {
+    for (const { file, id } of LOCK_FILES) {
+      if (existsSync2(join2(dir, file))) {
+        const meta = MANAGER_META[id];
+        return { id, lockFile: meta.lockFile, command: meta.command };
+      }
+    }
+    const parent = dirname2(dir);
+    if (parent === dir || parent === root) break;
+    dir = parent;
+  }
+  return { id: "npm", lockFile: "package-lock.json", command: "npm" };
+}
+var TRANSLATIONS = {
+  "install": {},
+  // same for all
+  "add": {
+    npm: ["install"]
+  },
+  "remove": {
+    npm: ["uninstall"]
+  },
+  "run": {},
+  // same for all
+  "publish": {
+    bun: null
+  },
+  "audit": {
+    bun: null
+  },
+  "outdated": {
+    bun: null
+  },
+  "ls": {
+    yarn: ["list"],
+    bun: null
+  },
+  "pack": {
+    bun: null
+  },
+  "version": {},
+  // same for all
+  "login": {
+    bun: null
+  },
+  "logout": {
+    bun: null
+  },
+  "config": {},
+  // same for all
+  "whoami": {
+    bun: null
+  },
+  "info": {
+    npm: ["info"],
+    pnpm: ["info"],
+    yarn: ["info"],
+    bun: null
+  },
+  "search": {
+    pnpm: null,
+    yarn: null,
+    bun: null
+  },
+  "init": {}
+  // same for all
+};
+var UnsupportedCommandError = class extends Error {
+  constructor(command, manager) {
+    super(`"${command}" is not supported by ${manager}`);
+    this.name = "UnsupportedCommandError";
+  }
+};
+function translateCommand(base, manager) {
+  const [subcommand, ...rest] = base;
+  if (!subcommand) {
+    return { command: manager, args: [] };
+  }
+  const translation = TRANSLATIONS[subcommand];
+  if (translation) {
+    const managerEntry = translation[manager];
+    if (managerEntry === null) {
+      throw new UnsupportedCommandError(subcommand, manager);
+    }
+    if (managerEntry !== void 0) {
+      return { command: manager, args: [...managerEntry, ...rest] };
+    }
+  }
+  return { command: manager, args: [subcommand, ...rest] };
+}
+function resolvePkgArgs(base, cwd = process.cwd()) {
+  const mgr = detectPkgManager(cwd);
+  return translateCommand(base, mgr.id);
 }
 
 // src/lib/toolResolver.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { join as join3 } from "path";
 
 // src/lib/system.ts
 import { execSync } from "child_process";
@@ -1012,6 +1192,13 @@ function resolveToolCommand(toolId, cwd = process.cwd()) {
       source: resolved.source
     };
   }
+  if (toolId === "pkg") {
+    const mgr = detectPkgManager(cwd);
+    if (!commandExists(mgr.command)) {
+      return { command: mgr.command, source: "not-found" };
+    }
+    return { command: mgr.command, env: { ...process.env }, source: "path" };
+  }
   const command = toolId;
   if (!commandExists(command)) {
     return { command, source: "not-found" };
@@ -1029,6 +1216,10 @@ function getToolVersion(toolId) {
         return execCapture("vercel --version").split("\n")[0]?.trim();
       case "git":
         return execCapture("git --version").replace(/^git version\s+/i, "").trim();
+      case "pkg": {
+        const mgr = detectPkgManager();
+        return execCapture(`${mgr.command} --version`).split("\n")[0]?.trim();
+      }
       default:
         return void 0;
     }
@@ -1044,9 +1235,11 @@ function getToolInfo(toolId) {
     supabase: "Supabase CLI",
     gh: "GitHub CLI",
     vercel: "Vercel CLI",
-    git: "Git"
+    git: "Git",
+    pkg: "Package Manager"
   };
-  const installed = commandExists(toolId === "supabase" ? "supabase" : toolId);
+  const commandName = toolId === "supabase" ? "supabase" : toolId === "pkg" ? detectPkgManager().command : toolId;
+  const installed = commandExists(commandName);
   const version = installed ? getToolVersion(toolId) : void 0;
   const info = {
     id: toolId,
@@ -1059,8 +1252,8 @@ function getToolInfo(toolId) {
 }
 function detectSupabaseLink(cwd) {
   try {
-    const configPath = join2(cwd, ".supabase", "config.toml");
-    if (existsSync2(configPath)) {
+    const configPath = join3(cwd, ".supabase", "config.toml");
+    if (existsSync3(configPath)) {
       const content = readFileSync(configPath, "utf-8");
       const match = content.match(/project_id\s*=\s*"([^"]+)"/);
       return { linked: true, project: match?.[1] };
@@ -1071,8 +1264,8 @@ function detectSupabaseLink(cwd) {
 }
 function detectVercelLink(cwd) {
   try {
-    const projectPath = join2(cwd, ".vercel", "project.json");
-    if (existsSync2(projectPath)) {
+    const projectPath = join3(cwd, ".vercel", "project.json");
+    if (existsSync3(projectPath)) {
       const data = JSON.parse(readFileSync(projectPath, "utf-8"));
       return { linked: true, project: data.projectId };
     }
@@ -1080,6 +1273,18 @@ function detectVercelLink(cwd) {
   }
   return { linked: false };
 }
+function detectPkgLink(cwd) {
+  try {
+    const pkgPath = join3(cwd, "package.json");
+    if (existsSync3(pkgPath)) {
+      const data = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      const mgr = detectPkgManager(cwd);
+      return { linked: true, project: data.name ? `${data.name} (${mgr.id})` : mgr.id };
+    }
+  } catch {
+  }
+  return { linked: false };
+}
 function detectGhLink(cwd) {
   try {
     const remote = execCapture(`git -C "${cwd}" remote get-url origin 2>/dev/null`);
@@ -1108,6 +1313,9 @@ function getToolLinkInfo(toolId, cwd = process.cwd()) {
       case "gh":
         linkStatus = detectGhLink(cwd);
         break;
+      case "pkg":
+        linkStatus = detectPkgLink(cwd);
+        break;
     }
   }
   const info = { ...base, ...linkStatus };
@@ -1115,6 +1323,194 @@ function getToolLinkInfo(toolId, cwd = process.cwd()) {
   return info;
 }
 
+// src/lib/processManager.ts
+import { spawn as spawn2 } from "child_process";
+var DEFAULT_BUFFER_CAP = 1e3;
+function createRingBuffer(cap = DEFAULT_BUFFER_CAP) {
+  return { lines: [], cap, totalLines: 0 };
+}
+function appendToBuffer(buf, data) {
+  const newLines = data.split("\n");
+  if (newLines.length > 0 && newLines[newLines.length - 1] === "") {
+    newLines.pop();
+  }
+  if (newLines.length === 0) return;
+  buf.lines.push(...newLines);
+  buf.totalLines += newLines.length;
+  if (buf.lines.length > buf.cap) {
+    buf.lines.splice(0, buf.lines.length - buf.cap);
+  }
+}
+function tailBuffer(buf, n) {
+  if (n === void 0 || n >= buf.lines.length) return [...buf.lines];
+  return buf.lines.slice(-n);
+}
+var registry = /* @__PURE__ */ new Map();
+var cleanupRegistered = false;
+function registerCleanup() {
+  if (cleanupRegistered) return;
+  cleanupRegistered = true;
+  const cleanup = () => {
+    for (const proc of registry.values()) {
+      if (proc.status === "running" && proc.child.pid) {
+        try {
+          process.kill(-proc.child.pid, "SIGKILL");
+        } catch {
+        }
+      }
+    }
+  };
+  process.on("exit", cleanup);
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(143);
+  });
+}
+function generateProcessId(command, args) {
+  const slug = [command, ...args].join("-").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+  if (!registry.has(slug)) return slug;
+  let i = 2;
+  while (registry.has(`${slug}-${i}`)) i++;
+  return `${slug}-${i}`;
+}
+function startProcess(id, command, args = [], cwd = process.cwd(), env) {
+  const existing = registry.get(id);
+  if (existing && existing.status === "running") {
+    throw new Error(`Process "${id}" is already running (pid ${existing.child.pid})`);
+  }
+  registerCleanup();
+  const child = spawn2(command, args, {
+    cwd,
+    env: env ?? process.env,
+    detached: true,
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: true
+  });
+  const tracked = {
+    id,
+    command,
+    args,
+    cwd,
+    child,
+    status: "running",
+    exitCode: null,
+    signal: null,
+    startedAt: /* @__PURE__ */ new Date(),
+    exitedAt: null,
+    stdout: createRingBuffer(),
+    stderr: createRingBuffer()
+  };
+  child.stdout?.on("data", (data) => {
+    appendToBuffer(tracked.stdout, data.toString());
+  });
+  child.stderr?.on("data", (data) => {
+    appendToBuffer(tracked.stderr, data.toString());
+  });
+  child.on("exit", (code, signal) => {
+    tracked.status = "exited";
+    tracked.exitCode = code;
+    tracked.signal = signal;
+    tracked.exitedAt = /* @__PURE__ */ new Date();
+  });
+  child.on("error", (err) => {
+    tracked.status = "errored";
+    tracked.exitedAt = /* @__PURE__ */ new Date();
+    appendToBuffer(tracked.stderr, `spawn error: ${err.message}
+`);
+  });
+  registry.set(id, tracked);
+  return toProcessInfo(tracked);
+}
+function stopProcess(id) {
+  const proc = registry.get(id);
+  if (!proc) throw new Error(`No tracked process with id "${id}"`);
+  if (proc.status !== "running") return Promise.resolve(toProcessInfo(proc));
+  return new Promise((resolve3) => {
+    const escalateTimer = setTimeout(() => {
+      if (proc.status === "running" && proc.child.pid) {
+        try {
+          process.kill(-proc.child.pid, "SIGKILL");
+        } catch {
+        }
+      }
+    }, 5e3);
+    const onDone = () => {
+      clearTimeout(escalateTimer);
+      resolve3(toProcessInfo(proc));
+    };
+    proc.child.once("exit", onDone);
+    if (proc.child.pid) {
+      try {
+        process.kill(-proc.child.pid, "SIGTERM");
+      } catch {
+      }
+    }
+    if (proc.status !== "running") {
+      clearTimeout(escalateTimer);
+      proc.child.removeListener("exit", onDone);
+      resolve3(toProcessInfo(proc));
+    }
+  });
+}
+function listProcesses() {
+  return Array.from(registry.values()).map(toProcessInfo);
+}
+function getProcessOutput(id, tail, stream) {
+  const proc = registry.get(id);
+  if (!proc) throw new Error(`No tracked process with id "${id}"`);
+  const which = stream ?? "both";
+  return {
+    stdout: which === "stderr" ? [] : tailBuffer(proc.stdout, tail),
+    stderr: which === "stdout" ? [] : tailBuffer(proc.stderr, tail),
+    stdoutLineCount: proc.stdout.totalLines,
+    stderrLineCount: proc.stderr.totalLines
+  };
+}
+function isProcessRunning(id) {
+  const proc = registry.get(id);
+  if (!proc) return false;
+  if (proc.status !== "running") return false;
+  if (proc.child.pid) {
+    try {
+      process.kill(proc.child.pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function removeProcess(id) {
+  const proc = registry.get(id);
+  if (!proc) throw new Error(`No tracked process with id "${id}"`);
+  if (proc.status === "running") {
+    throw new Error(`Cannot remove running process "${id}". Stop it first.`);
+  }
+  registry.delete(id);
+}
+function toProcessInfo(proc) {
+  const now = Date.now();
+  const start = proc.startedAt.getTime();
+  const end = proc.exitedAt ? proc.exitedAt.getTime() : now;
+  return {
+    id: proc.id,
+    command: proc.command,
+    args: proc.args,
+    cwd: proc.cwd,
+    pid: proc.child.pid,
+    status: proc.status,
+    exitCode: proc.exitCode,
+    signal: proc.signal,
+    startedAt: proc.startedAt.toISOString(),
+    exitedAt: proc.exitedAt?.toISOString() ?? null,
+    uptime: end - start
+  };
+}
+
 // src/pipeline/engine.ts
 async function executePipeline(pipeline, onProgress, cwd = process.cwd()) {
   const stepResults = pipeline.steps.map((step) => ({
@@ -1134,13 +1530,20 @@ async function executePipeline(pipeline, onProgress, cwd = process.cwd()) {
     const cmdDef = getCommandById(step.commandId);
     const toolId = cmdDef?.tool ?? "supabase";
     const resolved = resolveToolCommand(toolId, cwd);
-    const baseArgs = cmdDef?.base ?? [];
+    let baseArgs = cmdDef?.base ?? [];
+    if (toolId === "pkg" && cmdDef) {
+      try {
+        const translated = resolvePkgArgs(cmdDef.base, cwd);
+        baseArgs = translated.args;
+      } catch {
+      }
+    }
     const allArgs = [...baseArgs, ...step.args, ...step.flags];
     const result = await runCommand(
       { command: resolved.command, env: resolved.env },
       allArgs,
       cwd
-    );
+    ).promise;
     const success = !result.spawnError && result.exitCode === 0;
     stepResults[i] = {
       step,
@@ -1161,23 +1564,23 @@ async function executePipeline(pipeline, onProgress, cwd = process.cwd()) {
 }
 
 // src/config/projectConfig.ts
-import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
+import { join as join5 } from "path";
 
 // src/lib/packageRoot.ts
-import { existsSync as existsSync3 } from "fs";
-import { dirname as dirname2, join as join3, resolve as resolve2 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { dirname as dirname3, join as join4, resolve as resolve2 } from "path";
 var rootCache = /* @__PURE__ */ new Map();
 function findNearestPackageRoot(startDir = process.cwd()) {
   const resolvedStart = resolve2(startDir);
   if (rootCache.has(resolvedStart)) return rootCache.get(resolvedStart);
   let currentDir = resolvedStart;
   while (true) {
-    if (existsSync3(join3(currentDir, "package.json"))) {
+    if (existsSync4(join4(currentDir, "package.json"))) {
       rootCache.set(resolvedStart, currentDir);
       return currentDir;
     }
-    const parentDir = dirname2(currentDir);
+    const parentDir = dirname3(currentDir);
     if (parentDir === currentDir) {
       rootCache.set(resolvedStart, void 0);
       return void 0;
@@ -1199,13 +1602,13 @@ function defaultConfig() {
 function getProjectConfigPath(startDir) {
   const root = findNearestPackageRoot(startDir);
   if (!root) return void 0;
-  const dir = join4(root, CONFIG_DIR);
-  return { dir, file: join4(dir, CONFIG_FILE) };
+  const dir = join5(root, CONFIG_DIR);
+  return { dir, file: join5(dir, CONFIG_FILE) };
 }
 function readProjectConfig(startDir) {
   const paths = getProjectConfigPath(startDir);
   if (!paths) return void 0;
-  if (!existsSync4(paths.file)) return void 0;
+  if (!existsSync5(paths.file)) return void 0;
   try {
     const raw = readFileSync2(paths.file, "utf-8");
     return JSON.parse(raw);
@@ -1306,8 +1709,8 @@ function findPipelineByName(name, startDir) {
 }
 
 // src/declarative/parser.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
+import { join as join6 } from "path";
 var YAML_FILE = "polter.yaml";
 function parseSimpleYaml(content) {
   const lines = content.split("\n");
@@ -1379,8 +1782,8 @@ function parseValue(raw) {
   return raw;
 }
 function findPolterYaml(startDir = process.cwd()) {
-  const filePath = join5(startDir, YAML_FILE);
-  return existsSync5(filePath) ? filePath : void 0;
+  const filePath = join6(startDir, YAML_FILE);
+  return existsSync6(filePath) ? filePath : void 0;
 }
 function parsePolterYaml(startDir = process.cwd()) {
   const filePath = findPolterYaml(startDir);
@@ -1517,13 +1920,258 @@ async function applyActions(actions, cwd = process.cwd(), onProgress) {
       { command: resolved.command, env: resolved.env },
       action.args,
       cwd
-    );
+    ).promise;
     const success = !result.spawnError && result.exitCode === 0;
     results.push({ action, success, result });
   }
   return results;
 }
 
+// src/lib/mcpInstaller.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync7 } from "fs";
+import { join as join7, dirname as dirname4 } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+import pc from "picocolors";
+var __dirname = dirname4(fileURLToPath(import.meta.url));
+function readPkgVersion() {
+  for (const rel of ["../../package.json", "../package.json"]) {
+    const p = join7(__dirname, rel);
+    if (existsSync7(p)) {
+      const pkg = JSON.parse(readFileSync4(p, "utf-8"));
+      return pkg.version;
+    }
+  }
+  return "0.0.0";
+}
+var MCP_ARGS = ["npx", "-y", "-p", "@polterware/polter@latest", "polter-mcp"];
+var SCOPE_LABELS = {
+  local: "local (this machine)",
+  project: "project (shared via repo)",
+  user: "global (all projects)"
+};
+function tryClaudeCli(scope) {
+  if (!commandExists("claude")) return false;
+  const result = spawnSync2("claude", ["mcp", "add", "-s", scope, "polter", "--", ...MCP_ARGS], {
+    stdio: "inherit",
+    shell: true
+  });
+  return result.status === 0;
+}
+function getSettingsPath(scope) {
+  if (scope === "project") {
+    return join7(process.cwd(), ".mcp.json");
+  }
+  return join7(homedir(), ".claude", "settings.json");
+}
+function tryManualInstall(scope) {
+  const settingsPath = getSettingsPath(scope);
+  const dir = join7(settingsPath, "..");
+  let settings = {};
+  if (existsSync7(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+    } catch {
+      process.stderr.write(pc.red(`Failed to parse ${settingsPath}
+`));
+      return false;
+    }
+  } else {
+    mkdirSync2(dir, { recursive: true });
+  }
+  const mcpServers = settings.mcpServers ?? {};
+  mcpServers.polter = {
+    command: "npx",
+    args: ["-y", "-p", "@polterware/polter@latest", "polter-mcp"]
+  };
+  settings.mcpServers = mcpServers;
+  writeFileSync2(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  return true;
+}
+async function installMcpServer(scope) {
+  process.stdout.write(pc.bold(`Installing Polter MCP server \u2014 ${SCOPE_LABELS[scope]}
+
+`));
+  if (commandExists("claude")) {
+    process.stdout.write(`  Using 'claude mcp add -s ${scope}'...
+`);
+    if (tryClaudeCli(scope)) {
+      process.stdout.write(pc.green("\n  Done! Restart Claude Code to use Polter tools.\n"));
+      return;
+    }
+    process.stdout.write(pc.yellow("  'claude mcp add' failed, falling back to manual install...\n\n"));
+  }
+  const settingsPath = getSettingsPath(scope);
+  process.stdout.write(`  Writing to ${settingsPath}...
+`);
+  if (tryManualInstall(scope)) {
+    process.stdout.write(pc.green("\n  Done! Restart Claude Code to use Polter tools.\n"));
+  } else {
+    process.stderr.write(pc.red("\n  Failed to install. Add manually:\n\n"));
+    process.stderr.write(`  ${pc.dim(JSON.stringify({ mcpServers: { polter: { command: "npx", args: ["-y", "-p", "@polterware/polter@latest", "polter-mcp"] } } }, null, 2))}
+`);
+    process.exit(1);
+  }
+}
+async function removeMcpServer(scope) {
+  process.stdout.write(pc.bold(`Removing Polter MCP server \u2014 ${SCOPE_LABELS[scope]}
+
+`));
+  if (commandExists("claude")) {
+    const result = spawnSync2("claude", ["mcp", "remove", "-s", scope, "polter"], {
+      stdio: "inherit",
+      shell: true
+    });
+    if (result.status === 0) {
+      process.stdout.write(pc.green("\n  Done! Polter MCP server removed.\n"));
+      return;
+    }
+    process.stdout.write(pc.yellow("  'claude mcp remove' failed, falling back to manual removal...\n\n"));
+  }
+  const settingsPath = getSettingsPath(scope);
+  if (!existsSync7(settingsPath)) {
+    process.stdout.write(pc.yellow("  No settings file found. Nothing to remove.\n"));
+    return;
+  }
+  let settings;
+  try {
+    settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+  } catch {
+    process.stderr.write(pc.red(`  Failed to parse ${settingsPath}
+`));
+    process.exit(1);
+    return;
+  }
+  const mcpServers = settings.mcpServers;
+  if (!mcpServers?.polter) {
+    process.stdout.write(pc.yellow("  Polter MCP server not found in settings. Nothing to remove.\n"));
+    return;
+  }
+  delete mcpServers.polter;
+  settings.mcpServers = mcpServers;
+  writeFileSync2(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  process.stdout.write(pc.green("  Done! Polter MCP server removed.\n"));
+}
+function getMcpStatusInfo() {
+  const version = readPkgVersion();
+  const scopeDefs = [
+    { label: "Project (.mcp.json)", path: join7(process.cwd(), ".mcp.json"), scope: "project" },
+    { label: "User (~/.claude/settings.json)", path: join7(homedir(), ".claude", "settings.json"), scope: "user" }
+  ];
+  const scopes = scopeDefs.map((s) => {
+    if (!existsSync7(s.path)) {
+      return { label: s.label, scope: s.scope, registered: false };
+    }
+    try {
+      const settings = JSON.parse(readFileSync4(s.path, "utf-8"));
+      const mcpServers = settings.mcpServers;
+      return { label: s.label, scope: s.scope, registered: !!mcpServers?.polter };
+    } catch {
+      return { label: s.label, scope: s.scope, registered: false, error: "error reading file" };
+    }
+  });
+  return { installedVersion: version, latestVersion: null, scopes };
+}
+async function installMcpServerSilent(scope) {
+  const messages = [];
+  messages.push(`Installing Polter MCP server \u2014 ${SCOPE_LABELS[scope]}`);
+  if (commandExists("claude")) {
+    messages.push(`Using 'claude mcp add -s ${scope}'...`);
+    if (tryClaudeCli(scope)) {
+      messages.push("Done! Restart Claude Code to use Polter tools.");
+      return { success: true, message: messages.join("\n") };
+    }
+    messages.push("'claude mcp add' failed, falling back to manual install...");
+  }
+  const settingsPath = getSettingsPath(scope);
+  messages.push(`Writing to ${settingsPath}...`);
+  if (tryManualInstall(scope)) {
+    messages.push("Done! Restart Claude Code to use Polter tools.");
+    return { success: true, message: messages.join("\n") };
+  }
+  return { success: false, message: "Failed to install. Try manual installation." };
+}
+async function removeMcpServerSilent(scope) {
+  const messages = [];
+  messages.push(`Removing Polter MCP server \u2014 ${SCOPE_LABELS[scope]}`);
+  if (commandExists("claude")) {
+    const result = spawnSync2("claude", ["mcp", "remove", "-s", scope, "polter"], {
+      encoding: "utf-8",
+      shell: true
+    });
+    if (result.status === 0) {
+      messages.push("Done! Polter MCP server removed.");
+      return { success: true, message: messages.join("\n") };
+    }
+    messages.push("'claude mcp remove' failed, falling back to manual removal...");
+  }
+  const settingsPath = getSettingsPath(scope);
+  if (!existsSync7(settingsPath)) {
+    messages.push("No settings file found. Nothing to remove.");
+    return { success: true, message: messages.join("\n") };
+  }
+  let settings;
+  try {
+    settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+  } catch {
+    return { success: false, message: `Failed to parse ${settingsPath}` };
+  }
+  const mcpServers = settings.mcpServers;
+  if (!mcpServers?.polter) {
+    messages.push("Polter MCP server not found in settings. Nothing to remove.");
+    return { success: true, message: messages.join("\n") };
+  }
+  delete mcpServers.polter;
+  settings.mcpServers = mcpServers;
+  writeFileSync2(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  messages.push("Done! Polter MCP server removed.");
+  return { success: true, message: messages.join("\n") };
+}
+async function mcpStatus() {
+  process.stdout.write(pc.bold("Polter MCP Server Status\n\n"));
+  const pkgVersion = readPkgVersion();
+  process.stdout.write(`  Installed version: ${pc.cyan(pkgVersion)}
+`);
+  const latestResult = spawnSync2("npm", ["view", "@polterware/polter", "version"], {
+    encoding: "utf-8",
+    shell: true,
+    timeout: 1e4
+  });
+  const latest = latestResult.stdout?.trim();
+  if (latest) {
+    const upToDate = latest === pkgVersion;
+    process.stdout.write(`  Latest version:    ${upToDate ? pc.green(latest) : pc.yellow(`${latest} (update available)`)}
+`);
+  }
+  process.stdout.write("\n");
+  const scopes = [
+    { label: "Project (.mcp.json)", path: join7(process.cwd(), ".mcp.json"), key: "project" },
+    { label: "User (~/.claude/settings.json)", path: join7(homedir(), ".claude", "settings.json"), key: "user" }
+  ];
+  for (const scope of scopes) {
+    if (!existsSync7(scope.path)) {
+      process.stdout.write(`  ${scope.label}: ${pc.dim("not found")}
+`);
+      continue;
+    }
+    try {
+      const settings = JSON.parse(readFileSync4(scope.path, "utf-8"));
+      const mcpServers = settings.mcpServers;
+      if (mcpServers?.polter) {
+        process.stdout.write(`  ${scope.label}: ${pc.green("registered")}
+`);
+      } else {
+        process.stdout.write(`  ${scope.label}: ${pc.dim("not registered")}
+`);
+      }
+    } catch {
+      process.stdout.write(`  ${scope.label}: ${pc.red("error reading file")}
+`);
+    }
+  }
+}
+
 export {
   __export,
   allCommands,
@@ -1539,9 +2187,19 @@ export {
   runInteractiveCommand,
   runSupabaseCommand,
   commandExists,
+  detectPkgManager,
+  translateCommand,
+  resolvePkgArgs,
   resolveToolCommand,
   getToolInfo,
   getToolLinkInfo,
+  generateProcessId,
+  startProcess,
+  stopProcess,
+  listProcesses,
+  getProcessOutput,
+  isProcessRunning,
+  removeProcess,
   executePipeline,
   findNearestPackageRoot,
   getProjectConfigPath,
@@ -1551,8 +2209,15 @@ export {
   savePipeline,
   deletePipeline,
   findPipelineByName,
+  findPolterYaml,
   parsePolterYaml,
   getCurrentStatus,
   planChanges,
-  applyActions
+  applyActions,
+  installMcpServer,
+  removeMcpServer,
+  getMcpStatusInfo,
+  installMcpServerSilent,
+  removeMcpServerSilent,
+  mcpStatus
 };