sentinelayer-cli 0.36.2 → 0.36.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sentinelayer-cli",
-  "version": "0.36.2",
+  "version": "0.36.3",
   "description": "Scaffold Sentinelayer spec/prompt/guide artifacts with secure browser auth and token bootstrap.",
   "type": "module",
   "scripts": {

package/src/commands/session.js

@@ -69,6 +69,7 @@ import {
   getListenerProcessStatus,
   removeListenerPidRecord,
   requestListenerProcessStop,
+  stopMatchingListenerProcesses,
   writeListenerPidRecord,
 } from "../session/listener-process.js";
 import {
@@ -4752,10 +4753,26 @@ export function registerSessionCommand(program) {
           );
         }
         if (existingListener.running && options.force) {
-          const stopResult = await requestListenerProcessStop(existingListener.pid);
-          if (!stopResult.stopped) {
+          const stopMatchesResult = await stopMatchingListenerProcesses(normalizedSessionId, agentId);
+          const stoppedPids = new Set(
+            stopMatchesResult.results
+              .filter((result) => result.stopped)
+              .map((result) => Number(result.pid)),
+          );
+          let explicitStopResult = null;
+          if (existingListener.pid && !stoppedPids.has(Number(existingListener.pid))) {
+            explicitStopResult = await requestListenerProcessStop(existingListener.pid);
+          }
+          const failedStops = [
+            ...stopMatchesResult.failed,
+            ...(explicitStopResult && !explicitStopResult.stopped
+              ? [{ pid: existingListener.pid, ...explicitStopResult }]
+              : []),
+          ];
+          if (failedStops.length > 0) {
+            const failed = failedStops[0];
             throw new Error(
-              `Unable to stop existing listener pid ${existingListener.pid} for session ${normalizedSessionId} as ${agentId} (${stopResult.reason}). Stop it manually or use --allow-duplicate if parallel listeners are intentional.`,
+              `Unable to stop existing listener pid ${failed.pid || existingListener.pid} for session ${normalizedSessionId} as ${agentId} (${failed.reason}). Stop it manually or use --allow-duplicate if parallel listeners are intentional.`,
             );
           }
         }

package/src/session/listener-process.js

@@ -30,20 +30,120 @@ function normalizeCommandLine(value) {
   return normalizeString(value).toLowerCase();
 }
 
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function commandLineFlagValueMatches(commandLine, flagName, expectedValue) {
+  const expected = normalizeString(expectedValue).toLowerCase();
+  if (!expected) return { found: false, matches: true };
+  const pattern = new RegExp(
+    `(?:^|\\s)--${escapeRegExp(flagName)}(?:=|\\s+)(?:"([^"]+)"|'([^']+)'|([^\\s]+))`,
+    "gi",
+  );
+  let found = false;
+  for (const match of commandLine.matchAll(pattern)) {
+    found = true;
+    const value = normalizeString(match[1] ?? match[2] ?? match[3]).toLowerCase();
+    if (value === expected) {
+      return { found: true, matches: true };
+    }
+  }
+  return { found, matches: false };
+}
+
 function listenerCommandLineMatches(commandLine, { sessionId = "", agentId = "" } = {}) {
-  const normalized = normalizeCommandLine(commandLine);
+  const rawCommandLine = normalizeString(commandLine);
+  const normalized = normalizeCommandLine(rawCommandLine);
   if (!normalized) return false;
   const normalizedSessionId = normalizeString(sessionId).toLowerCase();
   const normalizedAgentId = normalizeString(agentId).toLowerCase();
   const hasCliEntry =
     normalized.includes("sentinelayer-cli") ||
     /[\\/](?:sl|sentinelayer-cli)\.js\b/.test(normalized);
+  const sessionFlagMatch = commandLineFlagValueMatches(rawCommandLine, "session", normalizedSessionId);
+  const agentFlagMatch = commandLineFlagValueMatches(rawCommandLine, "agent", normalizedAgentId);
   return (
     hasCliEntry &&
     normalized.includes("session") &&
     normalized.includes("listen") &&
-    (!normalizedSessionId || normalized.includes(normalizedSessionId)) &&
-    (!normalizedAgentId || normalized.includes(normalizedAgentId))
+    (!normalizedSessionId ||
+      (sessionFlagMatch.found
+        ? sessionFlagMatch.matches
+        : normalized.includes(normalizedSessionId))) &&
+    (!normalizedAgentId ||
+      (agentFlagMatch.found
+        ? agentFlagMatch.matches
+        : normalized.includes(normalizedAgentId)))
+  );
+}
+
+function normalizeProcessRows(rows = []) {
+  if (!Array.isArray(rows)) return [];
+  return rows
+    .map((row) => ({
+      pid: Number(row?.pid ?? row?.ProcessId ?? row?.processId),
+      commandLine: normalizeString(row?.commandLine ?? row?.CommandLine ?? row?.command ?? row?.args),
+    }))
+    .filter((row) => Number.isInteger(row.pid) && row.pid > 0 && row.commandLine);
+}
+
+async function listWindowsProcesses() {
+  const command = [
+    "$ErrorActionPreference = 'Stop';",
+    "$rows = Get-CimInstance Win32_Process |",
+    "Where-Object { $_.CommandLine -and ($_.CommandLine -match 'sentinelayer-cli|[\\\\/](sl|sentinelayer-cli)\\.js') } |",
+    "Select-Object ProcessId,CommandLine;",
+    "if ($rows) { $rows | ConvertTo-Json -Compress }",
+  ].join(" ");
+  const { stdout } = await execFileAsync(
+    "powershell.exe",
+    ["-NoProfile", "-NonInteractive", "-Command", command],
+    { windowsHide: true, timeout: 3000, maxBuffer: 10 * 1024 * 1024 },
+  );
+  const text = normalizeString(stdout);
+  if (!text) return [];
+  const parsed = JSON.parse(text);
+  return normalizeProcessRows(Array.isArray(parsed) ? parsed : [parsed]);
+}
+
+async function listPosixProcesses() {
+  const { stdout } = await execFileAsync("ps", ["-eo", "pid=,command="], {
+    timeout: 3000,
+    maxBuffer: 10 * 1024 * 1024,
+  });
+  return String(stdout || "")
+    .split(/\r?\n/)
+    .map((line) => {
+      const match = line.match(/^\s*(\d+)\s+(.*)$/);
+      return match ? { pid: Number(match[1]), commandLine: normalizeString(match[2]) } : null;
+    })
+    .filter(Boolean);
+}
+
+async function listProcessTable() {
+  try {
+    return process.platform === "win32"
+      ? await listWindowsProcesses()
+      : await listPosixProcesses();
+  } catch {
+    return [];
+  }
+}
+
+export async function listMatchingListenerProcesses(
+  sessionId,
+  agentId,
+  {
+    excludePid = process.pid,
+    _listProcesses = listProcessTable,
+  } = {},
+) {
+  const rows = normalizeProcessRows(await _listProcesses());
+  const excluded = Number(excludePid);
+  return rows.filter((row) =>
+    row.pid !== excluded &&
+    listenerCommandLineMatches(row.commandLine, { sessionId, agentId })
   );
 }
 
@@ -276,6 +376,7 @@ export async function getListenerProcessStatus(
     targetPath = process.cwd(),
     homeDir = os.homedir(),
     _readProcessCommandLine = readProcessCommandLine,
+    _listProcesses = listProcessTable,
   } = {},
 ) {
   const records = [
@@ -302,6 +403,22 @@ export async function getListenerProcessStatus(
     }
     staleStatuses.push(status);
   }
+  const matchingProcesses = await listMatchingListenerProcesses(sessionId, agentId, {
+    _listProcesses,
+  });
+  if (matchingProcesses.length > 0) {
+    return {
+      running: true,
+      pid: matchingProcesses[0].pid,
+      stale: false,
+      record: null,
+      recordScope: "process_scan",
+      untracked: true,
+      listenerKey: normalizeListenerProcessKey(agentId),
+      commandLine: matchingProcesses[0].commandLine,
+      matchingProcesses,
+    };
+  }
   if (staleStatuses.length === 0) {
     return {
       running: false,
@@ -314,6 +431,42 @@ export async function getListenerProcessStatus(
   return staleStatuses[0];
 }
 
+export async function stopMatchingListenerProcesses(
+  sessionId,
+  agentId,
+  {
+    excludePid = process.pid,
+    timeoutMs = 3000,
+    pollIntervalMs = 100,
+    _listProcesses = listProcessTable,
+  } = {},
+) {
+  const matches = await listMatchingListenerProcesses(sessionId, agentId, {
+    excludePid,
+    _listProcesses,
+  });
+  const results = [];
+  for (const match of matches) {
+    const result = await requestListenerProcessStop(match.pid, {
+      timeoutMs,
+      pollIntervalMs,
+    });
+    results.push({
+      pid: match.pid,
+      commandLine: match.commandLine,
+      ...result,
+    });
+  }
+  const failed = results.filter((result) => !result.stopped);
+  return {
+    matches,
+    results,
+    stoppedCount: results.filter((result) => result.stopped).length,
+    failedCount: failed.length,
+    failed,
+  };
+}
+
 export async function requestListenerProcessStop(
   pid,
   { signal = "SIGTERM", timeoutMs = 3000, pollIntervalMs = 100 } = {},