prism-mcp-server 20.21.26 → 20.21.27

package/README.md

@@ -170,6 +170,26 @@ or by re-enabling after each run.
 <details>
 <summary>Release history (optional)</summary>
 
+## What's New in v20.21.27
+
+**Why it matters:** a script that feeds Prism Browser through a pipe can
+now pause between blocks of commands. Before, commands that had already
+arrived waited for the next write, and never ran if the 600 s idle timeout
+came first, so a script that checked a result before sending more stalled
+and then failed.
+
+- **Every piped command runs when it arrives.** The reader waited on
+  `select()` for new pipe data while `readline()` had already buffered the
+  commands sent so far. It now reads the descriptor itself and decodes it as
+  the text stream did (its encoding, universal newlines). Measured with two
+  commands written together and a third written only after the reader hands
+  over the second: the second came out only with the third before, and
+  before the third is written now.
+- **Unchanged:** the idle timeout, `\` line continuation (CRLF endings
+  included), comment lines, and streams `select()` cannot watch, now read
+  blocking. At the idle timeout, a command still being written is dropped,
+  never run cut short.
+
 ## What's New in v20.21.26
 
 **Why it matters:** routine wording no longer lets a mixed request skip

package/dist/utils/safetyGate.js

@@ -31,7 +31,13 @@ const CRISIS_INPUT_RE = [
     // Swift copy); the generator's other patterns drift from this file —
     // reported; apply single lines, and keep the portal copy in step.
     /(?:(?<!\b(?:a|an|the|this|that|good|great|solid|useful|our|your|my|as)\s{1,4})\bjump(?:ing)?[\s-]+off\b|\bjump(?:ing)?[\s-]+off\b(?![\s-]+points?\b))/i,
-    /how\s+(?:many|much|to).*(?:pills|overdose|die)/i,
+    // "die", "dies", "died" and "dieing" as whole words: "how much is a diet
+    // coke" and "how to get a hoodie" matched (2026-10-15). Only the "it is to
+    // die for" idiom (ending its clause, or before and/but/so/too) and
+    // "to-die-for" are exempt; "how to die for the insurance" still matches.
+    // "starve myself to death" is named because "diet" no longer stands in for
+    // it. Same pattern as the portal copy.
+    /how\s+(?:many|much|to).*(?:pills|overdose|starv\w*\s+(?:my)?self\s+to\s+death|(?<!\b(?:is|are|was|were|s|re)\s{1,3}to\s{1,3})(?<!\bto-)\bdie(?:[sd]|ing)?\b|\bdie(?:[sd]|ing)?\b(?!\s+for(?:\s*[.!?,;:—–-]|\s*$|\s+(?:and|but|so|too)\b)|-for\b))/i,
     // Spanish — block hyperbole nouns only (NOT hunger/thirst/cold — may be literal for neglected child)
     /quiero\s+morir(?!\s+de\s+(?:risa|la\s+risa|vergüenza|ganas|envidia|aburrimiento)\b)/i,
     /(?:voy\s+a\s+)?matarme(?!\s+(?:estudiando|trabajando|riendo|de\s+(?:risa|la\s+risa))\b)/i,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "20.21.26",
+  "version": "20.21.27",
   "mcpName": "io.github.dcostenco/prism-coder",
   "description": "Persistent session memory for AI coding agents that never leaves your machine — including the on-device model that reasons over it. Restores your prior decisions, open TODOs, and changed files across sessions; adds associative recall of related past work, semantic drift detection, and local inference. Local-first by default. Works with Claude Code, Cursor, and Codex.",
   "module": "index.ts",

package/scripts/dev/browse.py

@@ -42,8 +42,10 @@ MODES:
 """
 
 import argparse
+import codecs
 import datetime
 import hashlib
+import io
 import json
 import os
 import random
@@ -2198,10 +2200,17 @@ def run_repl(session, sanitize=False, cleanup=False, fail_fast=False):
 # ---------------------------------------------------------------------------
 # Pipe/batch mode
 # ---------------------------------------------------------------------------
+class _PipeIdleTimeout(Exception):
+    """The producer held the pipe open past the idle timeout."""
+
+
 def _stdin_lines_with_idle_timeout(timeout_sec):
     """
     Yield stdin lines, giving up if the producer holds the pipe open without
-    sending anything. Falls back to plain iteration for non-selectable streams.
+    sending anything. Iterates the stream itself when it has no descriptor,
+    and reads blocking when select() cannot watch the descriptor. Raises
+    _PipeIdleTimeout at the timeout, so a command still being written is
+    dropped rather than run cut short.
     """
     stream = sys.stdin
     try:
@@ -2209,31 +2218,73 @@ def _stdin_lines_with_idle_timeout(timeout_sec):
     except Exception:
         yield from stream
         return
+    # Read the descriptor directly and split lines here. stream.readline()
+    # pulled a whole chunk into Python's own buffer and returned one line; the
+    # rest sat there while select() watched the empty pipe, so commands that
+    # had already arrived waited for the producer's next write, or for this
+    # timeout. A producer that pauses between blocks (waiting on a result the
+    # held-back commands would produce) deadlocked until then (2026-10-16).
+    #
+    # Decode as the text stream did: one incremental decoder for the whole
+    # stream, in its encoding and error policy, with universal newlines. A
+    # character split across two reads stays whole, and CRLF and a bare CR
+    # both end a line, so a backslash continuation written from Windows
+    # still joins.
+    decoder = io.IncrementalNewlineDecoder(
+        codecs.getincrementaldecoder(getattr(stream, "encoding", None) or "utf-8")(
+            getattr(stream, "errors", None) or "strict"),
+        translate=True,
+    )
+    pending = ""
+    selectable = True
     while True:
-        try:
-            ready, _, _ = select.select([fileno], [], [], timeout_sec)
-        except Exception:
-            yield from stream
-            return
-        if not ready:
-            audit_log("pipe_idle_timeout", "", f"timeout={timeout_sec}s")
-            print(json.dumps({
-                "status": "error",
-                "action": "pipe",
-                "message": f"No input for {timeout_sec}s. Closing browser to prevent zombie process.",
-            }))
-            sys.stdout.flush()
-            return
-        line = stream.readline()
-        if not line:
+        newline = pending.find("\n")
+        if newline >= 0:
+            line, pending = pending[:newline + 1], pending[newline + 1:]
+            yield line
+            continue
+        if selectable:
+            try:
+                ready, _, _ = select.select([fileno], [], [], timeout_sec)
+            except Exception:
+                # A descriptor select() cannot watch (a Windows pipe): read it
+                # blocking from here on, keeping any partial line already read.
+                selectable = False
+                ready = True
+            if not ready:
+                audit_log("pipe_idle_timeout", "", f"timeout={timeout_sec}s")
+                print(json.dumps({
+                    "status": "error",
+                    "action": "pipe",
+                    "message": f"No input for {timeout_sec}s. Closing browser to prevent zombie process.",
+                }))
+                sys.stdout.flush()
+                raise _PipeIdleTimeout()
+        chunk = os.read(fileno, 65536)
+        if not chunk:
+            pending += decoder.decode(b"", final=True)
+            if pending:
+                yield pending
             return
-        yield line
+        pending += decoder.decode(chunk)
+
+
+def _pipe_commands(timeout_sec):
+    """
+    The pipe's commands, continuations joined. At the idle timeout the reader
+    raises before the joiner can flush, so a continued command whose tail never
+    came is dropped, not run as its head alone.
+    """
+    try:
+        yield from _join_continuations(_stdin_lines_with_idle_timeout(timeout_sec))
+    except _PipeIdleTimeout:
+        return
 
 
 def run_pipe(session, sanitize=False, cleanup=False, fail_fast=False, cleanup_files=None):
     """Read commands from stdin, one per line. Returns True when all succeeded."""
     had_error = False
-    for line in _join_continuations(_stdin_lines_with_idle_timeout(PIPE_IDLE_TIMEOUT)):
+    for line in _pipe_commands(PIPE_IDLE_TIMEOUT):
         line = line.strip()
         if not line or line.startswith('#'):
             continue