@polterware/polter 0.4.0 → 0.4.2

package/dist/api.js

@@ -1,7 +1,10 @@
-import "./chunk-AGVTFYXU.js";
+import {
+  createIpcClient
+} from "./chunk-XCCKD3RZ.js";
 import {
   allCommands,
   applyActions,
+  createIpcServer,
   deletePipeline,
   detectPkgManager,
   executePipeline,
@@ -19,6 +22,9 @@ import {
   getFlagsForTool,
   getMcpStatusInfo,
   getProcessOutput,
+  getSkillContent,
+  getSkillPath,
+  getSocketPath,
   getToolDisplayName,
   getToolInfo,
   installMcpServerSilent,
@@ -26,20 +32,25 @@ import {
   listProcesses,
   parsePolterYaml,
   planChanges,
+  registerForegroundProcess,
   removeMcpServerSilent,
   removeProcess,
   resolvePkgArgs,
   resolveToolCommand,
   runCommand,
   savePipeline,
+  setupSkill,
+  setupSkillCli,
   startProcess,
   stopProcess,
   toolFlags,
   translateCommand
-} from "./chunk-YNOZDU75.js";
+} from "./chunk-CWBIXRZP.js";
 export {
   allCommands,
   applyActions,
+  createIpcClient,
+  createIpcServer,
   deletePipeline,
   detectPkgManager,
   executePipeline,
@@ -57,6 +68,9 @@ export {
   getFlagsForTool,
   getMcpStatusInfo,
   getProcessOutput,
+  getSkillContent,
+  getSkillPath,
+  getSocketPath,
   getToolDisplayName,
   getToolInfo,
   installMcpServerSilent,
@@ -64,12 +78,15 @@ export {
   listProcesses,
   parsePolterYaml,
   planChanges,
+  registerForegroundProcess,
   removeMcpServerSilent,
   removeProcess,
   resolvePkgArgs,
   resolveToolCommand,
   runCommand,
   savePipeline,
+  setupSkill,
+  setupSkillCli,
   startProcess,
   stopProcess,
   toolFlags,

package/dist/{chunk-YNOZDU75.js → chunk-CWBIXRZP.js}

@@ -989,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) {
@@ -1022,7 +1023,15 @@ 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 {
+        }
+      }
+    },
+    child
   };
 }
 function runInteractiveCommand(execution, args, cwd = process.cwd()) {
@@ -1337,6 +1346,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 };
@@ -1437,6 +1471,47 @@ function startProcess(id, command, args = [], cwd = process.cwd(), env) {
   registry.set(id, tracked);
   return toProcessInfo(tracked);
 }
+function registerForegroundProcess(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) => {
+    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}"`);
@@ -1536,6 +1611,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()) {
@@ -1590,32 +1847,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() {
@@ -1628,13 +1861,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);
@@ -1645,7 +1878,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;
 }
@@ -1735,8 +1968,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");
@@ -1808,8 +2041,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);
@@ -1955,16 +2188,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;
     }
@@ -1987,15 +2220,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 {
@@ -2004,7 +2237,7 @@ function tryManualInstall(scope) {
       return false;
     }
   } else {
-    mkdirSync2(dir, { recursive: true });
+    mkdirSync3(dir, { recursive: true });
   }
   const mcpServers = settings.mcpServers ?? {};
   mcpServers.polter = {
@@ -2056,7 +2289,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;
   }
@@ -2082,11 +2315,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 {
@@ -2133,7 +2366,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") };
   }
@@ -2172,11 +2405,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;
@@ -2198,6 +2431,119 @@ async function mcpStatus() {
   }
 }
 
+// src/lib/skillSetup.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, existsSync as existsSync9 } from "fs";
+import { join as join9 } from "path";
+import { homedir as homedir2 } from "os";
+import pc2 from "picocolors";
+var SKILL_DIR = join9(homedir2(), ".claude", "skills", "polter");
+var SKILL_PATH = join9(SKILL_DIR, "SKILL.md");
+var SKILL_CONTENT = `---
+name: polter
+description: "Polter - Infrastructure Orchestrator. Use when developing in any project to: monitor dev processes and check logs for errors after code changes, manage pipelines (multi-step command sequences), run CLI commands (Supabase, GitHub, Vercel, Git), manage packages (install, build, publish, audit), and apply declarative infrastructure from polter.yaml."
+---
+
+# Polter Skill
+
+You have access to Polter MCP tools for infrastructure orchestration. Use them proactively during development.
+
+## Process Monitoring
+
+**Tools:** \`polter_ps\`, \`polter_logs\`, \`polter_start\`, \`polter_stop\`, \`polter_find_process\`, \`polter_smart_start\`, \`polter_run_script_bg\`
+
+- At the start of a session, run \`polter_ps\` to check for active dev processes
+- After significant code edits, check \`polter_logs\` for compilation or runtime errors
+- Use \`polter_find_process\` to find processes running in the current directory
+- Use \`polter_smart_start\` to start package.json scripts as background processes (e.g. dev servers)
+- Use \`polter_run_script_bg\` to run arbitrary scripts in the background
+- Use \`polter_stop\` to stop processes that are no longer needed
+
+## CLI Commands
+
+**Tools:** \`polter_list_commands\`, \`polter_run_command\`, \`polter_status\`
+
+- Execute commands for Supabase, GitHub CLI, Vercel, and Git via their command IDs
+- Use \`polter_list_commands\` to discover available commands, optionally filtered by tool
+- Use \`polter_run_command\` to execute a command by its ID with additional args/flags
+- Check \`polter_status\` to see which CLI tools are installed and their versions
+
+## Pipelines
+
+**Tools:** \`polter_list_pipelines\`, \`polter_run_pipeline\`, \`polter_create_pipeline\`, \`polter_update_pipeline\`, \`polter_delete_pipeline\`
+
+- List and run saved multi-step command sequences with \`polter_list_pipelines\` and \`polter_run_pipeline\`
+- Create new pipelines for repetitive workflows (e.g. build + test + deploy) with \`polter_create_pipeline\`
+- Suggest creating pipelines when you notice the user repeating the same sequence of commands
+
+## Package Management
+
+**Tools:** \`polter_pkg_build\`, \`polter_pkg_install\`, \`polter_pkg_publish\`, \`polter_pkg_run_script\`, \`polter_pkg_version_bump\`, \`polter_pkg_audit\`, \`polter_pkg_info\`
+
+- Auto-detects the package manager (npm, pnpm, yarn, bun) from lockfiles
+- Use \`polter_pkg_build\` for building, \`polter_pkg_install\` for installing dependencies
+- Use \`polter_pkg_run_script\` to run package.json scripts
+- Use \`polter_pkg_audit\` to check for vulnerabilities
+- Use \`polter_pkg_version_bump\` before publishing, then \`polter_pkg_publish\`
+
+## Declarative Infrastructure
+
+**Tools:** \`polter_plan\`, \`polter_apply\`
+
+- Use \`polter_plan\` to read \`polter.yaml\` and compute a diff of desired vs current state
+- Use \`polter_apply\` to execute the planned infrastructure changes
+- Always run \`polter_plan\` first to review changes before applying
+
+## Workflow Recommendations
+
+1. **Starting a session:** Run \`polter_ps\` to see what's already running
+2. **After code changes:** Check \`polter_logs\` for errors in dev server output
+3. **Setting up a project:** Use \`polter_status\` to verify tools, then \`polter_smart_start\` for dev server
+4. **Deploying:** Create a pipeline with build + test + deploy steps
+5. **Infrastructure changes:** Edit \`polter.yaml\`, run \`polter_plan\`, then \`polter_apply\`
+`;
+function setupSkill() {
+  if (existsSync9(SKILL_PATH)) {
+    const existing = readFileSync5(SKILL_PATH, "utf-8");
+    if (existing === SKILL_CONTENT) {
+      return { status: "already-up-to-date", path: SKILL_PATH };
+    }
+    writeFileSync3(SKILL_PATH, SKILL_CONTENT, "utf-8");
+    return { status: "updated", path: SKILL_PATH };
+  }
+  mkdirSync4(SKILL_DIR, { recursive: true });
+  writeFileSync3(SKILL_PATH, SKILL_CONTENT, "utf-8");
+  return { status: "created", path: SKILL_PATH };
+}
+function setupSkillCli() {
+  const result = setupSkill();
+  switch (result.status) {
+    case "created":
+      process.stdout.write(pc2.green(`
+  Skill installed at ${result.path}
+`));
+      process.stdout.write(pc2.dim("  Use /polter in Claude Code to activate.\n\n"));
+      break;
+    case "updated":
+      process.stdout.write(pc2.green(`
+  Skill updated at ${result.path}
+`));
+      process.stdout.write(pc2.dim("  Use /polter in Claude Code to activate.\n\n"));
+      break;
+    case "already-up-to-date":
+      process.stdout.write(pc2.cyan(`
+  Skill already up to date at ${result.path}
+
+`));
+      break;
+  }
+}
+function getSkillContent() {
+  return SKILL_CONTENT;
+}
+function getSkillPath() {
+  return SKILL_PATH;
+}
+
 export {
   __export,
   allCommands,
@@ -2220,8 +2566,10 @@ export {
   resolveToolCommand,
   getToolInfo,
   getToolLinkInfo,
+  findNearestPackageRoot,
   generateProcessId,
   startProcess,
+  registerForegroundProcess,
   stopProcess,
   listProcesses,
   getProcessOutput,
@@ -2229,8 +2577,11 @@ export {
   removeProcess,
   findProcessesByCwd,
   findRunningByCommand,
+  getSocketPath,
+  serializeMessage,
+  parseMessages,
+  createIpcServer,
   executePipeline,
-  findNearestPackageRoot,
   getProjectConfigPath,
   writeProjectConfig,
   getOrCreateProjectConfig,
@@ -2248,5 +2599,9 @@ export {
   getMcpStatusInfo,
   installMcpServerSilent,
   removeMcpServerSilent,
-  mcpStatus
+  mcpStatus,
+  setupSkill,
+  setupSkillCli,
+  getSkillContent,
+  getSkillPath
 };