@polterware/polter 0.4.2 → 0.5.1

package/dist/chunk-6IBRTRLX.js

@@ -0,0 +1,257 @@
+import {
+  findNearestPackageRoot
+} from "./chunk-ZU5VZHYD.js";
+
+// src/lib/processManager.ts
+import { join } from "path";
+import { execa } from "execa";
+import ms from "ms";
+import { onExit } from "signal-exit";
+
+// src/lib/processEvents.ts
+import EE from "eventemitter3";
+var EventEmitter = EE.EventEmitter ?? EE;
+var processEvents = new EventEmitter();
+
+// 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;
+  onExit(() => {
+    for (const proc of registry.values()) {
+      if (proc.status === "running" && proc.child.pid) {
+        try {
+          process.kill(-proc.child.pid, "SIGKILL");
+        } catch {
+        }
+      }
+    }
+  }, { alwaysLast: true });
+}
+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 trackChild(id, command, args, cwd, child) {
+  const existing = registry.get(id);
+  if (existing && existing.status === "running") {
+    throw new Error(`Process "${id}" is already running (pid ${existing.child.pid})`);
+  }
+  registerCleanup();
+  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) => {
+    const text = data.toString();
+    appendToBuffer(tracked.stdout, text);
+    processEvents.emit("output", id, "stdout", text);
+  });
+  child.stderr?.on("data", (data) => {
+    const text = data.toString();
+    appendToBuffer(tracked.stderr, text);
+    processEvents.emit("output", id, "stderr", text);
+  });
+  child.on("exit", (code, signal) => {
+    tracked.status = "exited";
+    tracked.exitCode = code;
+    tracked.signal = signal;
+    tracked.exitedAt = /* @__PURE__ */ new Date();
+    processEvents.emit("stopped", toProcessInfo(tracked));
+  });
+  child.on("error", (err) => {
+    tracked.status = "errored";
+    tracked.exitedAt = /* @__PURE__ */ new Date();
+    appendToBuffer(tracked.stderr, `spawn error: ${err.message}
+`);
+    processEvents.emit("errored", toProcessInfo(tracked), err.message);
+  });
+  registry.set(id, tracked);
+  const info = toProcessInfo(tracked);
+  processEvents.emit("started", info);
+  return info;
+}
+function startProcess(id, command, args = [], cwd = process.cwd(), env) {
+  const subprocess = execa(command, args, {
+    cwd,
+    env: env ?? process.env,
+    detached: true,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    shell: true,
+    reject: false
+  });
+  return trackChild(id, command, args, cwd, subprocess);
+}
+function registerForegroundProcess(id, command, args, cwd, child) {
+  return trackChild(id, command, args, cwd, child);
+}
+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((resolve) => {
+    const escalateTimer = setTimeout(() => {
+      if (proc.status === "running" && proc.child.pid) {
+        try {
+          process.kill(-proc.child.pid, "SIGKILL");
+        } catch {
+        }
+      }
+    }, ms("5s"));
+    const onDone = () => {
+      clearTimeout(escalateTimer);
+      resolve(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);
+      resolve(toProcessInfo(proc));
+    }
+  });
+}
+function listProcesses() {
+  return Array.from(registry.values()).map(toProcessInfo).reverse();
+}
+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 _resetForTests() {
+  for (const proc of registry.values()) {
+    if (proc.status === "running" && proc.child.pid) {
+      try {
+        process.kill(-proc.child.pid, "SIGKILL");
+      } catch {
+      }
+    }
+  }
+  registry.clear();
+}
+function getSocketPath(cwd) {
+  const root = findNearestPackageRoot(cwd);
+  if (!root) return void 0;
+  return join(root, ".polter", "polter.sock");
+}
+
+export {
+  createRingBuffer,
+  appendToBuffer,
+  tailBuffer,
+  generateProcessId,
+  startProcess,
+  registerForegroundProcess,
+  stopProcess,
+  listProcesses,
+  getProcessOutput,
+  isProcessRunning,
+  removeProcess,
+  findProcessesByCwd,
+  findRunningByCommand,
+  _resetForTests,
+  getSocketPath
+};

package/dist/chunk-AK3NTS3Y.js

@@ -0,0 +1,220 @@
+import {
+  ghCommands,
+  gitCommands,
+  pkgCommands,
+  supabaseCommands,
+  vercelCommands
+} from "./chunk-GVIKF6UI.js";
+
+// src/data/features.ts
+var allSources = [...supabaseCommands, ...ghCommands, ...vercelCommands, ...gitCommands, ...pkgCommands];
+var allSourceIds = new Set(allSources.map((cmd) => cmd.id));
+function pick(ids) {
+  if (process.env.NODE_ENV !== "production") {
+    for (const id of ids) {
+      if (!allSourceIds.has(id)) {
+        throw new Error(`features.ts: unknown command ID "${id}". Check your feature definitions.`);
+      }
+    }
+  }
+  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;
+}
+
+export {
+  features,
+  getFeatureById,
+  toolFlags,
+  getFlagsForTool
+};

package/dist/chunk-BGT5TT2A.js

@@ -0,0 +1,32 @@
+import {
+  resolveToolCommand,
+  runCommand
+} from "./chunk-ELSIHPJL.js";
+
+// src/declarative/applier.ts
+import pLimit from "p-limit";
+async function applyActions(actions, cwd = process.cwd(), onProgress) {
+  const limit = pLimit(3);
+  let completed = 0;
+  const results = await Promise.all(
+    actions.map(
+      (action) => limit(async () => {
+        onProgress?.(completed, actions.length, action);
+        const resolved = resolveToolCommand(action.tool, cwd);
+        const result = await runCommand(
+          { command: resolved.command, env: resolved.env },
+          action.args,
+          cwd
+        ).promise;
+        completed++;
+        const success = !result.spawnError && result.exitCode === 0;
+        return { action, success, result };
+      })
+    )
+  );
+  return results;
+}
+
+export {
+  applyActions
+};

package/dist/chunk-BIN7BDA2.js

@@ -0,0 +1,77 @@
+import {
+  findNearestPackageRoot
+} from "./chunk-ZU5VZHYD.js";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync
+} from "./chunk-TD6YNU6L.js";
+
+// src/config/projectConfig.ts
+import { join } 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 = join(root, CONFIG_DIR);
+  return { dir, file: join(dir, CONFIG_FILE) };
+}
+function readProjectConfig(startDir) {
+  const paths = getProjectConfigPath(startDir);
+  if (!paths) return void 0;
+  if (!existsSync(paths.file)) return void 0;
+  try {
+    const raw = readFileSync(paths.file, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function writeProjectConfig(config, startDir) {
+  const paths = getProjectConfigPath(startDir);
+  if (!paths) return false;
+  mkdirSync(paths.dir, { recursive: true });
+  writeFileSync(paths.file, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  return true;
+}
+function getOrCreateProjectConfig(startDir) {
+  return readProjectConfig(startDir) ?? defaultConfig();
+}
+function getProjectPipelines(startDir) {
+  const config = readProjectConfig(startDir);
+  return config?.pipelines ?? [];
+}
+function saveProjectPipeline(pipeline, startDir) {
+  const config = getOrCreateProjectConfig(startDir);
+  const idx = config.pipelines.findIndex((p) => p.id === pipeline.id);
+  if (idx >= 0) {
+    config.pipelines[idx] = pipeline;
+  } else {
+    config.pipelines.push(pipeline);
+  }
+  return writeProjectConfig(config, startDir);
+}
+function deleteProjectPipeline(pipelineId, startDir) {
+  const config = getOrCreateProjectConfig(startDir);
+  config.pipelines = config.pipelines.filter((p) => p.id !== pipelineId);
+  return writeProjectConfig(config, startDir);
+}
+
+export {
+  getProjectConfigPath,
+  readProjectConfig,
+  writeProjectConfig,
+  getOrCreateProjectConfig,
+  getProjectPipelines,
+  saveProjectPipeline,
+  deleteProjectPipeline
+};

package/dist/chunk-E2B5FFBU.js

@@ -0,0 +1,81 @@
+import {
+  getCurrentStatus
+} from "./chunk-OKHPN6X7.js";
+
+// 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
+  };
+}
+
+export {
+  planChanges
+};