@polterware/polter 0.4.1 → 0.5.0

package/dist/chunk-ZHVOYB5M.js

@@ -1,2447 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/data/commands/supabase.ts
-var supabaseCommands = [
-  // Quick Start
-  {
-    id: "supabase:bootstrap",
-    tool: "supabase",
-    base: ["bootstrap"],
-    label: "bootstrap",
-    hint: "Bootstrap from a starter template",
-    interactive: true
-  },
-  {
-    id: "supabase:init",
-    tool: "supabase",
-    base: ["init"],
-    label: "init",
-    hint: "Initialize a local project",
-    interactive: true
-  },
-  {
-    id: "supabase:login",
-    tool: "supabase",
-    base: ["login"],
-    label: "login",
-    hint: "Authenticate with access token",
-    interactive: true
-  },
-  {
-    id: "supabase:logout",
-    tool: "supabase",
-    base: ["logout"],
-    label: "logout",
-    hint: "Remove local auth token"
-  },
-  // Local Dev
-  {
-    id: "supabase:start",
-    tool: "supabase",
-    base: ["start"],
-    label: "start",
-    hint: "Start local Supabase containers"
-  },
-  {
-    id: "supabase:stop",
-    tool: "supabase",
-    base: ["stop"],
-    label: "stop",
-    hint: "Stop local Supabase containers"
-  },
-  {
-    id: "supabase:status",
-    tool: "supabase",
-    base: ["status"],
-    label: "status",
-    hint: "Show container status"
-  },
-  {
-    id: "supabase:db",
-    tool: "supabase",
-    base: ["db"],
-    label: "db",
-    hint: "Manage Postgres databases",
-    suggestedArgs: [
-      { value: "pull", label: "pull", hint: "Pull schema from remote", args: ["pull"] },
-      { value: "push", label: "push", hint: "Push local migrations", args: ["push"] },
-      { value: "reset", label: "reset", hint: "Reset local database", args: ["reset"] },
-      { value: "dump", label: "dump", hint: "Dump schema/data", args: ["dump"] },
-      { value: "diff", label: "diff", hint: "Show migration diff", args: ["diff"] },
-      { value: "lint", label: "lint", hint: "Lint SQL migrations", args: ["lint"] }
-    ]
-  },
-  {
-    id: "supabase:migration",
-    tool: "supabase",
-    base: ["migration"],
-    label: "migration",
-    hint: "Manage migration scripts",
-    suggestedArgs: [
-      { value: "new", label: "new <name>", hint: "Create migration file", args: ["new"] },
-      { value: "up", label: "up", hint: "Apply pending migrations", args: ["up"] },
-      { value: "down", label: "down", hint: "Rollback last migration", args: ["down"] },
-      { value: "list", label: "list", hint: "List local migrations", args: ["list"] },
-      { value: "repair", label: "repair", hint: "Repair migration history", args: ["repair"] },
-      { value: "fetch", label: "fetch", hint: "Fetch migration history", args: ["fetch"] }
-    ]
-  },
-  {
-    id: "supabase:seed",
-    tool: "supabase",
-    base: ["seed"],
-    label: "seed",
-    hint: "Seed from config.toml",
-    suggestedArgs: [
-      { value: "run", label: "run", hint: "Run configured seed file", args: ["run"] }
-    ]
-  },
-  {
-    id: "supabase:test",
-    tool: "supabase",
-    base: ["test"],
-    label: "test",
-    hint: "Run tests on local stack"
-  },
-  // Inspect & Generate
-  {
-    id: "supabase:inspect",
-    tool: "supabase",
-    base: ["inspect"],
-    label: "inspect",
-    hint: "Inspect project resources"
-  },
-  {
-    id: "supabase:gen",
-    tool: "supabase",
-    base: ["gen"],
-    label: "gen",
-    hint: "Run code generation tools"
-  },
-  {
-    id: "supabase:services",
-    tool: "supabase",
-    base: ["services"],
-    label: "services",
-    hint: "Show service versions"
-  },
-  {
-    id: "supabase:link",
-    tool: "supabase",
-    base: ["link"],
-    label: "link",
-    hint: "Link to remote project",
-    interactive: true
-  },
-  {
-    id: "supabase:unlink",
-    tool: "supabase",
-    base: ["unlink"],
-    label: "unlink",
-    hint: "Unlink remote project"
-  },
-  // Cloud Management
-  {
-    id: "supabase:projects",
-    tool: "supabase",
-    base: ["projects"],
-    label: "projects",
-    hint: "Manage Supabase projects",
-    suggestedArgs: [
-      { value: "list", label: "list", hint: "List projects", args: ["list"] },
-      { value: "create", label: "create", hint: "Create project", args: ["create"] },
-      { value: "delete", label: "delete", hint: "Delete project", args: ["delete"] }
-    ]
-  },
-  {
-    id: "supabase:functions",
-    tool: "supabase",
-    base: ["functions"],
-    label: "functions",
-    hint: "Manage Edge Functions",
-    suggestedArgs: [
-      { value: "list", label: "list", hint: "List functions", args: ["list"] },
-      { value: "new", label: "new <name>", hint: "Create a function", args: ["new"] },
-      { value: "serve", label: "serve", hint: "Serve functions locally", args: ["serve"] },
-      { value: "deploy", label: "deploy <name>", hint: "Deploy function", args: ["deploy"] },
-      { value: "delete", label: "delete <name>", hint: "Delete function", args: ["delete"] }
-    ]
-  },
-  {
-    id: "supabase:secrets",
-    tool: "supabase",
-    base: ["secrets"],
-    label: "secrets",
-    hint: "Manage project secrets"
-  },
-  {
-    id: "supabase:config",
-    tool: "supabase",
-    base: ["config"],
-    label: "config",
-    hint: "Manage project configuration"
-  },
-  {
-    id: "supabase:storage",
-    tool: "supabase",
-    base: ["storage"],
-    label: "storage",
-    hint: "Manage Storage objects",
-    suggestedArgs: [
-      { value: "ls", label: "ls", hint: "List storage objects", args: ["ls"] },
-      { value: "cp", label: "cp", hint: "Copy storage object", args: ["cp"] },
-      { value: "mv", label: "mv", hint: "Move storage object", args: ["mv"] },
-      { value: "rm", label: "rm", hint: "Remove storage object", args: ["rm"] }
-    ]
-  },
-  // Networking & Security
-  {
-    id: "supabase:domains",
-    tool: "supabase",
-    base: ["domains"],
-    label: "domains",
-    hint: "Manage custom domains"
-  },
-  {
-    id: "supabase:ssl-enforcement",
-    tool: "supabase",
-    base: ["ssl-enforcement"],
-    label: "ssl-enforcement",
-    hint: "Manage SSL config"
-  },
-  {
-    id: "supabase:network-bans",
-    tool: "supabase",
-    base: ["network-bans"],
-    label: "network-bans",
-    hint: "Manage network bans"
-  },
-  {
-    id: "supabase:network-restrictions",
-    tool: "supabase",
-    base: ["network-restrictions"],
-    label: "network-restrictions",
-    hint: "Manage network restrictions"
-  },
-  {
-    id: "supabase:vanity-subdomains",
-    tool: "supabase",
-    base: ["vanity-subdomains"],
-    label: "vanity-subdomains",
-    hint: "Manage vanity subdomains"
-  },
-  {
-    id: "supabase:encryption",
-    tool: "supabase",
-    base: ["encryption"],
-    label: "encryption",
-    hint: "Manage encryption keys"
-  },
-  // Organizations & Admin
-  {
-    id: "supabase:orgs",
-    tool: "supabase",
-    base: ["orgs"],
-    label: "orgs",
-    hint: "Manage organizations",
-    suggestedArgs: [
-      { value: "list", label: "list", hint: "List organizations", args: ["list"] },
-      { value: "create", label: "create", hint: "Create organization", args: ["create"] }
-    ]
-  },
-  {
-    id: "supabase:sso",
-    tool: "supabase",
-    base: ["sso"],
-    label: "sso",
-    hint: "Manage Single Sign-On"
-  },
-  {
-    id: "supabase:branches",
-    tool: "supabase",
-    base: ["branches"],
-    label: "branches",
-    hint: "Manage preview branches"
-  },
-  {
-    id: "supabase:backups",
-    tool: "supabase",
-    base: ["backups"],
-    label: "backups",
-    hint: "Manage physical backups",
-    suggestedArgs: [
-      { value: "list", label: "list", hint: "List backups", args: ["list"] },
-      { value: "download", label: "download", hint: "Download backup", args: ["download"] }
-    ]
-  },
-  {
-    id: "supabase:snippets",
-    tool: "supabase",
-    base: ["snippets"],
-    label: "snippets",
-    hint: "Manage SQL snippets",
-    suggestedArgs: [
-      { value: "list", label: "list", hint: "List SQL snippets", args: ["list"] },
-      { value: "create", label: "create", hint: "Create SQL snippet", args: ["create"] },
-      { value: "delete", label: "delete", hint: "Delete SQL snippet", args: ["delete"] }
-    ]
-  },
-  {
-    id: "supabase:postgres-config",
-    tool: "supabase",
-    base: ["postgres-config"],
-    label: "postgres-config",
-    hint: "Manage Postgres config"
-  },
-  // Utilities
-  {
-    id: "supabase:completion",
-    tool: "supabase",
-    base: ["completion"],
-    label: "completion",
-    hint: "Generate shell completion script"
-  },
-  {
-    id: "supabase:help",
-    tool: "supabase",
-    base: ["help"],
-    label: "help",
-    hint: "Help about any command"
-  }
-];
-
-// src/data/commands/gh.ts
-var ghCommands = [
-  // Repository
-  {
-    id: "gh:repo:clone",
-    tool: "gh",
-    base: ["repo", "clone"],
-    label: "repo clone",
-    hint: "Clone a repository"
-  },
-  {
-    id: "gh:repo:create",
-    tool: "gh",
-    base: ["repo", "create"],
-    label: "repo create",
-    hint: "Create a new repository",
-    interactive: true
-  },
-  {
-    id: "gh:repo:view",
-    tool: "gh",
-    base: ["repo", "view"],
-    label: "repo view",
-    hint: "View repository details"
-  },
-  {
-    id: "gh:repo:list",
-    tool: "gh",
-    base: ["repo", "list"],
-    label: "repo list",
-    hint: "List your repositories"
-  },
-  // Pull Requests
-  {
-    id: "gh:pr:create",
-    tool: "gh",
-    base: ["pr", "create"],
-    label: "pr create",
-    hint: "Create a pull request"
-  },
-  {
-    id: "gh:pr:list",
-    tool: "gh",
-    base: ["pr", "list"],
-    label: "pr list",
-    hint: "List pull requests"
-  },
-  {
-    id: "gh:pr:view",
-    tool: "gh",
-    base: ["pr", "view"],
-    label: "pr view",
-    hint: "View a pull request"
-  },
-  {
-    id: "gh:pr:merge",
-    tool: "gh",
-    base: ["pr", "merge"],
-    label: "pr merge",
-    hint: "Merge a pull request"
-  },
-  {
-    id: "gh:pr:checkout",
-    tool: "gh",
-    base: ["pr", "checkout"],
-    label: "pr checkout",
-    hint: "Check out a pull request"
-  },
-  {
-    id: "gh:pr:review",
-    tool: "gh",
-    base: ["pr", "review"],
-    label: "pr review",
-    hint: "Review a pull request",
-    suggestedArgs: [
-      { value: "approve", label: "Approve", hint: "Approve the PR", args: ["--approve"] },
-      { value: "comment", label: "Comment", hint: "Leave a comment", args: ["--comment"] },
-      { value: "request-changes", label: "Request Changes", hint: "Request changes", args: ["--request-changes"] }
-    ]
-  },
-  // Issues
-  {
-    id: "gh:issue:create",
-    tool: "gh",
-    base: ["issue", "create"],
-    label: "issue create",
-    hint: "Create an issue"
-  },
-  {
-    id: "gh:issue:list",
-    tool: "gh",
-    base: ["issue", "list"],
-    label: "issue list",
-    hint: "List issues"
-  },
-  {
-    id: "gh:issue:view",
-    tool: "gh",
-    base: ["issue", "view"],
-    label: "issue view",
-    hint: "View an issue"
-  },
-  {
-    id: "gh:issue:close",
-    tool: "gh",
-    base: ["issue", "close"],
-    label: "issue close",
-    hint: "Close an issue"
-  },
-  // Workflows & Runs
-  {
-    id: "gh:workflow:list",
-    tool: "gh",
-    base: ["workflow", "list"],
-    label: "workflow list",
-    hint: "List workflows"
-  },
-  {
-    id: "gh:workflow:run",
-    tool: "gh",
-    base: ["workflow", "run"],
-    label: "workflow run",
-    hint: "Run a workflow"
-  },
-  {
-    id: "gh:workflow:view",
-    tool: "gh",
-    base: ["workflow", "view"],
-    label: "workflow view",
-    hint: "View a workflow"
-  },
-  {
-    id: "gh:run:list",
-    tool: "gh",
-    base: ["run", "list"],
-    label: "run list",
-    hint: "List workflow runs"
-  },
-  {
-    id: "gh:run:view",
-    tool: "gh",
-    base: ["run", "view"],
-    label: "run view",
-    hint: "View a workflow run"
-  },
-  {
-    id: "gh:run:watch",
-    tool: "gh",
-    base: ["run", "watch"],
-    label: "run watch",
-    hint: "Watch a workflow run"
-  },
-  // Releases
-  {
-    id: "gh:release:create",
-    tool: "gh",
-    base: ["release", "create"],
-    label: "release create",
-    hint: "Create a release"
-  },
-  {
-    id: "gh:release:list",
-    tool: "gh",
-    base: ["release", "list"],
-    label: "release list",
-    hint: "List releases"
-  },
-  {
-    id: "gh:release:view",
-    tool: "gh",
-    base: ["release", "view"],
-    label: "release view",
-    hint: "View a release"
-  },
-  // Auth
-  {
-    id: "gh:auth:login",
-    tool: "gh",
-    base: ["auth", "login"],
-    label: "auth login",
-    hint: "Log in to GitHub",
-    interactive: true
-  },
-  {
-    id: "gh:auth:status",
-    tool: "gh",
-    base: ["auth", "status"],
-    label: "auth status",
-    hint: "View auth status"
-  }
-];
-
-// src/data/commands/vercel.ts
-var vercelCommands = [
-  // Deploy
-  {
-    id: "vercel:deploy",
-    tool: "vercel",
-    base: ["deploy"],
-    label: "deploy",
-    hint: "Deploy to Vercel"
-  },
-  {
-    id: "vercel:deploy:prod",
-    tool: "vercel",
-    base: ["deploy", "--prod"],
-    label: "deploy --prod",
-    hint: "Deploy to production"
-  },
-  {
-    id: "vercel:promote",
-    tool: "vercel",
-    base: ["promote"],
-    label: "promote",
-    hint: "Promote a deployment"
-  },
-  {
-    id: "vercel:rollback",
-    tool: "vercel",
-    base: ["rollback"],
-    label: "rollback",
-    hint: "Rollback to previous deployment"
-  },
-  // Domains
-  {
-    id: "vercel:domains:list",
-    tool: "vercel",
-    base: ["domains", "ls"],
-    label: "domains ls",
-    hint: "List domains"
-  },
-  {
-    id: "vercel:domains:add",
-    tool: "vercel",
-    base: ["domains", "add"],
-    label: "domains add",
-    hint: "Add a domain"
-  },
-  {
-    id: "vercel:domains:rm",
-    tool: "vercel",
-    base: ["domains", "rm"],
-    label: "domains rm",
-    hint: "Remove a domain"
-  },
-  // Environment Variables
-  {
-    id: "vercel:env:ls",
-    tool: "vercel",
-    base: ["env", "ls"],
-    label: "env ls",
-    hint: "List environment variables"
-  },
-  {
-    id: "vercel:env:add",
-    tool: "vercel",
-    base: ["env", "add"],
-    label: "env add",
-    hint: "Add an environment variable"
-  },
-  {
-    id: "vercel:env:rm",
-    tool: "vercel",
-    base: ["env", "rm"],
-    label: "env rm",
-    hint: "Remove an environment variable"
-  },
-  {
-    id: "vercel:env:pull",
-    tool: "vercel",
-    base: ["env", "pull"],
-    label: "env pull",
-    hint: "Pull env vars to .env file"
-  },
-  // Project
-  {
-    id: "vercel:project:ls",
-    tool: "vercel",
-    base: ["project", "ls"],
-    label: "project ls",
-    hint: "List projects"
-  },
-  {
-    id: "vercel:project:add",
-    tool: "vercel",
-    base: ["project", "add"],
-    label: "project add",
-    hint: "Add a project"
-  },
-  {
-    id: "vercel:project:rm",
-    tool: "vercel",
-    base: ["project", "rm"],
-    label: "project rm",
-    hint: "Remove a project"
-  },
-  // Setup
-  {
-    id: "vercel:link",
-    tool: "vercel",
-    base: ["link"],
-    label: "link",
-    hint: "Link to a Vercel project",
-    interactive: true
-  },
-  {
-    id: "vercel:login",
-    tool: "vercel",
-    base: ["login"],
-    label: "login",
-    hint: "Log in to Vercel",
-    interactive: true
-  },
-  {
-    id: "vercel:whoami",
-    tool: "vercel",
-    base: ["whoami"],
-    label: "whoami",
-    hint: "Show current user"
-  },
-  // Logs & Inspect
-  {
-    id: "vercel:logs",
-    tool: "vercel",
-    base: ["logs"],
-    label: "logs",
-    hint: "View deployment logs"
-  },
-  {
-    id: "vercel:inspect",
-    tool: "vercel",
-    base: ["inspect"],
-    label: "inspect",
-    hint: "Inspect a deployment"
-  },
-  {
-    id: "vercel:ls",
-    tool: "vercel",
-    base: ["ls"],
-    label: "ls",
-    hint: "List deployments"
-  }
-];
-
-// src/data/commands/git.ts
-var gitCommands = [
-  { id: "git:status", tool: "git", base: ["status"], label: "status", hint: "Show working tree status" },
-  { id: "git:add", tool: "git", base: ["add"], label: "add", hint: "Stage changes" },
-  { id: "git:commit", tool: "git", base: ["commit"], label: "commit", hint: "Create a commit" },
-  { id: "git:push", tool: "git", base: ["push"], label: "push", hint: "Push to remote" },
-  { id: "git:pull", tool: "git", base: ["pull"], label: "pull", hint: "Pull from remote" },
-  { id: "git:checkout", tool: "git", base: ["checkout"], label: "checkout", hint: "Switch branches" },
-  { id: "git:branch", tool: "git", base: ["branch"], label: "branch", hint: "List or create branches" },
-  { id: "git:stash", tool: "git", base: ["stash"], label: "stash", hint: "Stash changes" },
-  { id: "git:diff", tool: "git", base: ["diff"], label: "diff", hint: "Show changes" },
-  { id: "git:log", tool: "git", base: ["log"], label: "log", hint: "View commit history" },
-  { id: "git:merge", tool: "git", base: ["merge"], label: "merge", hint: "Merge branches" }
-];
-
-// src/data/commands/pkg.ts
-var pkgCommands = [
-  // Publish & Version
-  { 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" },
-  // Info & Registry
-  { 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,
-  ...pkgCommands
-];
-var commandById = new Map(allCommands.map((cmd) => [cmd.id, cmd]));
-var commandByValue = new Map(
-  allCommands.map((cmd) => [getCommandValue(cmd), cmd])
-);
-function getCommandById(id) {
-  return commandById.get(id);
-}
-function getCommandsByTool(tool) {
-  return allCommands.filter((cmd) => cmd.tool === tool);
-}
-function getCommandValue(cmd) {
-  if (cmd.tool === "supabase") {
-    return cmd.base.join(" ");
-  }
-  return `${cmd.tool}:${cmd.base.join(" ")}`;
-}
-function findCommandByValue(value) {
-  const byId = commandById.get(value);
-  if (byId) return byId;
-  return commandByValue.get(value);
-}
-
-// src/data/features.ts
-var allSources = [...supabaseCommands, ...ghCommands, ...vercelCommands, ...gitCommands, ...pkgCommands];
-function pick(ids) {
-  const idSet = new Set(ids);
-  return allSources.filter((cmd) => idSet.has(cmd.id));
-}
-var features = [
-  {
-    id: "database",
-    icon: "\u{1F5C4}\uFE0F",
-    label: "Database",
-    commands: pick([
-      "supabase:db",
-      "supabase:migration",
-      "supabase:seed",
-      "supabase:inspect"
-    ])
-  },
-  {
-    id: "functions",
-    icon: "\u26A1",
-    label: "Functions",
-    commands: pick([
-      "supabase:functions"
-    ])
-  },
-  {
-    id: "deploy",
-    icon: "\u{1F680}",
-    label: "Deploy",
-    commands: pick([
-      "supabase:db",
-      "supabase:functions",
-      "vercel:deploy",
-      "vercel:deploy:prod",
-      "vercel:promote",
-      "vercel:rollback",
-      "git:commit",
-      "git:push"
-    ])
-  },
-  {
-    id: "repo",
-    icon: "\u{1F5C3}\uFE0F",
-    label: "Repo",
-    commands: pick([
-      "git:status",
-      "git:add",
-      "git:commit",
-      "git:push",
-      "git:pull",
-      "git:branch",
-      "git:checkout",
-      "git:log",
-      "git:diff",
-      "git:merge",
-      "git:stash",
-      "gh:repo:clone",
-      "gh:repo:create",
-      "gh:repo:view",
-      "gh:repo:list",
-      "gh:pr:create",
-      "gh:pr:list",
-      "gh:pr:view",
-      "gh:pr:merge",
-      "gh:pr:checkout",
-      "gh:pr:review",
-      "gh:issue:create",
-      "gh:issue:list",
-      "gh:issue:view",
-      "gh:issue:close",
-      "gh:release:create",
-      "gh:release:list",
-      "gh:release:view"
-    ])
-  },
-  {
-    id: "cicd",
-    icon: "\u{1F504}",
-    label: "CI/CD",
-    commands: pick([
-      "vercel:env:ls",
-      "vercel:env:add",
-      "vercel:env:rm",
-      "vercel:env:pull",
-      "gh:workflow:list",
-      "gh:workflow:run",
-      "gh:workflow:view",
-      "gh:run:list",
-      "gh:run:view",
-      "gh:run:watch"
-    ])
-  },
-  {
-    id: "auth-storage",
-    icon: "\u{1F510}",
-    label: "Auth & Storage",
-    commands: pick([
-      "supabase:storage",
-      "supabase:secrets",
-      "supabase:sso"
-    ])
-  },
-  {
-    id: "networking",
-    icon: "\u{1F310}",
-    label: "Networking",
-    commands: pick([
-      "supabase:domains",
-      "supabase:ssl-enforcement",
-      "supabase:network-bans",
-      "supabase:network-restrictions",
-      "supabase:vanity-subdomains",
-      "supabase:encryption",
-      "vercel:domains:list",
-      "vercel:domains:add",
-      "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: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",
-    label: "Setup",
-    commands: pick([
-      "supabase:init",
-      "supabase:link",
-      "supabase:login",
-      "vercel:link",
-      "vercel:login",
-      "gh:auth:login",
-      "gh:auth:status"
-    ])
-  }
-];
-var featureById = new Map(features.map((f) => [f.id, f]));
-function getFeatureById(id) {
-  return featureById.get(id);
-}
-
-// src/data/flags.ts
-var globalFlags = [
-  { value: "--debug", label: "--debug", hint: "Output debug logs to stderr" },
-  { value: "--yes", label: "--yes", hint: "Answer yes to all prompts" },
-  {
-    value: "--create-ticket",
-    label: "--create-ticket",
-    hint: "Create support ticket on error"
-  },
-  {
-    value: "--experimental",
-    label: "--experimental",
-    hint: "Enable experimental features"
-  }
-];
-var toolFlags = {
-  supabase: globalFlags,
-  gh: [],
-  vercel: [
-    { value: "--yes", label: "--yes", hint: "Skip confirmation prompts" },
-    { value: "--debug", label: "--debug", hint: "Debug mode" }
-  ],
-  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;
-}
-
-// src/lib/runner.ts
-import { spawn, spawnSync } from "child_process";
-import { existsSync } from "fs";
-import { delimiter, dirname, join, resolve } from "path";
-function getSupabaseBinaryCandidates() {
-  if (process.platform === "win32") {
-    return ["supabase.cmd", "supabase.exe", "supabase"];
-  }
-  return ["supabase"];
-}
-function hasLocalSupabaseBinary(binDir) {
-  return getSupabaseBinaryCandidates().some(
-    (candidate) => existsSync(join(binDir, candidate))
-  );
-}
-function getPathEnvKey(env) {
-  return Object.keys(env).find((key) => key.toLowerCase() === "path") ?? "PATH";
-}
-function findLocalSupabaseBinDir(startDir = process.cwd()) {
-  let currentDir = resolve(startDir);
-  while (true) {
-    const binDir = join(currentDir, "node_modules", ".bin");
-    if (hasLocalSupabaseBinary(binDir)) {
-      return binDir;
-    }
-    const parentDir = dirname(currentDir);
-    if (parentDir === currentDir) {
-      return void 0;
-    }
-    currentDir = parentDir;
-  }
-}
-function resolveSupabaseCommand(startDir = process.cwd(), env = process.env) {
-  const localBinDir = findLocalSupabaseBinDir(startDir);
-  if (!localBinDir) {
-    return {
-      command: "supabase",
-      env: { ...env },
-      source: "path"
-    };
-  }
-  const pathKey = getPathEnvKey(env);
-  const currentPath = env[pathKey];
-  return {
-    command: "supabase",
-    env: {
-      ...env,
-      [pathKey]: currentPath ? `${localBinDir}${delimiter}${currentPath}` : localBinDir
-    },
-    source: "repository",
-    localBinDir
-  };
-}
-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,
-    detached: 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;
-      if (!options?.quiet) process.stdout.write(text);
-      options?.onData?.(stdout, stderr);
-    });
-    child.stderr?.on("data", (data) => {
-      const text = data.toString();
-      stderr += text;
-      if (!options?.quiet) process.stderr.write(text);
-      options?.onData?.(stdout, stderr);
-    });
-    child.on("error", (err) => {
-      resolve3({
-        exitCode: null,
-        signal: null,
-        stdout,
-        stderr,
-        spawnError: err.message
-      });
-    });
-    child.on("exit", (code, signal) => {
-      resolve3({ exitCode: code, signal, stdout, stderr });
-    });
-  });
-  return {
-    promise,
-    abort: () => {
-      if (child.pid) {
-        try {
-          process.kill(-child.pid, "SIGTERM");
-        } catch {
-        }
-      }
-    }
-  };
-}
-function runInteractiveCommand(execution, args, cwd = process.cwd()) {
-  const resolved = typeof execution === "string" ? { command: execution } : execution;
-  const result = spawnSync(resolved.command, args, {
-    cwd,
-    env: resolved.env,
-    shell: true,
-    stdio: "inherit"
-  });
-  return {
-    exitCode: result.status,
-    signal: result.signal,
-    stdout: "",
-    stderr: "",
-    spawnError: result.error?.message
-  };
-}
-async function runSupabaseCommand(args, cwd = process.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 existsSync3, readFileSync } from "fs";
-import { join as join3 } from "path";
-
-// src/lib/system.ts
-import { execSync } from "child_process";
-function commandExists(command) {
-  try {
-    execSync(`command -v ${command}`, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function execCapture(command) {
-  return execSync(command, {
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  }).trim();
-}
-
-// src/lib/toolResolver.ts
-function getToolDisplayName(toolId, cwd = process.cwd()) {
-  if (toolId === "pkg") {
-    const mgr = detectPkgManager(cwd);
-    return mgr.id;
-  }
-  const names = {
-    supabase: "supabase",
-    gh: "github",
-    vercel: "vercel",
-    git: "git",
-    pkg: "npm"
-  };
-  return names[toolId];
-}
-function resolveToolCommand(toolId, cwd = process.cwd()) {
-  if (toolId === "supabase") {
-    const resolved = resolveSupabaseCommand(cwd);
-    return {
-      command: resolved.command,
-      env: resolved.env,
-      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" };
-  }
-  return { command, env: { ...process.env }, source: "path" };
-}
-function getToolVersion(toolId) {
-  try {
-    switch (toolId) {
-      case "supabase":
-        return execCapture("supabase --version").replace(/^supabase\s+/i, "");
-      case "gh":
-        return execCapture("gh --version").split("\n")[0]?.replace(/^gh\s+version\s+/i, "").split(" ")[0];
-      case "vercel":
-        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;
-    }
-  } catch {
-    return void 0;
-  }
-}
-var toolInfoCache = /* @__PURE__ */ new Map();
-function getToolInfo(toolId) {
-  const cached = toolInfoCache.get(toolId);
-  if (cached) return cached;
-  const labels = {
-    supabase: "Supabase CLI",
-    gh: "GitHub CLI",
-    vercel: "Vercel CLI",
-    git: "Git",
-    pkg: "Package Manager"
-  };
-  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,
-    label: labels[toolId],
-    installed,
-    version
-  };
-  toolInfoCache.set(toolId, info);
-  return info;
-}
-function detectSupabaseLink(cwd) {
-  try {
-    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] };
-    }
-  } catch {
-  }
-  return { linked: false };
-}
-function detectVercelLink(cwd) {
-  try {
-    const projectPath = join3(cwd, ".vercel", "project.json");
-    if (existsSync3(projectPath)) {
-      const data = JSON.parse(readFileSync(projectPath, "utf-8"));
-      return { linked: true, project: data.projectId };
-    }
-  } catch {
-  }
-  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`);
-    if (remote) {
-      const match = remote.match(/[/:]([\w.-]+\/[\w.-]+?)(?:\.git)?$/);
-      return { linked: true, project: match?.[1] ?? remote };
-    }
-  } catch {
-  }
-  return { linked: false };
-}
-var toolLinkCache = /* @__PURE__ */ new Map();
-function getToolLinkInfo(toolId, cwd = process.cwd()) {
-  const cached = toolLinkCache.get(toolId);
-  if (cached) return cached;
-  const base = getToolInfo(toolId);
-  let linkStatus = { linked: false };
-  if (base.installed) {
-    switch (toolId) {
-      case "supabase":
-        linkStatus = detectSupabaseLink(cwd);
-        break;
-      case "vercel":
-        linkStatus = detectVercelLink(cwd);
-        break;
-      case "gh":
-        linkStatus = detectGhLink(cwd);
-        break;
-      case "pkg":
-        linkStatus = detectPkgLink(cwd);
-        break;
-    }
-  }
-  const info = { ...base, ...linkStatus };
-  toolLinkCache.set(toolId, info);
-  return info;
-}
-
-// src/lib/processManager.ts
-import { spawn as spawn2 } from "child_process";
-import { join as join5 } from "path";
-
-// src/lib/packageRoot.ts
-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 (existsSync4(join4(currentDir, "package.json"))) {
-      rootCache.set(resolvedStart, currentDir);
-      return currentDir;
-    }
-    const parentDir = dirname3(currentDir);
-    if (parentDir === currentDir) {
-      rootCache.set(resolvedStart, void 0);
-      return void 0;
-    }
-    currentDir = parentDir;
-  }
-}
-
-// src/lib/processManager.ts
-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 findProcessesByCwd(cwd) {
-  const normalized = cwd.replace(/\/+$/, "");
-  return Array.from(registry.values()).filter((proc) => proc.cwd.replace(/\/+$/, "") === normalized).map(toProcessInfo);
-}
-function findRunningByCommand(cwd, command, args) {
-  const normalized = cwd.replace(/\/+$/, "");
-  const argsStr = args.join(" ");
-  for (const proc of registry.values()) {
-    if (proc.cwd.replace(/\/+$/, "") === normalized && proc.status === "running" && proc.command === command && proc.args.join(" ") === argsStr) {
-      return toProcessInfo(proc);
-    }
-  }
-  return void 0;
-}
-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
-  };
-}
-function getSocketPath(cwd) {
-  const root = findNearestPackageRoot(cwd);
-  if (!root) return void 0;
-  return join5(root, ".polter", "polter.sock");
-}
-
-// src/lib/ipcServer.ts
-import net from "net";
-import { mkdirSync, unlinkSync, existsSync as existsSync5 } from "fs";
-import { dirname as dirname4 } from "path";
-
-// src/lib/ipcProtocol.ts
-var DELIMITER = "\n";
-function serializeMessage(msg) {
-  return JSON.stringify(msg) + DELIMITER;
-}
-function parseMessages(buffer) {
-  const messages = [];
-  let remainder = buffer;
-  let idx;
-  while ((idx = remainder.indexOf(DELIMITER)) !== -1) {
-    const line = remainder.slice(0, idx);
-    remainder = remainder.slice(idx + 1);
-    if (line.length === 0) continue;
-    try {
-      messages.push(JSON.parse(line));
-    } catch {
-    }
-  }
-  return { messages, remainder };
-}
-
-// src/lib/ipcServer.ts
-var handlers = {
-  "ps.list": () => listProcesses(),
-  "ps.start": (params) => {
-    const { command, args, cwd, id } = params;
-    const processArgs = args ?? [];
-    const processId = id ?? generateProcessId(command, processArgs);
-    const processCwd = cwd ?? process.cwd();
-    return startProcess(processId, command, processArgs, processCwd);
-  },
-  "ps.stop": async (params) => {
-    const { id } = params;
-    return stopProcess(id);
-  },
-  "ps.logs": (params) => {
-    const { id, tail, stream } = params;
-    return getProcessOutput(id, tail, stream);
-  },
-  "ps.remove": (params) => {
-    const { id } = params;
-    removeProcess(id);
-    return null;
-  },
-  "ps.find_by_cwd": (params) => {
-    const { cwd, filter } = params;
-    let processes = findProcessesByCwd(cwd);
-    if (filter) {
-      const f = filter.toLowerCase();
-      processes = processes.filter(
-        (p) => (p.command + " " + p.args.join(" ")).toLowerCase().includes(f)
-      );
-    }
-    return processes;
-  },
-  "ps.find_running": (params) => {
-    const { cwd, command, args } = params;
-    return findRunningByCommand(cwd, command, args) ?? null;
-  },
-  "ps.generate_id": (params) => {
-    const { command, args } = params;
-    return generateProcessId(command, args);
-  },
-  status: () => ({ tui: true, pid: process.pid })
-};
-async function handleRequest(req) {
-  const handler = handlers[req.method];
-  if (!handler) {
-    return {
-      jsonrpc: "2.0",
-      id: req.id,
-      error: { code: -32601, message: `Method not found: ${req.method}` }
-    };
-  }
-  try {
-    const result = await handler(req.params ?? {});
-    return { jsonrpc: "2.0", id: req.id, result };
-  } catch (err) {
-    return {
-      jsonrpc: "2.0",
-      id: req.id,
-      error: { code: -32e3, message: err.message }
-    };
-  }
-}
-function createIpcServer(socketPath) {
-  let server = null;
-  const connections = /* @__PURE__ */ new Set();
-  function handleConnection(socket) {
-    connections.add(socket);
-    let buffer = "";
-    socket.on("data", async (data) => {
-      buffer += data.toString();
-      const { messages, remainder } = parseMessages(buffer);
-      buffer = remainder;
-      for (const msg of messages) {
-        if ("method" in msg) {
-          const response = await handleRequest(msg);
-          try {
-            socket.write(serializeMessage(response));
-          } catch {
-          }
-        }
-      }
-    });
-    socket.on("close", () => {
-      connections.delete(socket);
-    });
-    socket.on("error", () => {
-      connections.delete(socket);
-    });
-  }
-  async function cleanStaleSocket() {
-    if (!existsSync5(socketPath)) return;
-    return new Promise((resolve3) => {
-      const probe = net.createConnection(socketPath);
-      probe.on("connect", () => {
-        probe.destroy();
-        resolve3();
-      });
-      probe.on("error", () => {
-        try {
-          unlinkSync(socketPath);
-        } catch {
-        }
-        resolve3();
-      });
-    });
-  }
-  return {
-    async start() {
-      mkdirSync(dirname4(socketPath), { recursive: true });
-      await cleanStaleSocket();
-      return new Promise((resolve3, reject) => {
-        server = net.createServer(handleConnection);
-        server.on("error", (err) => {
-          if (err.code === "EADDRINUSE") {
-            try {
-              unlinkSync(socketPath);
-            } catch {
-            }
-            server.listen(socketPath, () => resolve3());
-          } else {
-            reject(err);
-          }
-        });
-        server.listen(socketPath, () => resolve3());
-      });
-    },
-    async stop() {
-      for (const conn of connections) {
-        conn.destroy();
-      }
-      connections.clear();
-      return new Promise((resolve3) => {
-        if (!server) {
-          resolve3();
-          return;
-        }
-        server.close(() => {
-          try {
-            unlinkSync(socketPath);
-          } catch {
-          }
-          server = null;
-          resolve3();
-        });
-      });
-    }
-  };
-}
-
-// src/pipeline/engine.ts
-async function executePipeline(pipeline, onProgress, cwd = process.cwd()) {
-  const stepResults = pipeline.steps.map((step) => ({
-    step,
-    status: "pending"
-  }));
-  let aborted = false;
-  for (let i = 0; i < pipeline.steps.length; i++) {
-    const step = pipeline.steps[i];
-    if (aborted) {
-      stepResults[i] = { step, status: "skipped" };
-      onProgress({ stepResults: [...stepResults], currentStepIndex: i, done: false });
-      continue;
-    }
-    stepResults[i] = { step, status: "running" };
-    onProgress({ stepResults: [...stepResults], currentStepIndex: i, done: false });
-    const cmdDef = getCommandById(step.commandId);
-    const toolId = cmdDef?.tool ?? "supabase";
-    const resolved = resolveToolCommand(toolId, cwd);
-    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,
-      status: success ? "success" : "error",
-      result
-    };
-    if (!success && !step.continueOnError) {
-      aborted = true;
-    }
-    onProgress({ stepResults: [...stepResults], currentStepIndex: i, done: false });
-  }
-  onProgress({
-    stepResults: [...stepResults],
-    currentStepIndex: pipeline.steps.length - 1,
-    done: true
-  });
-  return stepResults;
-}
-
-// src/config/projectConfig.ts
-import { existsSync as existsSync6, readFileSync as readFileSync2, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
-import { join as join6 } from "path";
-var CONFIG_DIR = ".polter";
-var CONFIG_FILE = "config.json";
-function defaultConfig() {
-  return {
-    version: 1,
-    tools: {},
-    pipelines: []
-  };
-}
-function getProjectConfigPath(startDir) {
-  const root = findNearestPackageRoot(startDir);
-  if (!root) return void 0;
-  const dir = join6(root, CONFIG_DIR);
-  return { dir, file: join6(dir, CONFIG_FILE) };
-}
-function readProjectConfig(startDir) {
-  const paths = getProjectConfigPath(startDir);
-  if (!paths) return void 0;
-  if (!existsSync6(paths.file)) return void 0;
-  try {
-    const raw = readFileSync2(paths.file, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return void 0;
-  }
-}
-function writeProjectConfig(config2, startDir) {
-  const paths = getProjectConfigPath(startDir);
-  if (!paths) return false;
-  mkdirSync2(paths.dir, { recursive: true });
-  writeFileSync(paths.file, JSON.stringify(config2, null, 2) + "\n", "utf-8");
-  return true;
-}
-function getOrCreateProjectConfig(startDir) {
-  return readProjectConfig(startDir) ?? defaultConfig();
-}
-function getProjectPipelines(startDir) {
-  const config2 = readProjectConfig(startDir);
-  return config2?.pipelines ?? [];
-}
-function saveProjectPipeline(pipeline, startDir) {
-  const config2 = getOrCreateProjectConfig(startDir);
-  const idx = config2.pipelines.findIndex((p) => p.id === pipeline.id);
-  if (idx >= 0) {
-    config2.pipelines[idx] = pipeline;
-  } else {
-    config2.pipelines.push(pipeline);
-  }
-  return writeProjectConfig(config2, startDir);
-}
-function deleteProjectPipeline(pipelineId, startDir) {
-  const config2 = getOrCreateProjectConfig(startDir);
-  config2.pipelines = config2.pipelines.filter((p) => p.id !== pipelineId);
-  return writeProjectConfig(config2, startDir);
-}
-
-// src/config/store.ts
-import Conf from "conf";
-var config = new Conf({
-  projectName: process.env.NODE_ENV === "test" ? "polter-test" : "polter"
-});
-var GLOBAL_PIPELINES_KEY = "globalPipelinesV1";
-function getGlobalPipelines() {
-  if (!config.has(GLOBAL_PIPELINES_KEY)) {
-    config.set(GLOBAL_PIPELINES_KEY, []);
-  }
-  return config.get(GLOBAL_PIPELINES_KEY) || [];
-}
-function saveGlobalPipeline(pipeline) {
-  const pipelines = getGlobalPipelines();
-  const idx = pipelines.findIndex((p) => p.id === pipeline.id);
-  if (idx >= 0) {
-    pipelines[idx] = pipeline;
-  } else {
-    pipelines.push(pipeline);
-  }
-  config.set(GLOBAL_PIPELINES_KEY, pipelines);
-}
-function deleteGlobalPipeline(pipelineId) {
-  const pipelines = getGlobalPipelines().filter((p) => p.id !== pipelineId);
-  config.set(GLOBAL_PIPELINES_KEY, pipelines);
-}
-
-// src/pipeline/storage.ts
-function getAllPipelines(startDir) {
-  const projectPipelines = getProjectPipelines(startDir).map((p) => ({
-    ...p,
-    source: "project"
-  }));
-  const globalPipelines = getGlobalPipelines().map((p) => ({
-    ...p,
-    source: "global"
-  }));
-  const seen = new Set(projectPipelines.map((p) => p.id));
-  const merged = [
-    ...projectPipelines,
-    ...globalPipelines.filter((p) => !seen.has(p.id))
-  ];
-  return merged;
-}
-function savePipeline(pipeline, source, startDir) {
-  if (source === "project") {
-    saveProjectPipeline(pipeline, startDir);
-  } else {
-    saveGlobalPipeline(pipeline);
-  }
-}
-function deletePipeline(pipelineId, source, startDir) {
-  if (source === "project") {
-    deleteProjectPipeline(pipelineId, startDir);
-  } else {
-    deleteGlobalPipeline(pipelineId);
-  }
-}
-function findPipelineByName(name, startDir) {
-  return getAllPipelines(startDir).find((p) => p.name === name);
-}
-
-// src/declarative/parser.ts
-import { existsSync as existsSync7, readFileSync as readFileSync3 } from "fs";
-import { join as join7 } from "path";
-var YAML_FILE = "polter.yaml";
-function parseSimpleYaml(content) {
-  const lines = content.split("\n");
-  const result = {};
-  const stack = [
-    { obj: result, indent: -1 }
-  ];
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const trimmed = line.replace(/\s+$/, "");
-    if (!trimmed || trimmed.match(/^\s*#/)) continue;
-    const indent = line.search(/\S/);
-    if (indent < 0) continue;
-    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
-      stack.pop();
-    }
-    const current = stack[stack.length - 1].obj;
-    const content_ = trimmed.trim();
-    if (content_.startsWith("- ")) {
-      const parentKey = Object.keys(current).pop();
-      if (parentKey) {
-        const arr = current[parentKey];
-        if (Array.isArray(arr)) {
-          const val = content_.slice(2).trim();
-          const colonIdx2 = val.indexOf(":");
-          if (colonIdx2 > 0 && !val.startsWith('"') && !val.startsWith("'")) {
-            const key = val.slice(0, colonIdx2).trim();
-            const rest = val.slice(colonIdx2 + 1).trim();
-            const obj = { [key]: parseValue(rest) };
-            arr.push(obj);
-            stack.push({ obj, indent: indent + 2 });
-          } else {
-            arr.push(parseValue(val));
-          }
-        }
-      }
-      continue;
-    }
-    const colonIdx = content_.indexOf(":");
-    if (colonIdx > 0) {
-      const key = content_.slice(0, colonIdx).trim();
-      const rest = content_.slice(colonIdx + 1).trim();
-      if (rest === "" || rest === "|" || rest === ">") {
-        const nextLine = lines[i + 1];
-        const nextTrimmed = nextLine?.trim();
-        if (nextTrimmed?.startsWith("- ")) {
-          current[key] = [];
-        } else {
-          const nested = {};
-          current[key] = nested;
-          stack.push({ obj: nested, indent });
-        }
-      } else {
-        current[key] = parseValue(rest);
-      }
-    }
-  }
-  return result;
-}
-function parseValue(raw) {
-  if (!raw) return "";
-  if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
-    return raw.slice(1, -1);
-  }
-  if (raw === "true") return true;
-  if (raw === "false") return false;
-  const num = Number(raw);
-  if (!isNaN(num) && raw !== "") return num;
-  return raw;
-}
-function findPolterYaml(startDir = process.cwd()) {
-  const filePath = join7(startDir, YAML_FILE);
-  return existsSync7(filePath) ? filePath : void 0;
-}
-function parsePolterYaml(startDir = process.cwd()) {
-  const filePath = findPolterYaml(startDir);
-  if (!filePath) return void 0;
-  const content = readFileSync3(filePath, "utf-8");
-  const raw = parseSimpleYaml(content);
-  return raw;
-}
-
-// src/declarative/status.ts
-import { execSync as execSync2 } from "child_process";
-function safeExec(cmd) {
-  try {
-    return execSync2(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-  } catch {
-    return void 0;
-  }
-}
-function getCurrentStatus(cwd = process.cwd()) {
-  const result = {};
-  if (commandExists("supabase")) {
-    const linked = safeExec(`cd "${cwd}" && supabase projects list 2>/dev/null`) !== void 0;
-    result.supabase = {
-      linked,
-      projectRef: void 0,
-      functions: []
-    };
-    const functionsOutput = safeExec(`cd "${cwd}" && supabase functions list 2>/dev/null`);
-    if (functionsOutput) {
-      result.supabase.functions = functionsOutput.split("\n").filter((line) => line.trim() && !line.startsWith("\u2502") && !line.startsWith("\u250C")).slice(1);
-    }
-  }
-  if (commandExists("vercel")) {
-    const whoami = safeExec("vercel whoami 2>/dev/null");
-    result.vercel = {
-      linked: !!whoami,
-      projectId: void 0
-    };
-  }
-  if (commandExists("gh")) {
-    const authStatus = safeExec("gh auth status 2>&1");
-    const authenticated = authStatus?.includes("Logged in") ?? false;
-    const repoOutput = safeExec(`cd "${cwd}" && gh repo view --json nameWithOwner -q .nameWithOwner 2>/dev/null`);
-    result.github = {
-      repo: repoOutput || void 0,
-      authenticated
-    };
-  }
-  return result;
-}
-
-// src/declarative/planner.ts
-function planChanges(desired, cwd = process.cwd()) {
-  const current = getCurrentStatus(cwd);
-  const actions = [];
-  if (desired.supabase?.functions) {
-    const currentFunctions = new Set(current.supabase?.functions ?? []);
-    for (const fn of desired.supabase.functions) {
-      if (!currentFunctions.has(fn.name)) {
-        const args = ["functions", "deploy", fn.name];
-        if (fn.verify_jwt === false) {
-          args.push("--no-verify-jwt");
-        }
-        actions.push({
-          tool: "supabase",
-          action: "create",
-          resource: `function:${fn.name}`,
-          description: `Deploy function "${fn.name}"`,
-          args
-        });
-      }
-    }
-  }
-  if (desired.supabase?.secrets) {
-    for (const secret of desired.supabase.secrets) {
-      actions.push({
-        tool: "supabase",
-        action: "update",
-        resource: `secret:${secret}`,
-        description: `Ensure secret "${secret}" is set`,
-        args: ["secrets", "set", secret]
-      });
-    }
-  }
-  if (desired.vercel?.domains) {
-    for (const domain of desired.vercel.domains) {
-      actions.push({
-        tool: "vercel",
-        action: "create",
-        resource: `domain:${domain}`,
-        description: `Add domain "${domain}"`,
-        args: ["domains", "add", domain]
-      });
-    }
-  }
-  if (desired.vercel?.env) {
-    for (const [env, vars] of Object.entries(desired.vercel.env)) {
-      for (const [key, value] of Object.entries(vars)) {
-        actions.push({
-          tool: "vercel",
-          action: "update",
-          resource: `env:${env}:${key}`,
-          description: `Set env var "${key}" for ${env}`,
-          args: ["env", "add", key, env]
-        });
-      }
-    }
-  }
-  if (desired.github?.secrets) {
-    for (const secret of desired.github.secrets) {
-      actions.push({
-        tool: "gh",
-        action: "update",
-        resource: `secret:${secret}`,
-        description: `Ensure GitHub secret "${secret}" is set`,
-        args: ["secret", "set", secret]
-      });
-    }
-  }
-  return {
-    actions,
-    noChanges: actions.length === 0
-  };
-}
-
-// src/declarative/applier.ts
-async function applyActions(actions, cwd = process.cwd(), onProgress) {
-  const results = [];
-  for (let i = 0; i < actions.length; i++) {
-    const action = actions[i];
-    onProgress?.(i, actions.length, action);
-    const resolved = resolveToolCommand(action.tool, cwd);
-    const result = await runCommand(
-      { 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 mkdirSync3, existsSync as existsSync8 } from "fs";
-import { join as join8, dirname as dirname5 } from "path";
-import { fileURLToPath } from "url";
-import { homedir } from "os";
-import pc from "picocolors";
-var __dirname = dirname5(fileURLToPath(import.meta.url));
-function readPkgVersion() {
-  for (const rel of ["../../package.json", "../package.json"]) {
-    const p = join8(__dirname, rel);
-    if (existsSync8(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 join8(process.cwd(), ".mcp.json");
-  }
-  return join8(homedir(), ".claude", "settings.json");
-}
-function tryManualInstall(scope) {
-  const settingsPath = getSettingsPath(scope);
-  const dir = join8(settingsPath, "..");
-  let settings = {};
-  if (existsSync8(settingsPath)) {
-    try {
-      settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
-    } catch {
-      process.stderr.write(pc.red(`Failed to parse ${settingsPath}
-`));
-      return false;
-    }
-  } else {
-    mkdirSync3(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 (!existsSync8(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: join8(process.cwd(), ".mcp.json"), scope: "project" },
-    { label: "User (~/.claude/settings.json)", path: join8(homedir(), ".claude", "settings.json"), scope: "user" }
-  ];
-  const scopes = scopeDefs.map((s) => {
-    if (!existsSync8(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 (!existsSync8(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: join8(process.cwd(), ".mcp.json"), key: "project" },
-    { label: "User (~/.claude/settings.json)", path: join8(homedir(), ".claude", "settings.json"), key: "user" }
-  ];
-  for (const scope of scopes) {
-    if (!existsSync8(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,
-  getCommandById,
-  getCommandsByTool,
-  getCommandValue,
-  findCommandByValue,
-  features,
-  getFeatureById,
-  toolFlags,
-  getFlagsForTool,
-  runCommand,
-  runInteractiveCommand,
-  runSupabaseCommand,
-  commandExists,
-  detectPkgManager,
-  translateCommand,
-  resolvePkgArgs,
-  getToolDisplayName,
-  resolveToolCommand,
-  getToolInfo,
-  getToolLinkInfo,
-  findNearestPackageRoot,
-  generateProcessId,
-  startProcess,
-  stopProcess,
-  listProcesses,
-  getProcessOutput,
-  isProcessRunning,
-  removeProcess,
-  findProcessesByCwd,
-  findRunningByCommand,
-  getSocketPath,
-  serializeMessage,
-  parseMessages,
-  createIpcServer,
-  executePipeline,
-  getProjectConfigPath,
-  writeProjectConfig,
-  getOrCreateProjectConfig,
-  getAllPipelines,
-  savePipeline,
-  deletePipeline,
-  findPipelineByName,
-  findPolterYaml,
-  parsePolterYaml,
-  getCurrentStatus,
-  planChanges,
-  applyActions,
-  installMcpServer,
-  removeMcpServer,
-  getMcpStatusInfo,
-  installMcpServerSilent,
-  removeMcpServerSilent,
-  mcpStatus
-};