@haemmid/pi-processes 0.9.2 → 0.9.3

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this project will be documented in this file.
 
 This project follows semantic versioning for public releases.
 
+## [0.9.3] - 2026-07-02
+
+### Fixed
+
+- `restart` waits for old process to fully exit before starting replacement;
+  does not start a new process if the old one does not exit within timeout.
+- `restart` error message now shows the actual signal used (SIGTERM vs SIGKILL)
+  depending on `force` parameter.
+- Ambiguous name errors now include exact process IDs in the suggestion.
+- Added manager-level regression tests for `restart`: no premature spawn,
+  timeout handling, force=SIGKILL, post-restart resolve, ambiguous name rejection.
+
 ## [0.9.2] - 2026-07-02
 
 ### Added

package/README.md

@@ -194,6 +194,8 @@ process clear
 - `ensure` reuses existing process when name+command+cwd match; returns conflict error otherwise.
 - `restart` safely kills the existing process (awaited) before starting a new one.
 - `restart` accepts `force=true` to send `SIGKILL` instead of `SIGTERM`.
+- `restart` waits for the old process to exit; if it does not exit within the
+  timeout, the replacement is not started. Use `force=true` or inspect logs.
 - `start`/`ensure`/`restart` accept `cwd` to override the working directory (defaults to session cwd).
 - `output`, `logs`, and `kill` return an error if both `id` and `name` are provided.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haemmid/pi-processes",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "description": "Agent-facing background process manager for Pi and pi-web automation workflows.",
   "license": "MIT",
   "type": "module",

package/src/manager.ts

@@ -235,6 +235,48 @@ export class ProcessManager {
     return this.toProcessInfo(managed);
   }
 
+  /**
+   * Restart a process by name: kill existing (awaited), then start new.
+   *
+   * - Waits for existing process to exit (polls every 500ms, up to timeoutMs).
+   * - Returns null if existing process does not exit after timeout.
+   * - Returns null if a different live process with the same name appears.
+   * - Returns new ProcessInfo on success.
+   */
+  async restart(
+    name: string,
+    command: string,
+    cwd: string,
+    opts?: { force?: boolean; timeoutMs?: number },
+  ): Promise<ProcessInfo | null> {
+    const existing = this.resolve(name);
+    if (!existing.ok) {
+      return null;
+    }
+
+    // Kill existing process
+    const killResult = await this.kill(existing.info.id, {
+      signal: opts?.force ? "SIGKILL" : "SIGTERM",
+      timeoutMs: opts?.timeoutMs ?? 5000,
+    });
+
+    if (!killResult.ok) {
+      // Process did not exit — return null so caller can decide
+      return null;
+    }
+
+    // Verify no other live process with this name appeared
+    const liveMatch = Array.from(this.processes.values()).find(
+      (proc) => proc.name === name && LIVE_STATUSES.has(proc.status),
+    );
+    if (liveMatch) {
+      return null;
+    }
+
+    // Start new process
+    return this.start(name, command, cwd);
+  }
+
   /**
    * Ensure a process is running with the given name, command, and cwd.
    *

package/src/tools/actions/restart.ts

@@ -2,7 +2,6 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { ExecuteResult } from "../../constants";
 import type { ProcessManager } from "../../manager";
 import { formatTimestamp, sanitizeLine } from "../../utils";
-import { executeKill } from "./kill";
 import { buildNextCommands } from "./utils";
 
 interface RestartParams {
@@ -56,46 +55,27 @@ export async function executeRestart(
     };
   }
 
-  // Kill existing process (awaited, safe)
-  const killResult = await executeKill(
-    { id: existing.info.id, force: params.force },
-    manager,
-  );
-  if (!killResult.details.success) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Failed to kill existing process: ${killResult.details.message}`,
-        },
-      ],
-      details: {
-        action: "restart",
-        success: false,
-        message: `Failed to kill existing process: ${killResult.details.message}`,
-      },
-    };
-  }
-
-  // Start new process
-  const proc = manager.start(
+  // Restart via manager (atomic: kill → await exit → start)
+  const proc = await manager.restart(
     params.name,
     params.command,
     params.cwd ?? ctx.cwd,
+    { force: params.force },
   );
 
   if (proc === null) {
+    const signal = params.force ? "SIGKILL" : "SIGTERM";
     return {
       content: [
         {
           type: "text",
-          text: `A process named "${params.name}" is already running. Use process kill first.`,
+          text: `Could not restart "${sanitizeLine(params.name)}": previous process did not exit after ${signal}. Use restart force=true or inspect logs.`,
         },
       ],
       details: {
         action: "restart",
         success: false,
-        message: `A process named "${params.name}" is already running.`,
+        message: `Previous process did not exit after ${signal}.`,
       },
     };
   }

package/src/tools/actions/utils.ts

@@ -62,17 +62,22 @@ export function resolveSelector(
     const choices = (resolved.matches ?? [])
       .map((match) => `${match.id} ("${sanitizeLine(match.name)}")`)
       .join(", ");
+    const ids = (resolved.matches ?? []).map((m) => m.id);
+    const suggestion =
+      ids.length === 2
+        ? `Use id="${ids[0]}" or id="${ids[1]}", or inspect process list.`
+        : `Use an exact process ID instead. Matches: ${choices}`;
     return {
       content: [
         {
           type: "text",
-          text: `Process name is ambiguous: "${query}". Use an exact process ID instead. Matches: ${choices}`,
+          text: `Multiple processes named "${query}" found. ${suggestion}`,
         },
       ],
       details: {
         action: "output",
         success: false,
-        message: `Process name is ambiguous: "${query}". Matches: ${choices}`,
+        message: `Multiple processes named "${query}" found. Matches: ${choices}`,
       },
     };
   }