superlocalmemory 3.8.9 → 3.8.11

package/src/superlocalmemory/optimize/proxy/capture.py

@@ -74,7 +74,7 @@ def _windows_owner_dacl(
     win32api: Any,
     win32con: Any,
     win32security: Any,
-) -> Any:
+) -> tuple[Any, Any]:
     """Build one protected owner-only DACL for a Windows capture file."""
     import ntsecuritycon
 
@@ -95,7 +95,53 @@ def _windows_owner_dacl(
         ntsecuritycon.FILE_ALL_ACCESS,
         owner_sid,
     )
-    return dacl
+    return owner_sid, dacl
+
+
+def _windows_dacl_is_owner_only(
+    security_descriptor: Any,
+    owner_sid: Any,
+    ntsecuritycon: Any,
+    win32security: Any,
+) -> bool:
+    """Return whether a live descriptor already matches the capture policy."""
+    def _same_sid(left: Any, right: Any) -> bool:
+        try:
+            return (
+                win32security.ConvertSidToStringSid(left)
+                == win32security.ConvertSidToStringSid(right)
+            )
+        except Exception:
+            return False
+
+    control, _revision = security_descriptor.GetSecurityDescriptorControl()
+    if not control & win32security.SE_DACL_PROTECTED:
+        return False
+
+    descriptor_owner = security_descriptor.GetSecurityDescriptorOwner()
+    if descriptor_owner is None or not _same_sid(
+        descriptor_owner,
+        owner_sid,
+    ):
+        return False
+
+    dacl = security_descriptor.GetSecurityDescriptorDacl()
+    if dacl is None or dacl.GetAceCount() != 1:
+        return False
+
+    ace = dacl.GetAce(0)
+    if not isinstance(ace, tuple) or len(ace) != 3:
+        return False
+    ace_header, access_mask, ace_sid = ace
+    if (
+        not isinstance(ace_header, tuple)
+        or not ace_header
+        or ace_header[0] != win32security.ACCESS_ALLOWED_ACE_TYPE
+    ):
+        return False
+    if access_mask & ntsecuritycon.FILE_ALL_ACCESS != ntsecuritycon.FILE_ALL_ACCESS:
+        return False
+    return _same_sid(ace_sid, owner_sid)
 
 
 def _open_windows_capture_append(path: Path) -> int:
@@ -117,7 +163,11 @@ def _open_windows_capture_append(path: Path) -> int:
         # ever inheriting a broader parent DACL. For an existing file Windows
         # ignores this descriptor; _enforce_owner_only_permissions replaces
         # that DACL through the same WRITE_DAC-capable handle before writing.
-        dacl = _windows_owner_dacl(win32api, win32con, win32security)
+        owner_sid, dacl = _windows_owner_dacl(
+            win32api,
+            win32con,
+            win32security,
+        )
         security_attributes = win32security.SECURITY_ATTRIBUTES()
         security_attributes.bInheritHandle = False
         security_attributes.SECURITY_DESCRIPTOR.SetSecurityDescriptorDacl(
@@ -129,21 +179,57 @@ def _open_windows_capture_append(path: Path) -> int:
             win32security.SE_DACL_PROTECTED,
             win32security.SE_DACL_PROTECTED,
         )
-        handle = win32file.CreateFile(
-            os.fspath(path),
-            ntsecuritycon.FILE_APPEND_DATA | ntsecuritycon.WRITE_DAC,
+        desired_access = (
+            ntsecuritycon.FILE_APPEND_DATA
+            | ntsecuritycon.WRITE_DAC
+            | ntsecuritycon.READ_CONTROL
+        )
+        share_mode = (
             win32con.FILE_SHARE_READ
             | win32con.FILE_SHARE_WRITE
-            | win32con.FILE_SHARE_DELETE,
-            security_attributes,
-            win32con.OPEN_ALWAYS,
+            | win32con.FILE_SHARE_DELETE
+        )
+        file_flags = (
             win32con.FILE_ATTRIBUTE_NORMAL
             # pywin32 does not export this SDK constant from win32con on
             # every supported Python build. Keep the Microsoft-defined value
             # as a named fallback rather than silently following a reparse.
-            | getattr(win32con, "FILE_FLAG_OPEN_REPARSE_POINT", 0x00200000),
-            None,
+            | getattr(win32con, "FILE_FLAG_OPEN_REPARSE_POINT", 0x00200000)
         )
+        try:
+            # CREATE_NEW is the only race-safe proof that the protected
+            # SECURITY_ATTRIBUTES were applied to this exact file.  OPEN_ALWAYS
+            # would require trusting GetLastError after the pywin32 wrapper has
+            # returned, which is not a documented preservation boundary.
+            handle = win32file.CreateFile(
+                os.fspath(path),
+                desired_access,
+                share_mode,
+                security_attributes,
+                getattr(win32con, "CREATE_NEW", 1),
+                file_flags,
+                None,
+            )
+            created_new = True
+        except Exception as exc:
+            winerror = getattr(exc, "winerror", None)
+            if winerror is None and exc.args:
+                winerror = exc.args[0]
+            if winerror != getattr(win32con, "ERROR_FILE_EXISTS", 80):
+                raise
+            # The creation descriptor is ignored for existing files. Reopen
+            # the exact path without following a reparse point, then replace
+            # its DACL through this WRITE_DAC-capable handle before appending.
+            handle = win32file.CreateFile(
+                os.fspath(path),
+                desired_access,
+                share_mode,
+                None,
+                getattr(win32con, "OPEN_EXISTING", 3),
+                file_flags,
+                None,
+            )
+            created_new = False
         file_info = win32file.GetFileInformationByHandle(handle)
         if file_info[0] & win32con.FILE_ATTRIBUTE_REPARSE_POINT:
             raise OSError(
@@ -151,25 +237,57 @@ def _open_windows_capture_append(path: Path) -> int:
                 "capture path is a Windows reparse point",
                 path,
             )
-        try:
-            # Enforce the DACL while this is still the original CreateFile
-            # handle carrying WRITE_DAC. Transferring it into Python's CRT
-            # first can lose the authority SetSecurityInfo needs on Windows.
-            win32security.SetSecurityInfo(
-                handle,
-                win32security.SE_FILE_OBJECT,
-                win32security.DACL_SECURITY_INFORMATION
-                | win32security.PROTECTED_DACL_SECURITY_INFORMATION,
-                None,
-                None,
-                dacl,
-                None,
-            )
-        except Exception as exc:
-            raise OSError(
-                "Windows capture ACL could not be enforced "
-                f"({type(exc).__name__}: {exc})"
-            ) from exc
+        if not created_new:
+            try:
+                query_flags = (
+                    win32security.OWNER_SECURITY_INFORMATION
+                    | win32security.DACL_SECURITY_INFORMATION
+                )
+                descriptor = win32security.GetSecurityInfo(
+                    handle,
+                    win32security.SE_FILE_OBJECT,
+                    query_flags,
+                )
+                if not _windows_dacl_is_owner_only(
+                    descriptor,
+                    owner_sid,
+                    ntsecuritycon,
+                    win32security,
+                ):
+                    # Existing files ignore the creation security descriptor,
+                    # so repair an unsafe DACL while this is still the original
+                    # CreateFile handle carrying WRITE_DAC. Avoid rewriting an
+                    # already-protected DACL: Windows may correctly deny that
+                    # redundant mutation even though append access is allowed.
+                    win32security.SetSecurityInfo(
+                        handle,
+                        win32security.SE_FILE_OBJECT,
+                        win32security.DACL_SECURITY_INFORMATION
+                        | win32security.PROTECTED_DACL_SECURITY_INFORMATION,
+                        None,
+                        None,
+                        dacl,
+                        None,
+                    )
+                    descriptor = win32security.GetSecurityInfo(
+                        handle,
+                        win32security.SE_FILE_OBJECT,
+                        query_flags,
+                    )
+                    if not _windows_dacl_is_owner_only(
+                        descriptor,
+                        owner_sid,
+                        ntsecuritycon,
+                        win32security,
+                    ):
+                        raise OSError(
+                            "Windows capture ACL verification failed after repair"
+                        )
+            except Exception as exc:
+                raise OSError(
+                    "Windows capture ACL could not be enforced "
+                    f"({type(exc).__name__}: {exc})"
+                ) from exc
 
         # Transfer the native handle to Python's CRT descriptor exactly once.
         raw_handle = handle.Detach()

package/src/superlocalmemory/optimize/storage/db.py

@@ -212,8 +212,12 @@ class CacheDB:
             try:
                 import sqlite3 as _sq
                 test_conn = _sq.connect(str(self._db_path))
-                test_conn.execute("PRAGMA schema_version")
-                test_conn.close()
+                try:
+                    test_conn.execute("PRAGMA schema_version")
+                finally:
+                    # Windows will not rename an open SQLite file. Always
+                    # release the probe before corrupt-file recovery runs.
+                    test_conn.close()
             except Exception as exc:
                 corrupt_sidecar = self._db_path.with_suffix(
                     self._db_path.suffix + ".corrupt"

package/src/superlocalmemory/retrieval/reranker.py

@@ -84,6 +84,21 @@ _WARMUP_MAX_ATTEMPTS = int(os.environ.get("SLM_RERANKER_WARMUP_ATTEMPTS", "5"))
 _WARMUP_RETRY_BACKOFF_S = float(os.environ.get("SLM_RERANKER_WARMUP_BACKOFF", "3"))
 
 
+# Substrings that mark a load failure as a configuration problem rather than a
+# transient one. Retrying these can never succeed, so the warmup aborts on the
+# first occurrence instead of spending _WARMUP_MAX_ATTEMPTS × backoff on them.
+_PERMANENT_LOAD_ERROR_MARKERS = (
+    "unknown backend",
+    "sentence-transformers is not installed",
+)
+
+
+def _is_permanent_load_error(error: str) -> bool:
+    """True when a worker load error cannot be fixed by retrying."""
+    lowered = (error or "").lower()
+    return any(m in lowered for m in _PERMANENT_LOAD_ERROR_MARKERS)
+
+
 class CrossEncoderReranker:
     """Rerank candidate facts using a local cross-encoder model.
 
@@ -201,11 +216,43 @@ class CrossEncoderReranker:
                                 resp.get("warmup_inference", False),
                             )
                             return
-                        logger.warning(
-                            "Reranker warmup attempt %d/%d did not confirm "
-                            "ready (timeout=%ds); retrying",
-                            attempt, _WARMUP_MAX_ATTEMPTS, _WARMUP_LOAD_TIMEOUT,
-                        )
+                        # v3.8.11 (issue #103): this used to report
+                        # "(timeout=90s)" for EVERY failure, including loads
+                        # that failed instantly. A user whose retries were 3s
+                        # apart was told each one timed out after 90s, and the
+                        # worker's actual error was never printed at all.
+                        # Distinguish the two cases and surface the real cause.
+                        if resp is None:
+                            logger.warning(
+                                "Reranker warmup attempt %d/%d: no response "
+                                "from worker within %ds; retrying",
+                                attempt, _WARMUP_MAX_ATTEMPTS,
+                                _WARMUP_LOAD_TIMEOUT,
+                            )
+                        else:
+                            load_error = (
+                                resp.get("error")
+                                or "worker reported not-ready without an error"
+                            )
+                            # A misconfiguration cannot fix itself. Retrying a
+                            # bad backend name or a missing dependency four
+                            # more times burns ~7.5 minutes of daemon startup
+                            # to reach the same answer (issue #103). Fail fast
+                            # and say exactly what to change.
+                            if _is_permanent_load_error(load_error):
+                                logger.error(
+                                    "Reranker disabled — configuration error: "
+                                    "%s. Not retrying. Fix the config or set "
+                                    "retrieval.use_cross_encoder=false; recall "
+                                    "continues with fusion scores.",
+                                    load_error,
+                                )
+                                return
+                            logger.warning(
+                                "Reranker warmup attempt %d/%d failed: %s; "
+                                "retrying",
+                                attempt, _WARMUP_MAX_ATTEMPTS, load_error,
+                            )
 
                     if attempt < _WARMUP_MAX_ATTEMPTS and not self._model_loaded:
                         if self._shutdown_event.wait(

package/src/superlocalmemory/server/unified_daemon.py

@@ -534,6 +534,10 @@ def _recall_keyword_fallback(engine, query: str, limit: int) -> dict:
         "results": results,
         "count": len(results),
         "no_confident_match": True,
+        # PR #101: every other recall path returns this key, so clients format
+        # it unconditionally. Omitting it here made the degraded path — the one
+        # that fires when recall is ALREADY struggling — crash the CLI.
+        "retrieval_time_ms": 0,
     }
 
 # v3.4.52: Embedding model warm state. Set to True by the async pre-warm
@@ -1244,6 +1248,7 @@ async def lifespan(application: FastAPI):
     engine = None
     config = None
     canonical_remember_runtime = None
+    profile_runtime = None
 
     # The local dashboard obtains its short-lived browser credential from
     # ``/internal/token`` before its first write or token-gated read.  A
@@ -1916,11 +1921,17 @@ async def lifespan(application: FastAPI):
 
     except Exception:
         logger.exception("Engine init failed")  # auto-includes traceback
-        _release_canonical_remember_runtime(
+        writer_released = _release_canonical_remember_runtime(
             application, canonical_remember_runtime,
         )
         application.state.engine = None
         application.state.config = None
+        if engine is not None and writer_released:
+            try:
+                engine.close()
+            except Exception:
+                logger.debug("partially initialized engine cleanup failed", exc_info=True)
+        raise
 
     application.state.observe_buffer = _observe_buffer
 

package/src/superlocalmemory/storage/admission_codec.py

@@ -74,6 +74,16 @@ def _load_or_create_key(path: Path) -> bytes:
         )
     except FileExistsError:
         fd = -1
+    except OSError as exc:
+        try:
+            info = path.lstat()
+        except OSError:
+            raise AdmissionKeyError("admission key cannot be created") from exc
+        if stat.S_ISLNK(info.st_mode) or not stat.S_ISREG(info.st_mode):
+            raise AdmissionKeyError(
+                "admission key path must be a regular file"
+            ) from exc
+        raise AdmissionKeyError("admission key cannot be created") from exc
     else:
         try:
             key = os.urandom(_KEY_BYTES)