fix: safely revert working tree to stable state (e93985a)

Author: 1minds3t

.github/workflows/demo-matrix-test.yml

@@ -293,7 +293,7 @@ jobs:
       if: always()
       run: |
         8pkg daemon stop  || true
-        pkill -f "_work/omnipkg/omnipkg/.venv" || true
+        pkill -f "omnipkg" || true
 
   # ─────────────────────────────────────────────────────────────────────────────
   # 7. PYPI RELEASE GATE

.github/workflows/windows-concurrency-test.yml

@@ -64,13 +64,7 @@ jobs:
       - name: Dump daemon log after demo run 1
         if: always()
         shell: pwsh
-        run: |
-          $logFile = Get-ChildItem -Path "$env:TEMP\omnipkg" -Filter "omnipkg_daemon.log" -Recurse | Select-Object -First 1
-          if ($logFile) {
-              Get-Content $logFile.FullName
-          } else {
-              Write-Error "Could not find daemon log in $env:TEMP\omnipkg"
-          }
+        run: type "$env:TEMP\omnipkg\omnipkg_daemon.log"
 
       - name: Run Demo Again (Verify Caching)
         shell: cmd

src/omnipkg/common_utils.py

@@ -747,26 +747,10 @@ def _worker_read_reply() -> dict:
     The daemon writes to worker.process.stdin (also text mode) after
     receiving the stdin_line from the C dispatcher.
     """
-    import threading
-    result = [None]
-    exc = [None]
-
-    def _read():
-        try:
-            result[0] = sys.stdin.readline()
-        except Exception as e:
-            exc[0] = e
-
-    t = threading.Thread(target=_read, daemon=True)
-    t.start()
-    t.join(5.0)
-    if t.is_alive():
-        raise TimeoutError("no stdin reply within 5s")
-    if exc[0]:
-        raise exc[0]
-    if not result[0]:
+    line = sys.stdin.readline()
+    if not line:
         raise EOFError("daemon closed stdin")
-    return json.loads(result[0].strip())
+    return json.loads(line.strip())
 
 
 def safe_input(prompt: str, default: str = "", auto_value: str = None) -> str:

src/omnipkg/core.py

@@ -2823,13 +2823,6 @@ def _first_time_setup(self, interactive=True) -> Dict:
             safe_print(_("   💡 Future startups will be instant!"))
 
         # Initialize knowledge base
-        rebuild_cmd = [
-            str(final_config["python_executable"]),
-            "-m",
-            "omnipkg.cli",
-            "reset",
-            "-y",
-        ]
         is_windows = platform.system() == "Windows"
         creationflags = subprocess.CREATE_NO_WINDOW if is_windows else 0
         win_env = {**os.environ, "PYTHONIOENCODING": "utf-8", "PYTHONUTF8": "1"}
@@ -4247,9 +4240,6 @@ def _create_bubble_from_editable_install(
         source_path: str,
         python_context_version: str,
     ) -> bool:
-        # --- ADD THIS LINE HERE ---
-        import site as site_module 
-        
         """
         Creates a bubble from an editable install by copying files from the live source.
         This preserves the current dev version WITH ALL DEPENDENCIES as a fallback.
@@ -4488,7 +4478,6 @@ def _try_pip_dry_run(self, package_name: str, version: str) -> Optional[List[str
                     pass
 
     def _try_pypi_api(self, package_name: str, version: str) -> Optional[List[str]]:
-        import requests as http_requests
         try:
             pass
         except ImportError:
@@ -4501,11 +4490,11 @@ def _try_pypi_api(self, package_name: str, version: str) -> Optional[List[str]]:
                 "User-Agent": "omnipkg-package-manager/1.0",
                 "Accept": "application/json",
             }
-            response = http_requests.get(url, timeout=10, headers=headers)
+            response = requests.get(url, timeout=10, headers=headers)
             if response.status_code == 404:
                 if clean_version != version:
                     url = f"https://pypi.org/pypi/{package_name}/{version}/json"
-                    response = http_requests.get(url, timeout=10, headers=headers)
+                    response = requests.get(url, timeout=10, headers=headers)
             if response.status_code != 200:
                 return None
             if not response.text.strip():
@@ -4532,7 +4521,7 @@ def _try_pypi_api(self, package_name: str, version: str) -> Optional[List[str]]:
                     version_spec = match.group(2) or ""
                     dependencies.append(_("{}{}").format(dep_name, version_spec))
             return dependencies
-        except http_requests.exceptions.RequestException:
+        except requests.exceptions.RequestException:
             return None
         except Exception:
             return None
@@ -6825,15 +6814,11 @@ def _check_sync_status_ultra_fast(self, master_version: str) -> List[Tuple[str,
                     if p.name != expected_dist_info and p.name != expected_editable_dist_info
                 ]
 
+                # egg-link = legacy setuptools editable; always needs re-sync to modern format
                 has_egg_link = (site_packages / "omnipkg.egg-link").exists()
                 if has_egg_link:
-                    _marker = Path(exe_path).parent / f".omnipkg_synced_{master_version}"
-                    if _marker.exists():
-                        # Already synced, egg-link is stale but harmless — skip
-                        pass
-                    else:
-                        sync_needed.append((py_ver, str(exe_path)))
-                        continue
+                    sync_needed.append((py_ver, str(exe_path)))
+                    continue
 
                 # If we found an old/conflicting .dist-info directory, sync is ALWAYS needed.
                 # This is non-negotiable and overrides any .pth file check.
@@ -7020,31 +7005,8 @@ def sync_interpreter(py_ver, target_exe):
                 _already_synced = _marker.exists()
                 if _already_synced:
                     # Still need to check uv_ffi even if omnipkg is already synced
-                    if _already_synced:
-                    # Still need to check uv_ffi even if omnipkg is already synced
-                        if os.environ.get("OMNIPKG_DEBUG"):
-                            safe_print(f"   [HEAL] {py_ver} omnipkg marker exists, checking uv_ffi only...")
-                        # Clean up stale egg-link even if already synced (editable installs on old Python)
-                        try:
-                            _ir = Path(target_exe).parent.parent
-                            sp_path = _ir / "Lib" if (_ir / "Lib").exists() else _ir / "lib"
-                            import glob as _glob
-                            _sp_dirs = _glob.glob(str(sp_path / "python*/site-packages")) or _glob.glob(str(sp_path / "site-packages"))
-                            for sp_dir in _sp_dirs:
-                                sp_dir = Path(sp_dir)
-                                egg_link = sp_dir / "omnipkg.egg-link"
-                                if egg_link.exists():
-                                    egg_link.unlink()
-                                easy_pth = sp_dir / "easy-install.pth"
-                                if easy_pth.exists():
-                                    lines = easy_pth.read_text(encoding="utf-8").splitlines()
-                                    cleaned = [l for l in lines if "omnipkg" not in l]
-                                    if cleaned:
-                                        easy_pth.write_text("\n".join(cleaned) + "\n", encoding="utf-8")
-                                    else:
-                                        easy_pth.unlink()
-                        except Exception:
-                            pass
+                    if os.environ.get("OMNIPKG_DEBUG"):
+                        safe_print(f"   [HEAL] {py_ver} omnipkg marker exists, checking uv_ffi only...")
                 # Detect egg-based pip (e.g. pip 20.2.2 on Python 3.7)
                 # and inject it into PYTHONPATH so -m pip works in subprocess
                 import glob, os
@@ -16128,28 +16090,21 @@ def _run_pip_install(
             # ── PATH 1: FFI in-process ─────────────────────────────────
             if self._uv_ffi_run is not None:
                 daemon_client = None
-                _ffi_installed, _ffi_removed = [], []
-                _op_marker = None
-                # ✅ HOISTED: Define before the try so `finally` can always reference it safely
-                _is_target_call = "--target" in _uv_args
-                _target_val = _uv_args[_uv_args.index("--target") + 1] if _is_target_call else None
-
-                # Signal the START of our operation (Marker File + IPC)
-                # 🔥 BUBBLE FIX: Only signal the daemon if we're touching the MAIN env.
-                #    A bubble install goes to a temp --target dir; the watcher isn't
-                #    watching that dir, so lying to it causes spurious invalidations.
-                if not _is_target_call:
-                    try:
-                        _sp_path = Path(self.config.get("site_packages_path"))
-                        _op_marker = _sp_path / ".omnipkg_op.lock"
-                        _op_marker.touch()
+                _ffi_installed, _ffi_removed = [], []  # Initialize for finally block
+                _op_marker = None                      # Initialize for finally block
 
-                        from omnipkg.isolation.worker_daemon import DaemonClient
-                        daemon_client = DaemonClient(auto_start=False)
-                        daemon_client.start_omnipkg_op()
-                    except Exception as e:
-                        _dbg(f"[FS-WATCHER-CLIENT] Failed to signal start_op: {e}")
-                        daemon_client = None
+                # 1. Signal the START of our operation (Marker File + IPC)
+                try:
+                    _sp_path = Path(self.config.get("site_packages_path"))
+                    _op_marker = _sp_path / ".omnipkg_op.lock"
+                    _op_marker.touch()
+                    
+                    from omnipkg.isolation.worker_daemon import DaemonClient
+                    daemon_client = DaemonClient(auto_start=False)
+                    daemon_client.start_omnipkg_op()
+                except Exception as e:
+                    _dbg(f"[FS-WATCHER-CLIENT] Failed to signal start_op: {e}")
+                    daemon_client = None
 
                 try:
                     from omnipkg.isolation.fs_watcher import FfiWriteGuard
@@ -16202,26 +16157,22 @@ def _run_pip_install(
                         safe_print(f"[UV-PATH] FFI error ({_ffi_ex}) after {_ffi_ms:.2f}ms — trying daemon", file=sys.stderr)
 
                 finally:
-                    # 🔥 BUBBLE FIX: Only tell the daemon if we actually touched the MAIN env.
-                    #    If _is_target_call, this was a bubble — daemon knows nothing about it,
-                    #    and we don't want it to think the main site-packages changed.
-                    if not _is_target_call and daemon_client:
-                        _dbg(f"[CORE-SENDER] Sending to Daemon: INST={_ffi_installed}, REM={_ffi_removed}")
+                    if daemon_client:
+                        print(f" [CORE-SENDER] Sending to Daemon: INST={_ffi_installed}, REM={_ffi_removed}", file=sys.stderr)
                         try:
                             daemon_client.end_omnipkg_op(installed=_ffi_installed, removed=_ffi_removed)
                         except Exception as e:
                             _dbg(f"[FS-WATCHER-CLIENT] Failed to signal end_op to daemon: {e}")
 
-                    # Always clean up the lock file (it lives in main site-packages,
-                    # we touched it, we clean it — even if the bubble path somehow set it)
+                    # ✅ Delete AFTER IPC is sent — not before
                     if _op_marker and _op_marker.exists():
                         try:
                             _op_marker.unlink()
                         except Exception as e:
-                            _dbg(f"[FS-WATCHER-CLIENT] Failed to unlink op_marker: {e}")
+                            _dbg(f"[FS-WATCHER-CLIENT] Failed to signal end_op to daemon: {e}")
 
             else:
-                safe_print(f"[UV-PATH] FFI skipped (unavailable) — trying daemon", file=sys.stderr)
+                safe_print(f"[UV-PATH] FFI skipped (unavailable or --target) — trying daemon", file=sys.stderr)
 
             # ── PATH 2: daemon run_uv (~IPC overhead) ──────────────
             _t0 = time.perf_counter()

src/omnipkg/dispatcher.c

@@ -2055,16 +2055,7 @@ int main(int argc, char **argv) {
          * that contain the word python (e.g. "info python-dotenv"). */
         int info_python = (is_info && argc >= 3 &&
                            strcmp(argv[2], "python") == 0);
-        int is_logs_follow = 0;
-        if (argc >= 3 && strcmp(argv[1], "daemon") == 0 && strcmp(argv[2], "logs") == 0) {
-            for (int _i = 3; _i < argc; _i++) {
-                if (strcmp(argv[_i], "-f") == 0 || strcmp(argv[_i], "--follow") == 0) {
-                    is_logs_follow = 1;
-                    break;
-                }
-            }
-        }
-        is_interactive_command = ((is_info && !info_python) || is_config || is_logs_follow);
+        is_interactive_command = ((is_info && !info_python) || is_config);
     }
     if (!is_swap_python && !is_interactive_command) {
         try_daemon_cli(target_python, argc, argv, version_injected, forced_version);

src/omnipkg/dispatcher.py

@@ -225,21 +225,7 @@ def main():
         and argv_commands[1] in ("start", "stop", "restart")
     )
 
-    is_info_command = (
-        len(argv_commands) >= 1
-        and argv_commands[0] == "info"
-        and not (len(argv_commands) >= 2 and argv_commands[1] == "python")
-    )
-    is_config_command = len(argv_commands) >= 1 and argv_commands[0] == "config"
-    is_logs_follow = (
-        len(argv_commands) >= 2
-        and argv_commands[0] == "daemon"
-        and argv_commands[1] == "logs"
-        and "-f" in sys.argv
-    )
-    is_interactive_command = is_info_command or is_config_command or is_logs_follow
-
-    if not is_swap_command and not is_daemon_lifecycle and not is_interactive_command:
+    if not is_swap_command and not is_daemon_lifecycle:
         try:
             import socket
             import tempfile
@@ -254,7 +240,6 @@ def main():
                         host, port = conn_str[6:].split(":")
                         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                         sock.connect((host, int(port)))
-                        sock.settimeout(300)
                     else:
                         raise ValueError()
                 else:
@@ -263,7 +248,6 @@ def main():
                 if os.path.exists(sock_path):
                     sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
                     sock.connect(sock_path)
-                    sock.settimeout(300)
                 else:
                     raise ValueError()