@promptprojectmanager/mcp-server 4.6.1 → 4.6.2

package/dist/index.js

@@ -1,4 +1,12 @@
 #!/usr/bin/env node
+import {
+  getWatcherDir,
+  isWatcherRunning,
+  readPid,
+  readStatus,
+  removePid,
+  writeStatus
+} from "./chunk-PY22KZ7Z.js";
 
 // src/index.ts
 import minimist from "minimist";
@@ -101,159 +109,168 @@ function parseWatcherStartArgs(args) {
   };
 }
 
-// src/watcher/watcher_state.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
-import { join } from "path";
-function getWatcherDir(workingDirectory) {
-  const dir = join(workingDirectory, ".ppm", "yolo");
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
+// src/watcher/watcher_controller.ts
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+function startWatcher(baseConfig, args) {
+  const workingDirectory = args?.workingDirectory ?? baseConfig.workingDirectory;
+  if (isWatcherRunning(workingDirectory)) {
+    const existingPid = readPid(workingDirectory);
+    const status = readStatus(workingDirectory);
+    return {
+      success: true,
+      message: `Watcher already running (PID: ${existingPid})`,
+      pid: existingPid,
+      alreadyRunning: true,
+      config: status?.config
+    };
+  }
+  const config = {
+    projectSlug: baseConfig.projectSlug,
+    projectToken: baseConfig.projectToken,
+    convexUrl: baseConfig.convexUrl,
+    pollIntervalMs: args?.pollIntervalMs ?? 3e4,
+    maxParallel: args?.maxParallel ?? 1,
+    ticketTimeout: args?.ticketTimeout ?? 18e5,
+    enableNotifications: args?.enableNotifications ?? true,
+    workingDirectory
+  };
+  getWatcherDir(workingDirectory);
+  const daemonPath = getDaemonPath();
+  const configJson = JSON.stringify(config);
+  const configB64 = Buffer.from(configJson).toString("base64");
+  try {
+    const child = spawn("node", [daemonPath, "--config", configB64], {
+      detached: true,
+      stdio: ["ignore", "ignore", "ignore"],
+      cwd: workingDirectory
+    });
+    child.unref();
+    const pid = child.pid;
+    if (!pid) {
+      return {
+        success: false,
+        message: "Failed to spawn daemon - no PID returned"
+      };
+    }
+    const configWithoutToken = {
+      projectSlug: config.projectSlug,
+      convexUrl: config.convexUrl,
+      pollIntervalMs: config.pollIntervalMs,
+      maxParallel: config.maxParallel,
+      ticketTimeout: config.ticketTimeout,
+      enableNotifications: config.enableNotifications,
+      workingDirectory: config.workingDirectory
+    };
+    return {
+      success: true,
+      message: `Watcher started (PID: ${pid})`,
+      pid,
+      alreadyRunning: false,
+      config: configWithoutToken
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return {
+      success: false,
+      message: `Failed to start watcher: ${errorMessage}`
+    };
   }
-  return dir;
-}
-function getStatusFile(workingDirectory) {
-  return join(getWatcherDir(workingDirectory), "status.json");
 }
-function writeStatus(workingDirectory, status) {
-  const statusFile = getStatusFile(workingDirectory);
-  writeFileSync(statusFile, JSON.stringify(status, null, 2), "utf-8");
+function getDaemonPath() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const currentDir = dirname(currentFile);
+  return join(currentDir, "watcher", "watcher_daemon.js");
 }
-function readStatus(workingDirectory) {
-  const statusFile = getStatusFile(workingDirectory);
-  if (!existsSync(statusFile)) {
-    return void 0;
+function stopWatcher(workingDirectory) {
+  const pid = readPid(workingDirectory);
+  if (!pid) {
+    return {
+      success: true,
+      message: "No watcher running (no PID file)",
+      wasRunning: false
+    };
+  }
+  if (!isWatcherRunning(workingDirectory)) {
+    removePid(workingDirectory);
+    return {
+      success: true,
+      message: "Watcher was not running (stale PID file cleaned up)",
+      wasRunning: false
+    };
   }
   try {
-    const content = readFileSync(statusFile, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return void 0;
+    process.kill(pid, "SIGTERM");
+    const status = readStatus(workingDirectory);
+    if (status) {
+      writeStatus(workingDirectory, {
+        ...status,
+        state: "stopped"
+      });
+    }
+    removePid(workingDirectory);
+    return {
+      success: true,
+      message: `Watcher stopped (PID: ${pid})`,
+      wasRunning: true
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    removePid(workingDirectory);
+    return {
+      success: false,
+      message: `Failed to stop watcher: ${errorMessage}`,
+      wasRunning: true
+    };
   }
 }
-
-// src/watcher/watcher_orchestrator.ts
-function buildOrchestratorInstructions(config, pendingTickets) {
-  const pollIntervalSec = Math.round(config.pollIntervalMs / 1e3);
-  return `# \u{1F916} YOLO Orchestrator Active
-
-You are now the **YOLO Orchestrator** for project \`${config.projectSlug}\`.
-
-## \u26A0\uFE0F CRITICAL RULE: STRICT SUB-AGENT MODE
-
-**You are the ORCHESTRATOR, not the executor.**
-
-You MUST NEVER execute ticket work directly. ALL ticket execution MUST go through Task sub-agents.
-
-Your ONLY jobs are:
-1. Poll for YOLO tickets
-2. Claim tickets (transition to "working" status)
-3. Spawn Task sub-agents to execute them
-4. Report results when sub-agents complete
-
-**FORBIDDEN**: Doing the ticket work yourself (no web searches, no code writing, no file edits for tickets)
-**REQUIRED**: Always use the Task tool to spawn a sub-agent for EVERY ticket
-
----
-
-## Current Configuration
-| Setting | Value |
-|---------|-------|
-| Poll Interval | ${pollIntervalSec}s |
-| Max Parallel | ${config.maxParallel} |
-| Ticket Timeout | ${Math.round(config.ticketTimeout / 1e3 / 60)} minutes |
-| Working Directory | ${config.workingDirectory} |
-
-## Pending YOLO Tickets
-${pendingTickets.length > 0 ? formatPendingTickets(pendingTickets) : "_No tickets with YOLO flag currently in queue._"}
-
-${pendingTickets.length > 0 ? `
-## \u{1F4E5} Execute These Tickets NOW
-
-For EACH pending ticket, you MUST:
-
-### Step 1: Claim the ticket
-\`\`\`
-tickets_work with ticketSlug: "{slug}"
-\`\`\`
-
-### Step 2: Spawn a Task sub-agent (REQUIRED - DO NOT SKIP)
-\`\`\`
-Task tool with:
-  description: "Execute YOLO ticket {slug}"
-  subagent_type: "general-purpose"
-  prompt: [use the template below]
-  run_in_background: ${config.maxParallel > 1 ? "true" : "false"}
-\`\`\`
-
-### Sub-Agent Prompt Template (copy this exactly):
-
-\`\`\`
-You are executing a YOLO ticket autonomously.
-
-## Ticket: {ticketSlug}
-
-{ticketContent}
-
----
-
-## Your Instructions
-
-1. Execute the task described above
-2. When complete, close the ticket: tickets_close with ticketSlug: "{ticketSlug}"
-3. If blocked, update the ticket: tickets_update with your findings
-4. Return a brief summary of what you accomplished
-\`\`\`
-
-### Step 3: Report the result
-After each sub-agent completes, report:
-- \u2705 Success: what was done
-- \u274C Failure: what went wrong
-
----
-
-**START NOW**: Claim and spawn sub-agents for all ${pendingTickets.length} pending ticket(s) above.
-` : `
-## \u{1F504} No Tickets Ready
-
-No YOLO tickets are currently pending. Options:
-- Say **"poll"** to check for new tickets
-- Say **"stop"** to exit orchestrator mode
-`}
-
-## Commands
-| Command | Action |
-|---------|--------|
-| "poll" / "check" | Refresh the ticket list |
-| "status" | Show orchestrator status |
-| "stop" / "exit" | Stop the orchestrator |
-
----
-
-_Orchestrator started at ${(/* @__PURE__ */ new Date()).toISOString()}_`;
-}
-function formatPendingTickets(tickets) {
-  return tickets.map((t, i) => {
-    const num = t.ticketNumber ? `#${t.ticketNumber}` : "";
-    const title = t.slug;
-    const preview = t.content.slice(0, 150).replace(/\n/g, " ");
-    return `### ${i + 1}. ${num} ${title}
-> ${preview}${t.content.length > 150 ? "..." : ""}`;
-  }).join("\n\n");
+function getWatcherStatus(workingDirectory) {
+  const status = readStatus(workingDirectory);
+  const isRunning = isWatcherRunning(workingDirectory);
+  if (status?.state === "running" && !isRunning) {
+    const updatedStatus = {
+      ...status,
+      state: "stopped"
+    };
+    writeStatus(workingDirectory, updatedStatus);
+    return {
+      success: true,
+      status: updatedStatus,
+      formattedStatus: formatStatus(updatedStatus),
+      message: "Watcher died unexpectedly - status updated"
+    };
+  }
+  if (!status) {
+    return {
+      success: true,
+      message: "No watcher session found for this project",
+      formattedStatus: formatStatus(null)
+    };
+  }
+  return {
+    success: true,
+    status,
+    formattedStatus: formatStatus(status)
+  };
 }
-function formatOrchestratorStatus(status, pendingTickets) {
+function formatStatus(status) {
   if (!status) {
-    return `# YOLO Orchestrator Status
+    return `# YOLO Watcher Status
 
 **State**: Not started
 
-_Use \`tickets_yolo_start\` to begin orchestration._`;
+_Use \`tickets_yolo_start\` to begin watching for YOLO tickets._`;
   }
   const lines = [
-    "# YOLO Orchestrator Status",
+    "# YOLO Watcher Status",
     "",
     `**State**: ${status.state}`,
     `**Project**: ${status.projectSlug}`
   ];
+  if (status.pid) {
+    lines.push(`**Daemon PID**: ${status.pid}`);
+  }
   if (status.startedAt) {
     lines.push(`**Started**: ${status.startedAt}`);
   }
@@ -261,27 +278,38 @@ _Use \`tickets_yolo_start\` to begin orchestration._`;
     lines.push(`**Last Poll**: ${status.lastPollAt}`);
   }
   lines.push(`**Tickets Processed**: ${status.ticketsProcessed}`);
+  if (status.config) {
+    lines.push("");
+    lines.push("## Configuration");
+    lines.push(`- Poll Interval: ${status.config.pollIntervalMs / 1e3}s`);
+    lines.push(`- Max Parallel: ${status.config.maxParallel}`);
+    lines.push(`- Ticket Timeout: ${status.config.ticketTimeout / 1e3 / 60} min`);
+    lines.push(`- Notifications: ${status.config.enableNotifications ? "enabled" : "disabled"}`);
+  }
   if (status.currentlyExecuting && status.currentlyExecuting.length > 0) {
     lines.push("");
-    lines.push("## Currently Executing (Sub-Agents)");
+    lines.push("## Currently Executing");
     for (const exec of status.currentlyExecuting) {
       const num = exec.ticketNumber ? `#${exec.ticketNumber}` : "";
       const elapsed = getElapsedTime(exec.startedAt);
       lines.push(`- **${num} ${exec.ticketSlug}** (${elapsed})`);
     }
   }
-  lines.push("");
-  lines.push("## Pending YOLO Tickets");
-  if (pendingTickets.length > 0) {
-    lines.push("");
-    lines.push("**Action Required**: Spawn Task sub-agents for these tickets:");
+  if (status.completedTickets && status.completedTickets.length > 0) {
     lines.push("");
-    for (const ticket of pendingTickets) {
-      const num = ticket.ticketNumber ? `#${ticket.ticketNumber}` : "";
-      lines.push(`- **${num} ${ticket.slug}**`);
+    lines.push("## Recently Completed");
+    for (const completed of status.completedTickets.slice(0, 10)) {
+      const num = completed.ticketNumber ? `#${completed.ticketNumber}` : "";
+      const emoji = completed.success ? "\u2705" : "\u274C";
+      const duration = formatDuration(completed.durationMs);
+      const summary = completed.summary ? ` - ${completed.summary.slice(0, 50)}` : "";
+      lines.push(`- ${emoji} **${num} ${completed.ticketSlug}** (${duration})${summary}`);
     }
-  } else {
-    lines.push("_No tickets pending_");
+  }
+  if (status.lastError) {
+    lines.push("");
+    lines.push("## Last Error");
+    lines.push(`\`${status.lastError}\``);
   }
   return lines.join("\n");
 }
@@ -295,87 +323,17 @@ function getElapsedTime(startedAt) {
   }
   return `${seconds}s`;
 }
-
-// src/watcher/watcher_controller.ts
-function startOrchestrator(baseConfig, args, pendingTickets) {
-  const workingDirectory = args?.workingDirectory ?? baseConfig.workingDirectory;
-  const orchestratorConfig = {
-    projectSlug: baseConfig.projectSlug,
-    pollIntervalMs: args?.pollIntervalMs ?? 3e4,
-    maxParallel: args?.maxParallel ?? 1,
-    ticketTimeout: args?.ticketTimeout ?? 18e5,
-    workingDirectory
-  };
-  getWatcherDir(workingDirectory);
-  const initialStatus = {
-    state: "running",
-    projectSlug: baseConfig.projectSlug,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    ticketsProcessed: 0,
-    currentlyExecuting: [],
-    config: {
-      projectSlug: baseConfig.projectSlug,
-      convexUrl: baseConfig.convexUrl,
-      pollIntervalMs: orchestratorConfig.pollIntervalMs,
-      maxParallel: orchestratorConfig.maxParallel,
-      ticketTimeout: orchestratorConfig.ticketTimeout,
-      enableNotifications: args?.enableNotifications ?? true,
-      workingDirectory
-    }
-  };
-  writeStatus(workingDirectory, initialStatus);
-  const instructions = buildOrchestratorInstructions(orchestratorConfig, pendingTickets);
-  return {
-    success: true,
-    message: "Orchestrator started",
-    instructions,
-    config: initialStatus.config,
-    alreadyRunning: false
-  };
-}
-function stopOrchestrator(workingDirectory) {
-  const status = readStatus(workingDirectory);
-  if (!status) {
-    return {
-      success: true,
-      message: "No orchestrator session found",
-      wasRunning: false
-    };
-  }
-  if (status.state !== "running") {
-    return {
-      success: true,
-      message: `Orchestrator was already ${status.state}`,
-      wasRunning: false
-    };
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${ms}ms`;
   }
-  writeStatus(workingDirectory, {
-    ...status,
-    state: "stopped"
-  });
-  return {
-    success: true,
-    message: "Orchestrator stopped",
-    wasRunning: true
-  };
-}
-function getOrchestratorStatus(workingDirectory, pendingTickets) {
-  const status = readStatus(workingDirectory);
-  const formattedStatus = formatOrchestratorStatus(status ?? null, pendingTickets);
-  if (!status) {
-    return {
-      success: true,
-      message: "No orchestrator session has been started for this project",
-      pendingTickets,
-      formattedStatus
-    };
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  if (minutes > 0) {
+    const remainingSeconds = seconds % 60;
+    return `${minutes}m ${remainingSeconds}s`;
   }
-  return {
-    success: true,
-    status,
-    pendingTickets,
-    formattedStatus
-  };
+  return `${seconds}s`;
 }
 
 // src/prompt-builder.ts
@@ -1624,31 +1582,30 @@ _Ticket content has been appended with your update._`
         const args = parseWatcherStartArgs(request.params.arguments);
         const workingDirectory = args.workingDirectory ?? process.cwd();
         try {
-          let pendingTickets = [];
-          try {
-            pendingTickets = await convexClient.query(
-              "mcp_tickets:listYoloTickets",
-              {
-                projectToken: config.projectToken,
-                projectSlug: ticketTool.projectSlug
-              }
-            );
-          } catch (queryError) {
-            console.error(`[MCP] Failed to query YOLO tickets:`, queryError);
-          }
-          const result = startOrchestrator(
+          const result = startWatcher(
             {
               projectSlug: ticketTool.projectSlug,
               projectToken: config.projectToken,
               convexUrl: config.convexUrl,
               workingDirectory
             },
-            args,
-            pendingTickets
+            args
           );
-          if (result.success && result.instructions) {
+          if (result.success) {
+            const configInfo = result.config ? `
+
+**Configuration:**
+- Poll Interval: ${result.config.pollIntervalMs / 1e3}s
+- Max Parallel: ${result.config.maxParallel}
+- Ticket Timeout: ${result.config.ticketTimeout / 1e3 / 60} min
+- Working Directory: ${result.config.workingDirectory}` : "";
+            const text = result.alreadyRunning ? `\u2139\uFE0F ${result.message}${configInfo}` : `\u2705 ${result.message}
+
+The daemon is now polling for YOLO-flagged tickets and will spawn Claude CLI processes to execute them.
+
+Logs: \`.ppm/yolo/logs/\`${configInfo}`;
             return {
-              content: [{ type: "text", text: result.instructions }]
+              content: [{ type: "text", text }]
             };
           } else {
             return {
@@ -1660,19 +1617,21 @@ _Ticket content has been appended with your update._`
           const errorMessage = error instanceof Error ? error.message : "Unknown error";
           console.error(`[MCP] tickets_yolo_start error:`, error);
           return {
-            content: [{ type: "text", text: `Error starting orchestrator: ${errorMessage}` }],
+            content: [{ type: "text", text: `Error starting watcher daemon: ${errorMessage}` }],
             isError: true
           };
         }
       } else if (ticketTool.type === "yolo_stop") {
         const workingDirectory = process.cwd();
         try {
-          const result = stopOrchestrator(workingDirectory);
+          const result = stopWatcher(workingDirectory);
           if (result.success) {
             return {
               content: [{
                 type: "text",
-                text: result.wasRunning ? `\u2705 Orchestrator stopped. You can stop processing tickets now.` : `\u2139\uFE0F ${result.message}`
+                text: result.wasRunning ? `\u2705 ${result.message}
+
+The daemon has been stopped. Any running ticket executions will complete.` : `\u2139\uFE0F ${result.message}`
               }]
             };
           } else {
@@ -1685,39 +1644,27 @@ _Ticket content has been appended with your update._`
           const errorMessage = error instanceof Error ? error.message : "Unknown error";
           console.error(`[MCP] tickets_yolo_stop error:`, error);
           return {
-            content: [{ type: "text", text: `Error stopping orchestrator: ${errorMessage}` }],
+            content: [{ type: "text", text: `Error stopping watcher daemon: ${errorMessage}` }],
             isError: true
           };
         }
       } else if (ticketTool.type === "yolo_status") {
         const workingDirectory = process.cwd();
         try {
-          let pendingTickets = [];
-          try {
-            pendingTickets = await convexClient.query(
-              "mcp_tickets:listYoloTickets",
-              {
-                projectToken: config.projectToken,
-                projectSlug: ticketTool.projectSlug
-              }
-            );
-          } catch (queryError) {
-            console.error(`[MCP] Failed to query YOLO tickets:`, queryError);
-          }
-          const result = getOrchestratorStatus(workingDirectory, pendingTickets);
+          const result = getWatcherStatus(workingDirectory);
           if (result.formattedStatus) {
             return {
               content: [{ type: "text", text: result.formattedStatus }]
             };
           }
           return {
-            content: [{ type: "text", text: `\u2139\uFE0F ${result.message ?? "No orchestrator status available"}` }]
+            content: [{ type: "text", text: `\u2139\uFE0F ${result.message ?? "No watcher status available"}` }]
           };
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : "Unknown error";
           console.error(`[MCP] tickets_yolo_status error:`, error);
           return {
-            content: [{ type: "text", text: `Error getting orchestrator status: ${errorMessage}` }],
+            content: [{ type: "text", text: `Error getting watcher status: ${errorMessage}` }],
             isError: true
           };
         }