@polterware/polter 0.4.2 → 0.5.0

package/dist/chunk-EAMHFQKU.js

@@ -0,0 +1,222 @@
+import {
+  findProcessesByCwd,
+  findRunningByCommand,
+  generateProcessId,
+  getProcessOutput,
+  listProcesses,
+  removeProcess,
+  startProcess,
+  stopProcess
+} from "./chunk-6IBRTRLX.js";
+import {
+  existsSync,
+  mkdirSync,
+  unlinkSync
+} from "./chunk-TD6YNU6L.js";
+
+// src/lib/ipcServer.ts
+import net from "net";
+import { dirname } from "path";
+import { z } from "zod";
+
+// 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 PsStartParams = z.object({
+  command: z.string(),
+  args: z.array(z.string()).default([]),
+  cwd: z.string().default(process.cwd()),
+  id: z.string().optional()
+});
+var PsIdParams = z.object({
+  id: z.string()
+});
+var PsLogsParams = z.object({
+  id: z.string(),
+  tail: z.number().optional(),
+  stream: z.enum(["stdout", "stderr", "both"]).optional()
+});
+var PsFindByCwdParams = z.object({
+  cwd: z.string(),
+  filter: z.string().optional()
+});
+var PsFindRunningParams = z.object({
+  cwd: z.string(),
+  command: z.string(),
+  args: z.array(z.string())
+});
+var PsGenerateIdParams = z.object({
+  command: z.string(),
+  args: z.array(z.string())
+});
+var handlers = {
+  "ps.list": () => listProcesses(),
+  "ps.start": (params) => {
+    const { command, args, cwd, id } = PsStartParams.parse(params);
+    return startProcess(id ?? generateProcessId(command, args), command, args, cwd);
+  },
+  "ps.stop": async (params) => {
+    const { id } = PsIdParams.parse(params);
+    return stopProcess(id);
+  },
+  "ps.logs": (params) => {
+    const { id, tail, stream } = PsLogsParams.parse(params);
+    return getProcessOutput(id, tail, stream);
+  },
+  "ps.remove": (params) => {
+    const { id } = PsIdParams.parse(params);
+    removeProcess(id);
+    return null;
+  },
+  "ps.find_by_cwd": (params) => {
+    const { cwd, filter } = PsFindByCwdParams.parse(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 } = PsFindRunningParams.parse(params);
+    return findRunningByCommand(cwd, command, args) ?? null;
+  },
+  "ps.generate_id": (params) => {
+    const { command, args } = PsGenerateIdParams.parse(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 (!existsSync(socketPath)) return;
+    return new Promise((resolve) => {
+      const probe = net.createConnection(socketPath);
+      probe.on("connect", () => {
+        probe.destroy();
+        resolve();
+      });
+      probe.on("error", () => {
+        try {
+          unlinkSync(socketPath);
+        } catch {
+        }
+        resolve();
+      });
+    });
+  }
+  return {
+    async start() {
+      mkdirSync(dirname(socketPath), { recursive: true });
+      await cleanStaleSocket();
+      return new Promise((resolve, reject) => {
+        server = net.createServer(handleConnection);
+        server.on("error", (err) => {
+          if (err.code === "EADDRINUSE") {
+            try {
+              unlinkSync(socketPath);
+            } catch {
+            }
+            server.listen(socketPath, () => resolve());
+          } else {
+            reject(err);
+          }
+        });
+        server.listen(socketPath, () => resolve());
+      });
+    },
+    async stop() {
+      for (const conn of connections) {
+        conn.destroy();
+      }
+      connections.clear();
+      return new Promise((resolve) => {
+        if (!server) {
+          resolve();
+          return;
+        }
+        server.close(() => {
+          try {
+            unlinkSync(socketPath);
+          } catch {
+          }
+          server = null;
+          resolve();
+        });
+      });
+    }
+  };
+}
+
+export {
+  serializeMessage,
+  parseMessages,
+  createIpcServer
+};

package/dist/chunk-ELSIHPJL.js

@@ -0,0 +1,455 @@
+import {
+  commandExists,
+  execCapture
+} from "./chunk-RVMOIUSL.js";
+import {
+  existsSync,
+  readFileSync
+} from "./chunk-TD6YNU6L.js";
+
+// src/lib/toolResolver.ts
+import { join as join3 } from "path";
+
+// src/lib/runner.ts
+import { execa, execaSync } from "execa";
+import { delimiter, dirname, join, resolve } from "path";
+import pRetry from "p-retry";
+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 stdoutBuf = "";
+  let stderrBuf = "";
+  const resolvedExecution = typeof execution === "string" ? { command: execution } : execution;
+  const subprocess = execa(resolvedExecution.command, args, {
+    cwd,
+    env: resolvedExecution.env,
+    shell: true,
+    detached: true,
+    stdin: options?.quiet ? "pipe" : "inherit",
+    stdout: "pipe",
+    stderr: "pipe",
+    reject: false
+  });
+  if (options?.quiet) {
+    subprocess.stdin?.end();
+  }
+  subprocess.stdout?.on("data", (data) => {
+    const text = data.toString();
+    stdoutBuf += text;
+    if (!options?.quiet) process.stdout.write(text);
+    options?.onData?.(stdoutBuf, stderrBuf);
+  });
+  subprocess.stderr?.on("data", (data) => {
+    const text = data.toString();
+    stderrBuf += text;
+    if (!options?.quiet) process.stderr.write(text);
+    options?.onData?.(stdoutBuf, stderrBuf);
+  });
+  const promise = subprocess.then(
+    (result) => ({
+      exitCode: result.exitCode ?? null,
+      signal: result.signal ?? null,
+      stdout: stdoutBuf,
+      stderr: stderrBuf
+    }),
+    (err) => ({
+      exitCode: null,
+      signal: null,
+      stdout: stdoutBuf,
+      stderr: stderrBuf,
+      spawnError: err.message
+    })
+  );
+  return {
+    promise,
+    abort: () => {
+      if (subprocess.pid) {
+        try {
+          process.kill(-subprocess.pid, "SIGTERM");
+        } catch {
+        }
+      }
+    },
+    pid: subprocess.pid,
+    subprocess
+  };
+}
+function runInteractiveCommand(execution, args, cwd = process.cwd()) {
+  const resolved = typeof execution === "string" ? { command: execution } : execution;
+  try {
+    const result = execaSync(resolved.command, args, {
+      cwd,
+      env: resolved.env,
+      shell: true,
+      stdio: "inherit"
+    });
+    return {
+      exitCode: result.exitCode ?? null,
+      signal: null,
+      stdout: "",
+      stderr: ""
+    };
+  } catch (err) {
+    if (err && typeof err === "object" && "exitCode" in err) {
+      const execaErr = err;
+      return {
+        exitCode: execaErr.exitCode,
+        signal: execaErr.signal ?? null,
+        stdout: "",
+        stderr: ""
+      };
+    }
+    return {
+      exitCode: null,
+      signal: null,
+      stdout: "",
+      stderr: "",
+      spawnError: err.message
+    };
+  }
+}
+async function runCommandWithRetry(execution, args, cwd = process.cwd(), options) {
+  return pRetry(
+    async () => {
+      const result = await runCommand(execution, args, cwd, options).promise;
+      if (result.spawnError && !result.spawnError.includes("ENOENT")) {
+        throw new Error(result.spawnError);
+      }
+      return result;
+    },
+    {
+      retries: 2,
+      shouldRetry: ({ error }) => !error.message.includes("ENOENT")
+    }
+  );
+}
+
+// src/lib/pkgManager.ts
+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 (existsSync(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
+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 (existsSync(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 (existsSync(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 (existsSync(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 cacheKey = `${toolId}:${cwd}`;
+  const cached = toolLinkCache.get(cacheKey);
+  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(cacheKey, info);
+  return info;
+}
+
+export {
+  runCommand,
+  runInteractiveCommand,
+  runCommandWithRetry,
+  detectPkgManager,
+  translateCommand,
+  resolvePkgArgs,
+  getToolDisplayName,
+  resolveToolCommand,
+  getToolVersion,
+  getToolInfo,
+  getToolLinkInfo
+};

package/dist/{chunk-XCCKD3RZ.js → chunk-GCS7JEYU.js}

@@ -1,11 +1,12 @@
 import {
   parseMessages,
   serializeMessage
-} from "./chunk-CWBIXRZP.js";
+} from "./chunk-EAMHFQKU.js";
 
 // src/lib/ipcClient.ts
 import net from "net";
-var DEFAULT_TIMEOUT = 5e3;
+import ms from "ms";
+var DEFAULT_TIMEOUT = ms("5s");
 function createIpcClient(socketPath) {
   let socket = null;
   let connected = false;
@@ -34,9 +35,11 @@ function createIpcClient(socketPath) {
   return {
     connect() {
       return new Promise((resolve, reject) => {
+        let settled = false;
         socket = net.createConnection(socketPath);
         socket.on("connect", () => {
           connected = true;
+          settled = true;
           resolve();
         });
         socket.on("data", handleData);
@@ -49,7 +52,8 @@ function createIpcClient(socketPath) {
         });
         socket.on("error", (err) => {
           connected = false;
-          if (!connected) {
+          if (!settled) {
+            settled = true;
             reject(err);
           }
         });