@polterware/polter 0.3.1 → 0.4.1

package/dist/api.js

@@ -1,12 +1,17 @@
-import "./chunk-AGVTFYXU.js";
+import {
+  createIpcClient
+} from "./chunk-VYHW3UNY.js";
 import {
   allCommands,
   applyActions,
+  createIpcServer,
   deletePipeline,
   detectPkgManager,
   executePipeline,
   features,
   findPipelineByName,
+  findProcessesByCwd,
+  findRunningByCommand,
   generateProcessId,
   getAllPipelines,
   getCommandById,
@@ -17,6 +22,8 @@ import {
   getFlagsForTool,
   getMcpStatusInfo,
   getProcessOutput,
+  getSocketPath,
+  getToolDisplayName,
   getToolInfo,
   installMcpServerSilent,
   isProcessRunning,
@@ -33,15 +40,19 @@ import {
   stopProcess,
   toolFlags,
   translateCommand
-} from "./chunk-7MIUDIAI.js";
+} from "./chunk-ZHVOYB5M.js";
 export {
   allCommands,
   applyActions,
+  createIpcClient,
+  createIpcServer,
   deletePipeline,
   detectPkgManager,
   executePipeline,
   features,
   findPipelineByName,
+  findProcessesByCwd,
+  findRunningByCommand,
   generateProcessId,
   getAllPipelines,
   getCommandById,
@@ -52,6 +63,8 @@ export {
   getFlagsForTool,
   getMcpStatusInfo,
   getProcessOutput,
+  getSocketPath,
+  getToolDisplayName,
   getToolInfo,
   installMcpServerSilent,
   isProcessRunning,

package/dist/chunk-VYHW3UNY.js

@@ -0,0 +1,108 @@
+import {
+  parseMessages,
+  serializeMessage
+} from "./chunk-ZHVOYB5M.js";
+
+// src/lib/ipcClient.ts
+import net from "net";
+var DEFAULT_TIMEOUT = 5e3;
+function createIpcClient(socketPath) {
+  let socket = null;
+  let connected = false;
+  let nextId = 1;
+  let buffer = "";
+  const pending = /* @__PURE__ */ new Map();
+  function handleData(data) {
+    buffer += data.toString();
+    const { messages, remainder } = parseMessages(buffer);
+    buffer = remainder;
+    for (const msg of messages) {
+      if ("id" in msg && !("method" in msg)) {
+        const resp = msg;
+        const entry = pending.get(resp.id);
+        if (entry) {
+          pending.delete(resp.id);
+          if (resp.error) {
+            entry.reject(new Error(resp.error.message));
+          } else {
+            entry.resolve(resp.result);
+          }
+        }
+      }
+    }
+  }
+  return {
+    connect() {
+      return new Promise((resolve, reject) => {
+        socket = net.createConnection(socketPath);
+        socket.on("connect", () => {
+          connected = true;
+          resolve();
+        });
+        socket.on("data", handleData);
+        socket.on("close", () => {
+          connected = false;
+          for (const entry of pending.values()) {
+            entry.reject(new Error("Connection closed"));
+          }
+          pending.clear();
+        });
+        socket.on("error", (err) => {
+          connected = false;
+          if (!connected) {
+            reject(err);
+          }
+        });
+      });
+    },
+    disconnect() {
+      if (socket) {
+        socket.destroy();
+        socket = null;
+        connected = false;
+      }
+    },
+    isConnected() {
+      return connected;
+    },
+    call(method, params) {
+      if (!socket || !connected) {
+        return Promise.reject(new Error("Not connected"));
+      }
+      const id = nextId++;
+      const request = {
+        jsonrpc: "2.0",
+        id,
+        method,
+        ...params !== void 0 ? { params } : {}
+      };
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pending.delete(id);
+          reject(new Error(`RPC call "${method}" timed out after ${DEFAULT_TIMEOUT}ms`));
+        }, DEFAULT_TIMEOUT);
+        pending.set(id, {
+          resolve: (v) => {
+            clearTimeout(timer);
+            resolve(v);
+          },
+          reject: (e) => {
+            clearTimeout(timer);
+            reject(e);
+          }
+        });
+        try {
+          socket.write(serializeMessage(request));
+        } catch (err) {
+          clearTimeout(timer);
+          pending.delete(id);
+          reject(err);
+        }
+      });
+    }
+  };
+}
+
+export {
+  createIpcClient
+};

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

@@ -675,8 +675,7 @@ var gitCommands = [
 
 // src/data/commands/pkg.ts
 var pkgCommands = [
-  // Build & Publish
-  { id: "pkg:build", tool: "pkg", base: ["run", "build"], label: "build", hint: "Run build script" },
+  // 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" },
@@ -695,8 +694,7 @@ var pkgCommands = [
   // Registry & Config
   { id: "pkg:config:list", tool: "pkg", base: ["config", "list"], label: "config list", hint: "Show config" },
   { id: "pkg:whoami", tool: "pkg", base: ["whoami"], label: "whoami", hint: "Show logged-in user" },
-  // Scripts & Info
-  { id: "pkg:run", tool: "pkg", base: ["run"], label: "run", hint: "Run a package script" },
+  // 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" }
@@ -863,8 +861,6 @@ var features = [
       "pkg:outdated",
       "pkg:audit",
       "pkg:ls",
-      "pkg:build",
-      "pkg:run",
       "pkg:publish",
       "pkg:pack",
       "pkg:version:patch",
@@ -993,6 +989,7 @@ function runCommand(execution, args, cwd = process.cwd(), options) {
     cwd,
     env: resolvedExecution.env,
     shell: true,
+    detached: true,
     stdio: [options?.quiet ? "pipe" : "inherit", "pipe", "pipe"]
   });
   if (options?.quiet) {
@@ -1003,11 +1000,13 @@ function runCommand(execution, args, cwd = process.cwd(), options) {
       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({
@@ -1024,7 +1023,14 @@ function runCommand(execution, args, cwd = process.cwd(), options) {
   });
   return {
     promise,
-    abort: () => child.kill("SIGTERM")
+    abort: () => {
+      if (child.pid) {
+        try {
+          process.kill(-child.pid, "SIGTERM");
+        } catch {
+        }
+      }
+    }
   };
 }
 function runInteractiveCommand(execution, args, cwd = process.cwd()) {
@@ -1183,6 +1189,20 @@ function execCapture(command) {
 }
 
 // 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);
@@ -1325,6 +1345,31 @@ function getToolLinkInfo(toolId, cwd = process.cwd()) {
 
 // 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 };
@@ -1492,6 +1537,20 @@ function removeProcess(id) {
   }
   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();
@@ -1510,6 +1569,188 @@ function toProcessInfo(proc) {
     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()) {
@@ -1564,32 +1805,8 @@ async function executePipeline(pipeline, onProgress, cwd = process.cwd()) {
 }
 
 // src/config/projectConfig.ts
-import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
-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/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() {
@@ -1602,13 +1819,13 @@ function defaultConfig() {
 function getProjectConfigPath(startDir) {
   const root = findNearestPackageRoot(startDir);
   if (!root) return void 0;
-  const dir = join5(root, CONFIG_DIR);
-  return { dir, file: join5(dir, CONFIG_FILE) };
+  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 (!existsSync5(paths.file)) return void 0;
+  if (!existsSync6(paths.file)) return void 0;
   try {
     const raw = readFileSync2(paths.file, "utf-8");
     return JSON.parse(raw);
@@ -1619,7 +1836,7 @@ function readProjectConfig(startDir) {
 function writeProjectConfig(config2, startDir) {
   const paths = getProjectConfigPath(startDir);
   if (!paths) return false;
-  mkdirSync(paths.dir, { recursive: true });
+  mkdirSync2(paths.dir, { recursive: true });
   writeFileSync(paths.file, JSON.stringify(config2, null, 2) + "\n", "utf-8");
   return true;
 }
@@ -1709,8 +1926,8 @@ function findPipelineByName(name, startDir) {
 }
 
 // src/declarative/parser.ts
-import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
-import { join as join6 } from "path";
+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");
@@ -1782,8 +1999,8 @@ function parseValue(raw) {
   return raw;
 }
 function findPolterYaml(startDir = process.cwd()) {
-  const filePath = join6(startDir, YAML_FILE);
-  return existsSync6(filePath) ? filePath : void 0;
+  const filePath = join7(startDir, YAML_FILE);
+  return existsSync7(filePath) ? filePath : void 0;
 }
 function parsePolterYaml(startDir = process.cwd()) {
   const filePath = findPolterYaml(startDir);
@@ -1929,16 +2146,16 @@ async function applyActions(actions, cwd = process.cwd(), onProgress) {
 
 // src/lib/mcpInstaller.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync7 } from "fs";
-import { join as join7, dirname as dirname4 } from "path";
+import { 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 = dirname4(fileURLToPath(import.meta.url));
+var __dirname = dirname5(fileURLToPath(import.meta.url));
 function readPkgVersion() {
   for (const rel of ["../../package.json", "../package.json"]) {
-    const p = join7(__dirname, rel);
-    if (existsSync7(p)) {
+    const p = join8(__dirname, rel);
+    if (existsSync8(p)) {
       const pkg = JSON.parse(readFileSync4(p, "utf-8"));
       return pkg.version;
     }
@@ -1961,15 +2178,15 @@ function tryClaudeCli(scope) {
 }
 function getSettingsPath(scope) {
   if (scope === "project") {
-    return join7(process.cwd(), ".mcp.json");
+    return join8(process.cwd(), ".mcp.json");
   }
-  return join7(homedir(), ".claude", "settings.json");
+  return join8(homedir(), ".claude", "settings.json");
 }
 function tryManualInstall(scope) {
   const settingsPath = getSettingsPath(scope);
-  const dir = join7(settingsPath, "..");
+  const dir = join8(settingsPath, "..");
   let settings = {};
-  if (existsSync7(settingsPath)) {
+  if (existsSync8(settingsPath)) {
     try {
       settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
     } catch {
@@ -1978,7 +2195,7 @@ function tryManualInstall(scope) {
       return false;
     }
   } else {
-    mkdirSync2(dir, { recursive: true });
+    mkdirSync3(dir, { recursive: true });
   }
   const mcpServers = settings.mcpServers ?? {};
   mcpServers.polter = {
@@ -2030,7 +2247,7 @@ async function removeMcpServer(scope) {
     process.stdout.write(pc.yellow("  'claude mcp remove' failed, falling back to manual removal...\n\n"));
   }
   const settingsPath = getSettingsPath(scope);
-  if (!existsSync7(settingsPath)) {
+  if (!existsSync8(settingsPath)) {
     process.stdout.write(pc.yellow("  No settings file found. Nothing to remove.\n"));
     return;
   }
@@ -2056,11 +2273,11 @@ async function removeMcpServer(scope) {
 function getMcpStatusInfo() {
   const version = readPkgVersion();
   const scopeDefs = [
-    { label: "Project (.mcp.json)", path: join7(process.cwd(), ".mcp.json"), scope: "project" },
-    { label: "User (~/.claude/settings.json)", path: join7(homedir(), ".claude", "settings.json"), scope: "user" }
+    { 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 (!existsSync7(s.path)) {
+    if (!existsSync8(s.path)) {
       return { label: s.label, scope: s.scope, registered: false };
     }
     try {
@@ -2107,7 +2324,7 @@ async function removeMcpServerSilent(scope) {
     messages.push("'claude mcp remove' failed, falling back to manual removal...");
   }
   const settingsPath = getSettingsPath(scope);
-  if (!existsSync7(settingsPath)) {
+  if (!existsSync8(settingsPath)) {
     messages.push("No settings file found. Nothing to remove.");
     return { success: true, message: messages.join("\n") };
   }
@@ -2146,11 +2363,11 @@ async function mcpStatus() {
   }
   process.stdout.write("\n");
   const scopes = [
-    { label: "Project (.mcp.json)", path: join7(process.cwd(), ".mcp.json"), key: "project" },
-    { label: "User (~/.claude/settings.json)", path: join7(homedir(), ".claude", "settings.json"), key: "user" }
+    { 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 (!existsSync7(scope.path)) {
+    if (!existsSync8(scope.path)) {
       process.stdout.write(`  ${scope.label}: ${pc.dim("not found")}
 `);
       continue;
@@ -2190,9 +2407,11 @@ export {
   detectPkgManager,
   translateCommand,
   resolvePkgArgs,
+  getToolDisplayName,
   resolveToolCommand,
   getToolInfo,
   getToolLinkInfo,
+  findNearestPackageRoot,
   generateProcessId,
   startProcess,
   stopProcess,
@@ -2200,8 +2419,13 @@ export {
   getProcessOutput,
   isProcessRunning,
   removeProcess,
+  findProcessesByCwd,
+  findRunningByCommand,
+  getSocketPath,
+  serializeMessage,
+  parseMessages,
+  createIpcServer,
   executePipeline,
-  findNearestPackageRoot,
   getProjectConfigPath,
   writeProjectConfig,
   getOrCreateProjectConfig,