sentinelayer-cli 0.36.1 → 0.36.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sentinelayer-cli",
-  "version": "0.36.1",
+  "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 } = {},

package/src/session/recap.js

@@ -484,6 +484,7 @@ function emptyWorkPlanSummary(sourceContext = {}) {
     completed: 0,
     currentSection: "",
     recentOpen: [],
+    actionableOpen: [],
     recent: [],
   };
 }
@@ -534,6 +535,41 @@ function shouldSuppressHistoricalWorkPlanDetails(summary = emptyWorkPlanSummary(
   return completed / Math.max(1, total) >= HISTORICAL_WORK_PLAN_COMPLETED_RATIO;
 }
 
+function isActionableWorkPlanOpenRecord(record = {}) {
+  if (!record || typeof record !== "object" || record.status !== "open") {
+    return false;
+  }
+  const task = normalizeString(record.task);
+  if (!task) {
+    return false;
+  }
+  return !isGenericWorkPlanSection(record.section);
+}
+
+function selectActionableWorkPlanOpenRecords(records = [], { limit = DEFAULT_WORK_PLAN_SUMMARY_LIMIT } = {}) {
+  const actionable = (Array.isArray(records) ? records : []).filter(isActionableWorkPlanOpenRecord);
+  if (actionable.length === 0) {
+    return [];
+  }
+  const latest = actionable[actionable.length - 1];
+  const latestSection = normalizeString(latest.section);
+  const selected = latestSection
+    ? actionable.filter((record) => normalizeString(record.section) === latestSection)
+    : actionable;
+  return selected.slice(-Math.max(1, normalizePositiveInteger(limit, DEFAULT_WORK_PLAN_SUMMARY_LIMIT)));
+}
+
+function formatWorkPlanOpenItems(items = []) {
+  return (Array.isArray(items) ? items : [])
+    .map((item) => {
+      const section = normalizeString(item.section);
+      const task = normalizeString(item.task);
+      return section ? `${section} - ${task}` : task;
+    })
+    .filter(Boolean)
+    .join("; ");
+}
+
 function summarizeWorkPlanMarkdown(
   raw = "",
   { limit = DEFAULT_WORK_PLAN_SUMMARY_LIMIT, truncated = false, sourceContext = {} } = {}
@@ -582,6 +618,7 @@ function summarizeWorkPlanMarkdown(
   summary.recentOpen = records
     .filter((record) => record.status === "open")
     .slice(-normalizedLimit);
+  summary.actionableOpen = selectActionableWorkPlanOpenRecords(records, { limit: normalizedLimit });
   summary.recent = records.slice(-normalizedLimit);
   if (!summary.detailSuppressed && shouldSuppressHistoricalWorkPlanDetails(summary)) {
     summary.detailSuppressed = true;
@@ -869,10 +906,17 @@ function buildWorkPlanText(workPlan = emptyWorkPlanSummary()) {
     const sourceWindowText = workPlan.truncated
       ? `recent ${sourceText} window`
       : sourceText;
+    const actionableText = formatWorkPlanOpenItems(workPlan.actionableOpen);
     const suppressionText =
       suppressionReason === "historical_generic_plan_section"
         ? "Current/next items suppressed because this generic plan is mostly historical completed work."
         : "Current/next items suppressed because the plan file is large.";
+    if (actionableText) {
+      const limitText = workPlan.truncated
+        ? "Full current/next scan suppressed because the plan file is large."
+        : suppressionText;
+      return `Workspace plan: ${open} open / ${completed} done in ${sourceWindowText}${sourceReasonText}. Recent open: ${actionableText}. ${limitText}`;
+    }
     return `Workspace plan: ${open} open / ${completed} done in ${sourceWindowText}${sourceReasonText}. ${suppressionText}`;
   }
   const currentSection = normalizeString(workPlan.currentSection);
@@ -880,14 +924,7 @@ function buildWorkPlanText(workPlan = emptyWorkPlanSummary()) {
   const recentOpen = Array.isArray(workPlan.recentOpen) ? workPlan.recentOpen : [];
   const nextText =
     recentOpen.length > 0
-      ? ` Next: ${recentOpen
-          .map((item) => {
-            const section = normalizeString(item.section);
-            const task = normalizeString(item.task);
-            return section ? `${section} - ${task}` : task;
-          })
-          .filter(Boolean)
-          .join("; ")}.`
+      ? ` Next: ${formatWorkPlanOpenItems(recentOpen)}.`
       : "";
   const truncatedText = workPlan.truncated ? " Recent window only." : "";
   return `Workspace plan: ${open} open / ${completed} done in ${sourceText}${sourceReasonText}.${currentText}${nextText}${truncatedText}`;