@aliou/pi-processes 0.9.4 → 0.10.0

package/extensions/processes/notifications/log-matchers.ts

@@ -0,0 +1,146 @@
+import { compileLineMatcher } from "../../../src/utils/match-line";
+import type { NotifyConfig } from "./registry";
+import type { Attention } from "./types";
+
+export interface CompiledLogMatcher {
+  pattern: string;
+  mode: "literal" | "regex";
+  stream: "stdout" | "stderr" | "both";
+  repeat: boolean;
+  on: Attention;
+  lineMatcher: ((line: string) => boolean) | null;
+  matcherIndex: number;
+  fired: boolean;
+  lastMatchTime: number;
+}
+
+export const MAX_LOG_MATCHERS_PER_PROCESS = 20;
+export const MAX_LOG_MATCH_PATTERN_LENGTH = 500;
+const MAX_LINE_LENGTH = 10_000;
+const LOG_MATCH_COOLDOWN_MS = 15_000;
+
+export function compileLogMatchers(config: NotifyConfig): CompiledLogMatcher[] {
+  const raw = config.logMatches;
+  if (!raw || raw.length === 0) return [];
+
+  const matchers: CompiledLogMatcher[] = [];
+
+  for (let i = 0; i < Math.min(raw.length, MAX_LOG_MATCHERS_PER_PROCESS); i++) {
+    const entry = raw[i];
+
+    if (entry.pattern.length > MAX_LOG_MATCH_PATTERN_LENGTH) {
+      continue;
+    }
+
+    const mode = entry.mode ?? "literal";
+    const stream = entry.stream ?? "both";
+    const repeat = entry.repeat ?? false;
+    const on = entry.on ?? "turn";
+
+    let lineMatcher: ((line: string) => boolean) | null = null;
+
+    if (mode === "regex") {
+      try {
+        lineMatcher = compileLineMatcher(entry.pattern, mode);
+      } catch (_error) {
+        void _error; // Invalid regex: skip this matcher
+        continue;
+      }
+    } else {
+      lineMatcher = compileLineMatcher(entry.pattern, mode);
+    }
+
+    matchers.push({
+      pattern: entry.pattern,
+      mode,
+      stream,
+      repeat,
+      on,
+      lineMatcher,
+      matcherIndex: i,
+      fired: false,
+      lastMatchTime: 0,
+    });
+  }
+
+  return matchers;
+}
+
+export interface LogMatchResult {
+  matcherIndex: number;
+  pattern: string;
+  mode: "literal" | "regex";
+  stream: "stdout" | "stderr";
+  line: string;
+  on: Attention;
+}
+
+export function evaluateLogMatchers(
+  matchers: CompiledLogMatcher[],
+  appendedText: Array<{ type: "stdout" | "stderr"; text: string }>,
+  now: number,
+): LogMatchResult[] {
+  const results: LogMatchResult[] = [];
+
+  const lines = splitAppendedIntoLines(appendedText);
+
+  for (const matcher of matchers) {
+    if (!matcher.repeat && matcher.fired) continue;
+
+    if (
+      matcher.repeat &&
+      matcher.fired &&
+      now - matcher.lastMatchTime < LOG_MATCH_COOLDOWN_MS
+    ) {
+      continue;
+    }
+
+    for (const line of lines) {
+      if (!streamMatches(matcher.stream, line.type)) continue;
+      if (line.text.length > MAX_LINE_LENGTH) continue;
+
+      const matched = matcher.lineMatcher?.(line.text);
+
+      if (matched) {
+        matcher.fired = true;
+        matcher.lastMatchTime = now;
+
+        results.push({
+          matcherIndex: matcher.matcherIndex,
+          pattern: matcher.pattern,
+          mode: matcher.mode,
+          stream: line.type,
+          line: line.text,
+          on: matcher.on,
+        });
+
+        break;
+      }
+    }
+  }
+
+  return results;
+}
+
+function splitAppendedIntoLines(
+  appended: Array<{ type: "stdout" | "stderr"; text: string }>,
+): Array<{ type: "stdout" | "stderr"; text: string }> {
+  const lines: Array<{ type: "stdout" | "stderr"; text: string }> = [];
+
+  for (const entry of appended) {
+    const split = entry.text.split("\n");
+    for (const line of split) {
+      if (line.length === 0) continue;
+      lines.push({ type: entry.type, text: line });
+    }
+  }
+
+  return lines;
+}
+
+function streamMatches(
+  matcherStream: "stdout" | "stderr" | "both",
+  lineStream: "stdout" | "stderr",
+): boolean {
+  return matcherStream === "both" || matcherStream === lineStream;
+}

package/extensions/processes/notifications/registry.ts

@@ -0,0 +1,225 @@
+import { MAX_LOG_MATCHERS_PER_PROCESS } from "./log-matchers";
+import type { Attention } from "./types";
+
+export interface LogMatcherConfig {
+  pattern: string;
+  mode?: "literal" | "regex";
+  stream?: "stdout" | "stderr" | "both";
+  repeat?: boolean;
+  on?: Attention;
+}
+
+export interface NotifyConfig {
+  onSuccess?: Attention;
+  onFailure?: Attention;
+  onKilled?: Attention;
+  logMatches?: LogMatcherConfig[];
+}
+
+export interface WatchMeta {
+  revision: number;
+  generation: number;
+}
+
+export interface WatchState {
+  logMatches: LogMatcherConfig[];
+  revision: number;
+  generation: number;
+}
+
+export interface WatchRemoveSpec {
+  index?: number;
+  pattern?: string;
+  mode?: "literal" | "regex";
+  stream?: "stdout" | "stderr" | "both";
+  repeat?: boolean;
+  on?: Attention;
+}
+
+export interface WatchUpdateResult {
+  logMatches: LogMatcherConfig[];
+  revision: number;
+  generation: number;
+}
+
+export interface NotificationRegistry {
+  register(processId: string, config: NotifyConfig): void;
+  unregister(processId: string): void;
+  get(processId: string): NotifyConfig | null;
+  markIntentionalStop(processId: string): void;
+  consumeIntentionalStop(processId: string): boolean;
+  clear(): void;
+  appendWatches(
+    processId: string,
+    items: LogMatcherConfig[],
+  ): WatchUpdateResult | null;
+  replaceWatches(
+    processId: string,
+    items: LogMatcherConfig[],
+  ): WatchUpdateResult | null;
+  removeWatches(
+    processId: string,
+    specs: WatchRemoveSpec[],
+  ): WatchUpdateResult | null;
+  clearWatches(processId: string): WatchUpdateResult | null;
+  getWatchState(processId: string): WatchState | null;
+}
+
+export function createNotificationRegistry(): NotificationRegistry {
+  const configs = new Map<string, NotifyConfig>();
+  const intentionalStops = new Set<string>();
+  const watchMeta = new Map<string, WatchMeta>();
+
+  function currentMatches(processId: string): LogMatcherConfig[] {
+    const config = configs.get(processId);
+    return config?.logMatches?.map((m) => ({ ...m })) ?? [];
+  }
+
+  function setMatches(processId: string, matches: LogMatcherConfig[]): void {
+    const config = configs.get(processId);
+    if (config) {
+      config.logMatches = matches;
+    }
+  }
+
+  function bumpRevision(processId: string, bumpGeneration: boolean): WatchMeta {
+    const meta = watchMeta.get(processId) ?? { revision: 0, generation: 0 };
+    meta.revision++;
+    if (bumpGeneration) {
+      meta.generation++;
+    }
+    watchMeta.set(processId, meta);
+    return meta;
+  }
+
+  return {
+    register(processId: string, config: NotifyConfig): void {
+      configs.set(processId, config);
+      watchMeta.set(processId, { revision: 0, generation: 0 });
+    },
+
+    unregister(processId: string): void {
+      configs.delete(processId);
+      intentionalStops.delete(processId);
+      watchMeta.delete(processId);
+    },
+
+    get(processId: string): NotifyConfig | null {
+      return configs.get(processId) ?? null;
+    },
+
+    markIntentionalStop(processId: string): void {
+      intentionalStops.add(processId);
+    },
+
+    consumeIntentionalStop(processId: string): boolean {
+      return intentionalStops.delete(processId);
+    },
+
+    clear(): void {
+      configs.clear();
+      intentionalStops.clear();
+      watchMeta.clear();
+    },
+
+    appendWatches(
+      processId: string,
+      items: LogMatcherConfig[],
+    ): WatchUpdateResult | null {
+      if (!configs.has(processId)) return null;
+      const existing = currentMatches(processId);
+      const merged = [...existing, ...items];
+      if (merged.length > MAX_LOG_MATCHERS_PER_PROCESS) {
+        throw new Error(
+          `process update watches would exceed maximum of ${MAX_LOG_MATCHERS_PER_PROCESS} matchers`,
+        );
+      }
+      setMatches(processId, merged);
+      const meta = bumpRevision(processId, false);
+      return {
+        logMatches: merged,
+        revision: meta.revision,
+        generation: meta.generation,
+      };
+    },
+
+    replaceWatches(
+      processId: string,
+      items: LogMatcherConfig[],
+    ): WatchUpdateResult | null {
+      if (!configs.has(processId)) return null;
+      if (items.length > MAX_LOG_MATCHERS_PER_PROCESS) {
+        throw new Error(
+          `process update watches would exceed maximum of ${MAX_LOG_MATCHERS_PER_PROCESS} matchers`,
+        );
+      }
+      setMatches(processId, [...items]);
+      const meta = bumpRevision(processId, true);
+      return {
+        logMatches: [...items],
+        revision: meta.revision,
+        generation: meta.generation,
+      };
+    },
+
+    removeWatches(
+      processId: string,
+      specs: WatchRemoveSpec[],
+    ): WatchUpdateResult | null {
+      if (!configs.has(processId)) return null;
+      const existing = currentMatches(processId);
+      const filtered = existing.filter(
+        (matcher, index) => !matchesRemoveSpec(matcher, index, specs),
+      );
+      setMatches(processId, filtered);
+      const meta = bumpRevision(processId, false);
+      return {
+        logMatches: filtered,
+        revision: meta.revision,
+        generation: meta.generation,
+      };
+    },
+
+    clearWatches(processId: string): WatchUpdateResult | null {
+      if (!configs.has(processId)) return null;
+      setMatches(processId, []);
+      const meta = bumpRevision(processId, true);
+      return {
+        logMatches: [],
+        revision: meta.revision,
+        generation: meta.generation,
+      };
+    },
+
+    getWatchState(processId: string): WatchState | null {
+      if (!configs.has(processId)) return null;
+      const meta = watchMeta.get(processId) ?? { revision: 0, generation: 0 };
+      return {
+        logMatches: currentMatches(processId),
+        revision: meta.revision,
+        generation: meta.generation,
+      };
+    },
+  };
+}
+
+function matchesRemoveSpec(
+  matcher: LogMatcherConfig,
+  index: number,
+  specs: WatchRemoveSpec[],
+): boolean {
+  return specs.some((spec) => {
+    if (spec.index !== undefined) return spec.index === index;
+    if (!spec.pattern) return false;
+    if (matcher.pattern !== spec.pattern) return false;
+    if (spec.mode !== undefined && (matcher.mode ?? "literal") !== spec.mode)
+      return false;
+    if (spec.stream !== undefined && (matcher.stream ?? "both") !== spec.stream)
+      return false;
+    if (spec.repeat !== undefined && (matcher.repeat ?? false) !== spec.repeat)
+      return false;
+    if (spec.on !== undefined && (matcher.on ?? "turn") !== spec.on)
+      return false;
+    return true;
+  });
+}

package/extensions/processes/notifications/render-content.ts

@@ -0,0 +1,122 @@
+import type { ProcessNotificationDetails } from "./types";
+
+export function buildProcessNotificationContent(
+  details: ProcessNotificationDetails,
+): string {
+  if (details.kind === "log_match" && details.logMatch) {
+    return buildLogMatchContent(details);
+  }
+  if (details.kind === "log_match_suppressed") {
+    return buildSuppressedContent(details);
+  }
+
+  return buildLifecycleContent(details);
+}
+
+function buildSuppressedContent(details: ProcessNotificationDetails): string {
+  return [
+    '<process_event type="notification_summary" kind="log_match_suppressed">',
+    element("summary", details.summary, 1),
+    "</process_event>",
+  ].join("\n");
+}
+
+function buildLifecycleContent(details: ProcessNotificationDetails): string {
+  const attrs = [
+    attr("type", "lifecycle"),
+    attr("kind", details.kind),
+    attr("process_id", details.processId),
+    attr("process_name", details.processName),
+    details.status ? attr("status", details.status) : null,
+  ]
+    .filter(Boolean)
+    .join(" ");
+
+  const lines = [
+    `<process_event ${attrs}>`,
+    element("summary", details.summary, 1),
+    element("command", details.command, 1),
+  ];
+
+  if (details.exitCode !== undefined && details.exitCode !== null) {
+    lines.push(element("exit_code", String(details.exitCode), 1));
+  }
+
+  if (details.endReason) {
+    lines.push(element("end_reason", details.endReason, 1));
+  }
+
+  if (details.signal) {
+    const signalAttrs = [
+      attr("name", details.signal.name),
+      details.signal.number === null
+        ? null
+        : attr("number", String(details.signal.number)),
+    ]
+      .filter(Boolean)
+      .join(" ");
+    lines.push(element("signal", details.signal.description, 1, signalAttrs));
+  }
+
+  lines.push(
+    element(
+      "logs_hint",
+      `Use process output/logs for process ${details.processId} to inspect recent output.`,
+      1,
+    ),
+  );
+  lines.push("</process_event>");
+
+  return lines.join("\n");
+}
+
+function buildLogMatchContent(details: ProcessNotificationDetails): string {
+  const logMatch = details.logMatch;
+  if (!logMatch) {
+    return buildLifecycleContent(details);
+  }
+
+  const attrs = [
+    attr("type", "log_match"),
+    attr("kind", details.kind),
+    attr("process_id", details.processId),
+    attr("process_name", details.processName),
+  ].join(" ");
+
+  return [
+    `<process_event ${attrs}>`,
+    element("summary", details.summary, 1),
+    element("pattern", logMatch.pattern, 1, attr("mode", logMatch.mode)),
+    element("stream", logMatch.stream, 1),
+    element("matched_line", logMatch.line, 1),
+    "</process_event>",
+  ].join("\n");
+}
+
+function element(
+  name: string,
+  value: string,
+  indent: number,
+  attrs?: string,
+): string {
+  const padding = "  ".repeat(indent);
+  const attrText = attrs ? ` ${attrs}` : "";
+  return `${padding}<${name}${attrText}>${escapeXmlText(value)}</${name}>`;
+}
+
+function attr(name: string, value: string): string {
+  return `${name}="${escapeXmlAttribute(value)}"`;
+}
+
+export function escapeXmlText(value: string): string {
+  return value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;");
+}
+
+export function escapeXmlAttribute(value: string): string {
+  return escapeXmlText(value)
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;");
+}