sentinelayer-cli 0.36.2 → 0.36.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sentinelayer-cli",
-  "version": "0.36.2",
+  "version": "0.36.4",
   "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,8 @@ import {
   getListenerProcessStatus,
   removeListenerPidRecord,
   requestListenerProcessStop,
+  summarizeLocalListenerProcesses,
+  stopMatchingListenerProcesses,
   writeListenerPidRecord,
 } from "../session/listener-process.js";
 import {
@@ -4465,7 +4467,47 @@ export function registerSessionCommand(program) {
         limit,
         maxPages,
       });
-      const listeners = Array.isArray(result.listeners) ? result.listeners : [];
+      let listeners = Array.isArray(result.listeners) ? result.listeners : [];
+      let localProcessScan = {
+        ok: false,
+        reason: listeners.length > 0 ? "not_scanned" : "no_listener_rows",
+        processCount: 0,
+        duplicateProcessCount: 0,
+        agents: [],
+      };
+      if (listeners.length > 0) {
+        try {
+          const summary = await summarizeLocalListenerProcesses(
+            normalizedSessionId,
+            listeners.map((row) => row.agentId),
+          );
+          const byAgent = new Map(summary.agents.map((entry) => [entry.agentId, entry]));
+          listeners = listeners.map((row) => {
+            const local = byAgent.get(row.agentId) || {};
+            const pids = Array.isArray(local.pids) ? local.pids : [];
+            return {
+              ...row,
+              localProcessCount: Number(local.processCount || 0),
+              localDuplicateProcessCount: Number(local.duplicateProcessCount || 0),
+              localProcessPids: pids,
+            };
+          });
+          localProcessScan = {
+            ok: true,
+            processCount: Number(summary.processCount || 0),
+            duplicateProcessCount: Number(summary.duplicateProcessCount || 0),
+            agents: summary.agents,
+          };
+        } catch (error) {
+          localProcessScan = {
+            ok: false,
+            reason: normalizeString(error?.message) || "process_scan_failed",
+            processCount: 0,
+            duplicateProcessCount: 0,
+            agents: [],
+          };
+        }
+      }
       const live = listeners.filter((row) => row.status === "active" || row.status === "idle").length;
       const payload = {
         command: "session listeners",
@@ -4479,6 +4521,7 @@ export function registerSessionCommand(program) {
         listenerEventCount: Number(result.listenerEventCount || 0),
         partial: Boolean(result.partial),
         beforeSequence: result.beforeSequence || null,
+        localProcessScan,
         listeners,
       };
       if (shouldEmitJson(options, command)) {
@@ -4500,6 +4543,16 @@ export function registerSessionCommand(program) {
         else if (row.status === "idle") console.log(pc.cyan(`  ${line}`));
         else console.log(pc.gray(`  ${line}`));
       }
+      const duplicateLocalRows = listeners.filter((row) => Number(row.localDuplicateProcessCount || 0) > 0);
+      if (duplicateLocalRows.length > 0) {
+        const summary = duplicateLocalRows
+          .map((row) => `${row.agentId}:${row.localProcessCount}`)
+          .join(", ");
+        console.log(pc.yellow(`Local process warning: multiple matching listener processes detected (${summary}).`));
+        console.log(pc.gray(
+          `Use "sl session listen --session ${normalizedSessionId} --agent <your-agent> --force --from-now" to replace your own duplicate listener; coordinate before touching another agent.`,
+        ));
+      }
       return payload;
     });
 
@@ -4752,10 +4805,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,21 +30,159 @@ 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 })
+  );
+}
+
+export async function summarizeLocalListenerProcesses(
+  sessionId,
+  agentIds = [],
+  {
+    excludePid = process.pid,
+    _listProcesses = listProcessTable,
+  } = {},
+) {
+  const normalizedSessionId = normalizeString(sessionId);
+  const uniqueAgentIds = [...new Set((Array.isArray(agentIds) ? agentIds : [])
+    .map((agentId) => normalizeString(agentId))
+    .filter(Boolean))];
+  const rows = normalizeProcessRows(await _listProcesses());
+  const excluded = Number(excludePid);
+  const candidates = rows.filter((row) => row.pid !== excluded);
+  const agents = uniqueAgentIds.map((agentId) => {
+    const matches = candidates
+      .filter((row) => listenerCommandLineMatches(row.commandLine, {
+        sessionId: normalizedSessionId,
+        agentId,
+      }))
+      .sort((a, b) => a.pid - b.pid);
+    const pids = matches.map((match) => match.pid);
+    return {
+      agentId,
+      processCount: pids.length,
+      duplicateProcessCount: Math.max(0, pids.length - 1),
+      pids,
+    };
+  });
+  return {
+    sessionId: normalizedSessionId,
+    processCount: agents.reduce((sum, agent) => sum + agent.processCount, 0),
+    duplicateProcessCount: agents.reduce((sum, agent) => sum + agent.duplicateProcessCount, 0),
+    agents,
+  };
 }
 
 async function readWindowsCommandLine(pid) {
@@ -276,6 +414,7 @@ export async function getListenerProcessStatus(
     targetPath = process.cwd(),
     homeDir = os.homedir(),
     _readProcessCommandLine = readProcessCommandLine,
+    _listProcesses = listProcessTable,
   } = {},
 ) {
   const records = [
@@ -302,6 +441,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 +469,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 } = {},

package/src/session/listeners.js

@@ -246,5 +246,13 @@ export function formatListenerLine(row) {
         : row.status === "stale"
           ? "◌ stale"
           : "× stopped";
-  return `${statusLabel.padEnd(10)} ${row.agentId.padEnd(24)} cadence=${cadence.padEnd(6)} last_seen=${seen}`;
+  const localProcessCount = Number(row.localProcessCount || 0);
+  const localPids = Array.isArray(row.localProcessPids)
+    ? row.localProcessPids.filter((pid) => Number.isInteger(Number(pid)) && Number(pid) > 0)
+    : [];
+  const local =
+    localProcessCount > 1 && localPids.length > 0
+      ? ` local_pids=${localPids.join(",")}`
+      : "";
+  return `${statusLabel.padEnd(10)} ${row.agentId.padEnd(24)} cadence=${cadence.padEnd(6)} last_seen=${seen}${local}`;
 }