feat(freecad): add Silo-aware start page with webview and offline fallback

Replaces the default FreeCAD Start page with a dual-mode view:
- Online: QWebEngineView loading the Silo web app
- Offline: native Qt fallback with recent files and connectivity status

The command override is registered at InitGui.py load time, before
the C++ StartLauncher fires.

freecad/InitGui.py

@@ -47,6 +47,8 @@ class SiloWorkbench(FreeCADGui.Workbench):
             "Separator",
             "Silo_Settings",
             "Silo_Auth",
+            "Silo_StartPanel",
+            "Silo_Diag",
         ]
 
         self.appendMenu("Silo", self.menu_commands)
@@ -54,6 +56,7 @@ class SiloWorkbench(FreeCADGui.Workbench):
     def Activated(self):
         """Called when workbench is activated."""
         FreeCAD.Console.PrintMessage("Kindred Silo workbench activated\n")
+        FreeCADGui.runCommand("Silo_StartPanel", 0)
 
     def Deactivated(self):
         pass
@@ -64,3 +67,12 @@ class SiloWorkbench(FreeCADGui.Workbench):
 
 FreeCADGui.addWorkbench(SiloWorkbench())
 FreeCAD.Console.PrintMessage("Silo workbench registered\n")
+
+# Override the Start page with Silo-aware version (must happen before
+# the C++ StartLauncher fires at ~100ms after GUI init)
+try:
+    import silo_start
+
+    silo_start.register()
+except Exception as e:
+    FreeCAD.Console.PrintWarning(f"Silo Start page override failed: {e}\n")

freecad/resources/icons/silo-rollback.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="#cba6f7" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <!-- Counter-clockwise arrow -->
+  <polyline points="1 4 1 10 7 10" stroke="#f38ba8"/>
+  <path d="M3.51 15a9 9 0 1 0 2.13-9.36L1 10" stroke="#cba6f7"/>
+  <!-- Clock hands -->
+  <line x1="12" y1="7" x2="12" y2="12" stroke="#89dceb" stroke-width="1.5"/>
+  <line x1="12" y1="12" x2="15" y2="14" stroke="#89dceb" stroke-width="1.5"/>
+</svg>

freecad/resources/icons/silo-status.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="#cba6f7" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <!-- Shield shape -->
+  <path d="M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z" fill="#313244"/>
+  <!-- Status bars -->
+  <line x1="8" y1="10" x2="16" y2="10" stroke="#a6e3a1" stroke-width="1.5"/>
+  <line x1="8" y1="14" x2="13" y2="14" stroke="#89dceb" stroke-width="1.5"/>
+</svg>

freecad/resources/icons/silo-tag.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="#cba6f7" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <!-- Tag shape -->
+  <path d="M20.59 13.41l-7.17 7.17a2 2 0 0 1-2.83 0L2 12V2h10l8.59 8.59a2 2 0 0 1 0 2.82z" fill="#313244"/>
+  <!-- Tag hole -->
+  <circle cx="7" cy="7" r="1.5" fill="#cba6f7" stroke="none"/>
+</svg>

freecad/silo_commands.py

@@ -3,6 +3,7 @@
 import json
 import os
 import re
+import socket
 import urllib.error
 import urllib.parse
 import urllib.request
@@ -1997,15 +1998,18 @@ class Silo_BOM:
 
         obj = get_tracked_object(doc)
         if not obj:
-            FreeCAD.Console.PrintError("No tracked Silo item in active document.\n")
-            from PySide import QtGui as _qg
-
-            _qg.QMessageBox.warning(
+            reply = QtGui.QMessageBox.question(
                 None,
                 "BOM",
-                "This document is not registered with Silo.\nUse Silo > New to register it first.",
+                "This document is not registered with Silo.\n\nRegister it now?",
+                QtGui.QMessageBox.Yes | QtGui.QMessageBox.No,
             )
-            return
+            if reply != QtGui.QMessageBox.Yes:
+                return
+            FreeCADGui.runCommand("Silo_New")
+            obj = get_tracked_object(doc)
+            if not obj:
+                return
 
         part_number = obj.SiloPartNumber
 
@@ -2365,13 +2369,13 @@ class SiloEventListener(QtCore.QThread):
     item_updated = QtCore.Signal(str)  # part_number
     revision_created = QtCore.Signal(str, int)  # part_number, revision
     connection_status = QtCore.Signal(
-        str
-    )  # "connected" / "disconnected" / "unsupported"
+        str, int, str
+    )  # (status, retry_count, error_message)
     server_mode_changed = QtCore.Signal(str)  # "normal" / "read-only" / "degraded"
 
-    _MAX_FAST_RETRIES = 3
-    _FAST_RETRY_SECS = 5
-    _SLOW_RETRY_SECS = 30
+    _MAX_RETRIES = 10
+    _BASE_DELAY = 1  # seconds, doubles each retry
+    _MAX_DELAY = 60  # seconds, backoff cap
 
     def __init__(self, parent=None):
         super().__init__(parent)
@@ -2394,6 +2398,7 @@ class SiloEventListener(QtCore.QThread):
 
     def run(self):
         retries = 0
+        last_error = ""
         while not self._stop_flag:
             try:
                 self._listen()
@@ -2401,21 +2406,24 @@ class SiloEventListener(QtCore.QThread):
                 if self._stop_flag:
                     return
                 retries += 1
+                last_error = "connection closed"
             except _SSEUnsupported:
-                self.connection_status.emit("unsupported")
+                self.connection_status.emit("unsupported", 0, "")
                 return
-            except Exception:
+            except Exception as exc:
                 retries += 1
+                last_error = str(exc) or "unknown error"
 
-            self.connection_status.emit("disconnected")
+            if retries > self._MAX_RETRIES:
+                self.connection_status.emit("gave_up", retries - 1, last_error)
+                return
 
-            if retries <= self._MAX_FAST_RETRIES:
-                delay = self._FAST_RETRY_SECS
-            else:
-                delay = self._SLOW_RETRY_SECS
+            self.connection_status.emit("disconnected", retries, last_error)
+
+            delay = min(self._BASE_DELAY * (2 ** (retries - 1)), self._MAX_DELAY)
 
             # Interruptible sleep
-            for _ in range(delay):
+            for _ in range(int(delay)):
                 if self._stop_flag:
                     return
                 self.msleep(1000)
@@ -2423,7 +2431,7 @@ class SiloEventListener(QtCore.QThread):
     # -- SSE stream reader --------------------------------------------------
 
     def _listen(self):
-        url = f"{_get_api_url().rstrip('/')}/api/events"
+        url = f"{_get_api_url().rstrip('/')}/events"
         headers = {"Accept": "text/event-stream"}
         headers.update(_get_auth_headers())
         req = urllib.request.Request(url, headers=headers, method="GET")
@@ -2439,7 +2447,7 @@ class SiloEventListener(QtCore.QThread):
         except urllib.error.URLError:
             raise
 
-        self.connection_status.emit("connected")
+        self.connection_status.emit("connected", 0, "")
 
         event_type = ""
         data_buf = ""
@@ -2705,13 +2713,28 @@ class SiloAuthDockWidget:
                 self._event_listener.stop()
             self._sse_label.setText("")
 
-    def _on_sse_status(self, status):
+    def _on_sse_status(self, status, retry, error):
         if status == "connected":
             self._sse_label.setText("Listening")
             self._sse_label.setStyleSheet("font-size: 11px; color: #4CAF50;")
+            self._sse_label.setToolTip("")
+            FreeCAD.Console.PrintMessage("Silo: SSE connected\n")
         elif status == "disconnected":
-            self._sse_label.setText("Reconnecting...")
+            self._sse_label.setText(
+                f"Reconnecting ({retry}/{SiloEventListener._MAX_RETRIES})..."
+            )
             self._sse_label.setStyleSheet("font-size: 11px; color: #FF9800;")
+            self._sse_label.setToolTip(error or "Connection lost")
+            FreeCAD.Console.PrintWarning(
+                f"Silo: SSE reconnecting ({retry}/{SiloEventListener._MAX_RETRIES}): {error}\n"
+            )
+        elif status == "gave_up":
+            self._sse_label.setText("Disconnected")
+            self._sse_label.setStyleSheet("font-size: 11px; color: #F44336;")
+            self._sse_label.setToolTip(error or "Max retries reached")
+            FreeCAD.Console.PrintError(
+                f"Silo: SSE gave up after {retry} retries: {error}\n"
+            )
         elif status == "unsupported":
             self._sse_label.setText("Not available")
             self._sse_label.setStyleSheet("font-size: 11px; color: #888;")
@@ -2765,7 +2788,7 @@ class SiloAuthDockWidget:
 
     def _refresh_activity_panel(self):
         """Refresh the Database Activity panel if it exists."""
-        from PySide import QtWidgets
+        from PySide import QtCore, QtGui, QtWidgets
 
         mw = FreeCADGui.getMainWindow()
         if mw is None:
@@ -2777,6 +2800,24 @@ class SiloAuthDockWidget:
         if activity_list is None:
             return
         activity_list.clear()
+
+        # Connect interaction signals (once)
+        if not getattr(activity_list, "_silo_connected", False):
+            activity_list.itemDoubleClicked.connect(self._on_activity_double_click)
+            activity_list.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
+            activity_list.customContextMenuRequested.connect(
+                lambda pos: self._on_activity_context_menu(activity_list, pos)
+            )
+            activity_list._silo_connected = True
+
+        # Collect local part numbers for badge
+        local_pns = set()
+        try:
+            for lf in search_local_files():
+                local_pns.add(lf.get("part_number", ""))
+        except Exception:
+            pass
+
         try:
             items = _client.list_items()
             if isinstance(items, list):
@@ -2786,12 +2827,96 @@ class SiloAuthDockWidget:
                     updated = item.get("updated_at", "")
                     if updated:
                         updated = updated[:10]
-                    activity_list.addItem(f"{pn} - {desc} - {updated}")
+
+                    # Fetch latest revision info
+                    rev_num = ""
+                    comment = ""
+                    try:
+                        revs = _client.get_revisions(pn)
+                        if revs:
+                            latest = revs[0] if isinstance(revs, list) else revs
+                            rev_num = str(latest.get("revision_number", ""))
+                            comment = latest.get("comment", "") or ""
+                    except Exception:
+                        pass
+
+                    # Truncate long descriptions
+                    desc_display = desc
+                    if len(desc_display) > 40:
+                        desc_display = desc_display[:37] + "..."
+
+                    # Build display text
+                    rev_part = f" \u2013 Rev {rev_num}" if rev_num else ""
+                    date_part = f" \u2013 {updated}" if updated else ""
+                    local_badge = " \u25cf local" if pn in local_pns else ""
+                    line1 = (
+                        f"{pn} \u2013 {desc_display}{rev_part}{date_part}{local_badge}"
+                    )
+
+                    if comment:
+                        line1 += f'\n  "{comment}"'
+                    else:
+                        line1 += "\n  (no comment)"
+
+                    list_item = QtWidgets.QListWidgetItem(line1)
+                    list_item.setData(QtCore.Qt.UserRole, pn)
+                    if desc and len(desc) > 40:
+                        list_item.setToolTip(desc)
+                    if pn in local_pns:
+                        list_item.setForeground(QtGui.QColor("#4CAF50"))
+                    activity_list.addItem(list_item)
+
             if activity_list.count() == 0:
                 activity_list.addItem("(No items in database)")
         except Exception:
             activity_list.addItem("(Unable to refresh activity)")
 
+    def _on_activity_double_click(self, item):
+        """Open/checkout item from activity pane."""
+        pn = item.data(256)  # Qt.UserRole
+        if not pn:
+            return
+        local_path = find_file_by_part_number(pn)
+        if local_path and local_path.exists():
+            FreeCAD.openDocument(str(local_path))
+        else:
+            _sync.open_item(pn)
+
+    def _on_activity_context_menu(self, activity_list, pos):
+        """Show context menu for activity pane items."""
+        from PySide import QtCore, QtGui
+
+        item = activity_list.itemAt(pos)
+        if item is None:
+            return
+        pn = item.data(QtCore.Qt.UserRole)
+        if not pn:
+            return
+
+        menu = QtGui.QMenu()
+        open_action = menu.addAction("Open in Create")
+        browser_action = menu.addAction("Open in Browser")
+        copy_action = menu.addAction("Copy Part Number")
+        revisions_action = menu.addAction("View Revisions")
+
+        action = menu.exec_(activity_list.mapToGlobal(pos))
+        if action == open_action:
+            local_path = find_file_by_part_number(pn)
+            if local_path and local_path.exists():
+                FreeCAD.openDocument(str(local_path))
+            else:
+                _sync.open_item(pn)
+        elif action == browser_action:
+            import webbrowser
+
+            api_url = _get_api_url().rstrip("/")
+            base_url = api_url[:-4] if api_url.endswith("/api") else api_url
+            webbrowser.open(f"{base_url}/items/{pn}")
+        elif action == copy_action:
+            QtGui.QApplication.clipboard().setText(pn)
+        elif action == revisions_action:
+            FreeCADGui.runCommand("Silo_Info", 0)
+
     # -- Actions ------------------------------------------------------------
 
     def _on_login_clicked(self):
@@ -2940,6 +3065,390 @@ class Silo_Auth:
         return True
 
 
+# ---------------------------------------------------------------------------
+# Start panel
+# ---------------------------------------------------------------------------
+
+
+class SiloStartPanel:
+    """Content widget for the Silo Start Panel dock."""
+
+    def __init__(self):
+        from PySide import QtCore, QtGui
+
+        self.widget = QtGui.QWidget()
+        self._build_ui()
+        self._refresh()
+
+        self._timer = QtCore.QTimer(self.widget)
+        self._timer.timeout.connect(self._refresh)
+        self._timer.start(60000)  # Refresh every 60 seconds
+
+    def _build_ui(self):
+        from PySide import QtCore, QtGui
+
+        layout = QtGui.QVBoxLayout(self.widget)
+        layout.setContentsMargins(8, 8, 8, 8)
+        layout.setSpacing(6)
+
+        # Connection status badge
+        status_row = QtGui.QHBoxLayout()
+        status_row.setSpacing(6)
+        self._conn_dot = QtGui.QLabel("\u2b24")
+        self._conn_dot.setFixedWidth(16)
+        self._conn_dot.setAlignment(QtCore.Qt.AlignCenter)
+        self._conn_label = QtGui.QLabel("Checking...")
+        self._conn_label.setStyleSheet("font-weight: bold;")
+        status_row.addWidget(self._conn_dot)
+        status_row.addWidget(self._conn_label)
+        status_row.addStretch()
+        layout.addLayout(status_row)
+
+        layout.addSpacing(8)
+
+        # My Checkouts section
+        checkout_header = QtGui.QLabel("My Checkouts")
+        checkout_header.setStyleSheet("font-weight: bold; font-size: 12px;")
+        layout.addWidget(checkout_header)
+
+        self._checkout_list = QtGui.QListWidget()
+        self._checkout_list.setMaximumHeight(160)
+        self._checkout_list.setAlternatingRowColors(True)
+        self._checkout_list.itemDoubleClicked.connect(self._on_checkout_clicked)
+        layout.addWidget(self._checkout_list)
+
+        layout.addSpacing(8)
+
+        # Recent Silo Activity section
+        activity_header = QtGui.QLabel("Recent Silo Activity")
+        activity_header.setStyleSheet("font-weight: bold; font-size: 12px;")
+        layout.addWidget(activity_header)
+
+        self._activity_list = QtGui.QListWidget()
+        self._activity_list.setMaximumHeight(200)
+        self._activity_list.setAlternatingRowColors(True)
+        self._activity_list.itemDoubleClicked.connect(self._on_activity_clicked)
+        layout.addWidget(self._activity_list)
+
+        layout.addSpacing(8)
+
+        # Local Recent Files section
+        local_header = QtGui.QLabel("Local Recent Files")
+        local_header.setStyleSheet("font-weight: bold; font-size: 12px;")
+        layout.addWidget(local_header)
+
+        self._local_list = QtGui.QListWidget()
+        self._local_list.setMaximumHeight(160)
+        self._local_list.setAlternatingRowColors(True)
+        self._local_list.itemDoubleClicked.connect(self._on_local_clicked)
+        layout.addWidget(self._local_list)
+
+        layout.addStretch()
+
+    def _refresh(self):
+        self._refresh_connection()
+        self._refresh_checkouts()
+        self._refresh_activity()
+        self._refresh_local()
+
+    def _refresh_connection(self):
+        try:
+            reachable, _ = _client.check_connection()
+        except Exception:
+            reachable = False
+
+        if reachable:
+            api_url = _get_api_url()
+            parsed = urllib.parse.urlparse(api_url)
+            hostname = parsed.hostname or api_url
+            self._conn_dot.setStyleSheet("color: #4CAF50; font-size: 10px;")
+            self._conn_label.setText(f"Connected to {hostname}")
+        else:
+            self._conn_dot.setStyleSheet("color: #888; font-size: 10px;")
+            self._conn_label.setText("Disconnected")
+
+    def _refresh_checkouts(self):
+        self._checkout_list.clear()
+        try:
+            local_files = search_local_files()
+            for item in local_files[:15]:
+                pn = item.get("part_number", "")
+                desc = item.get("description", "")
+                modified = (item.get("modified") or "")[:10]
+                label = f"{pn}  {desc}"
+                if modified:
+                    label += f"  ({modified})"
+                list_item = self._checkout_list.addItem(label)
+        except Exception:
+            self._checkout_list.addItem("(Unable to scan local files)")
+
+        if self._checkout_list.count() == 0:
+            self._checkout_list.addItem("(No local checkouts)")
+
+    def _refresh_activity(self):
+        self._activity_list.clear()
+        try:
+            reachable, _ = _client.check_connection()
+        except Exception:
+            reachable = False
+
+        if not reachable:
+            self._activity_list.addItem("(Not connected)")
+            return
+
+        try:
+            items = _client.list_items()
+            if isinstance(items, list):
+                # Collect local part numbers for badge comparison
+                local_pns = set()
+                try:
+                    for lf in search_local_files():
+                        local_pns.add(lf.get("part_number", ""))
+                except Exception:
+                    pass
+
+                for item in items[:10]:
+                    pn = item.get("part_number", "")
+                    desc = item.get("description", "")
+                    updated = (item.get("updated_at") or "")[:10]
+                    badge = "\u2713 " if pn in local_pns else ""
+                    label = f"{badge}{pn}  {desc}"
+                    if updated:
+                        label += f"  ({updated})"
+                    self._activity_list.addItem(label)
+
+            if self._activity_list.count() == 0:
+                self._activity_list.addItem("(No items in database)")
+        except Exception:
+            self._activity_list.addItem("(Unable to fetch activity)")
+
+    def _refresh_local(self):
+        from PySide import QtGui
+
+        self._local_list.clear()
+        try:
+            param = FreeCAD.ParamGet("User parameter:BaseApp/RecentFiles")
+            count = param.GetInt("RecentFiles", 0)
+            for i in range(min(count, 10)):
+                path = param.GetString(f"MRU{i}", "")
+                if path:
+                    name = Path(path).name
+                    item = QtGui.QListWidgetItem(name)
+                    item.setToolTip(path)
+                    item.setData(256, path)  # Qt.UserRole = 256
+                    self._local_list.addItem(item)
+        except Exception:
+            pass
+
+        if self._local_list.count() == 0:
+            self._local_list.addItem("(No recent files)")
+
+    def _on_checkout_clicked(self, item):
+        """Open a local checkout file."""
+        text = item.text()
+        if text.startswith("("):
+            return
+        pn = text.split()[0] if text else ""
+        if not pn:
+            return
+        local_path = find_file_by_part_number(pn)
+        if local_path and local_path.exists():
+            FreeCAD.openDocument(str(local_path))
+
+    def _on_activity_clicked(self, item):
+        """Open/checkout a remote item."""
+        text = item.text()
+        if text.startswith("("):
+            return
+        # Strip badge if present
+        text = text.lstrip("\u2713 ")
+        pn = text.split()[0] if text else ""
+        if not pn:
+            return
+        local_path = find_file_by_part_number(pn)
+        if local_path and local_path.exists():
+            FreeCAD.openDocument(str(local_path))
+        else:
+            _sync.open_item(pn)
+
+    def _on_local_clicked(self, item):
+        """Open a local recent file."""
+        path = item.data(256)  # Qt.UserRole
+        if path and Path(path).exists():
+            FreeCAD.openDocument(path)
+
+
+class Silo_StartPanel:
+    """Show the Silo Start Panel."""
+
+    def GetResources(self):
+        return {
+            "MenuText": "Start Panel",
+            "ToolTip": "Show Silo start panel with checkouts and recent activity",
+            "Pixmap": _icon("open"),
+        }
+
+    def Activated(self):
+        from PySide import QtCore, QtGui
+
+        mw = FreeCADGui.getMainWindow()
+        if mw is None:
+            return
+
+        # Reuse existing panel if it exists
+        panel = mw.findChild(QtGui.QDockWidget, "SiloStartPanel")
+        if panel:
+            panel.show()
+            panel.raise_()
+            return
+
+        # Create new dock widget
+        content = SiloStartPanel()
+        dock = QtGui.QDockWidget("Silo", mw)
+        dock.setObjectName("SiloStartPanel")
+        dock.setWidget(content.widget)
+        dock.setAllowedAreas(
+            QtCore.Qt.LeftDockWidgetArea | QtCore.Qt.RightDockWidgetArea
+        )
+        mw.addDockWidget(QtCore.Qt.LeftDockWidgetArea, dock)
+
+    def IsActive(self):
+        return True
+
+
+class _DiagWorker(QtCore.QThread):
+    """Background worker that runs connectivity diagnostics."""
+
+    result = QtCore.Signal(str, bool, str)  # (test_name, passed, detail)
+    finished_all = QtCore.Signal()
+    _HTTP_TIMEOUT = 10
+    _DNS_TIMEOUT = 5
+
+    def run(self):
+        api_url = _get_api_url()
+        base_url = api_url.rstrip("/")
+        if base_url.endswith("/api"):
+            base_url = base_url[:-4]
+        self._test_dns(base_url)
+        self._test_http("Health", f"{base_url}/health", auth=False)
+        self._test_http("Ready", f"{base_url}/ready", auth=False)
+        self._test_http("Auth", f"{api_url.rstrip('/')}/auth/me", auth=True)
+        self._test_sse(api_url)
+        self.finished_all.emit()
+
+    def _test_dns(self, base_url):
+        parsed = urllib.parse.urlparse(base_url)
+        hostname = parsed.hostname
+        if not hostname:
+            self.result.emit("DNS", False, "no hostname in URL")
+            return
+        try:
+            addrs = socket.getaddrinfo(
+                hostname, None, socket.AF_UNSPEC, socket.SOCK_STREAM
+            )
+            first_ip = addrs[0][4][0] if addrs else "?"
+            self.result.emit("DNS", True, f"{hostname} -> {first_ip}")
+        except socket.gaierror as e:
+            self.result.emit("DNS", False, f"{hostname}: {e}")
+        except Exception as e:
+            self.result.emit("DNS", False, str(e))
+
+    def _test_http(self, name, url, auth=False):
+        try:
+            headers = {}
+            if auth:
+                headers.update(_get_auth_headers())
+            req = urllib.request.Request(url, headers=headers, method="GET")
+            resp = urllib.request.urlopen(
+                req, context=_get_ssl_context(), timeout=self._HTTP_TIMEOUT
+            )
+            code = resp.getcode()
+            body = resp.read(4096).decode("utf-8", errors="replace").strip()
+            detail = f"HTTP {code}"
+            try:
+                data = json.loads(body)
+                if isinstance(data, dict):
+                    parts = []
+                    for key in ("status", "username", "role"):
+                        if key in data:
+                            parts.append(f"{key}={data[key]}")
+                    if parts:
+                        detail += f" ({', '.join(parts)})"
+            except (json.JSONDecodeError, ValueError):
+                if len(body) <= 80:
+                    detail += f" {body}"
+            self.result.emit(name, code < 400, detail)
+        except urllib.error.HTTPError as e:
+            self.result.emit(name, False, f"HTTP {e.code} {e.reason}")
+        except urllib.error.URLError as e:
+            self.result.emit(name, False, str(e.reason))
+        except Exception as e:
+            self.result.emit(name, False, str(e))
+
+    def _test_sse(self, api_url):
+        url = f"{api_url.rstrip('/')}/events"
+        try:
+            headers = {"Accept": "text/event-stream"}
+            headers.update(_get_auth_headers())
+            req = urllib.request.Request(url, headers=headers, method="GET")
+            resp = urllib.request.urlopen(
+                req, context=_get_ssl_context(), timeout=self._HTTP_TIMEOUT
+            )
+            content_type = resp.headers.get("Content-Type", "")
+            code = resp.getcode()
+            resp.close()
+            if "text/event-stream" in content_type:
+                self.result.emit("SSE", True, f"HTTP {code} event-stream")
+            else:
+                self.result.emit("SSE", True, f"HTTP {code} (type: {content_type})")
+        except urllib.error.HTTPError as e:
+            if e.code in (404, 501):
+                self.result.emit("SSE", False, f"HTTP {e.code} (not supported)")
+            else:
+                self.result.emit("SSE", False, f"HTTP {e.code} {e.reason}")
+        except urllib.error.URLError as e:
+            self.result.emit("SSE", False, str(e.reason))
+        except Exception as e:
+            self.result.emit("SSE", False, str(e))
+
+
+class Silo_Diag:
+    """Command to run connection diagnostics."""
+
+    _worker = None
+
+    def GetResources(self):
+        return {
+            "MenuText": "Diagnostics",
+            "ToolTip": "Test DNS, health, readiness, auth, and SSE connectivity",
+            "Pixmap": _icon("info"),
+        }
+
+    def Activated(self):
+        if self._worker is not None and self._worker.isRunning():
+            FreeCAD.Console.PrintWarning("Silo: diagnostics already running\n")
+            return
+        api_url = _get_api_url()
+        FreeCAD.Console.PrintMessage(f"--- Silo Diagnostics ({api_url}) ---\n")
+        self._worker = _DiagWorker()
+        self._worker.result.connect(self._on_result)
+        self._worker.finished_all.connect(self._on_finished)
+        self._worker.start()
+
+    def _on_result(self, name, passed, detail):
+        if passed:
+            FreeCAD.Console.PrintMessage(f"  PASS  {name}: {detail}\n")
+        else:
+            FreeCAD.Console.PrintError(f"  FAIL  {name}: {detail}\n")
+
+    def _on_finished(self):
+        FreeCAD.Console.PrintMessage("--- Diagnostics complete ---\n")
+        self._worker = None
+
+    def IsActive(self):
+        return True
+
+
 # Register commands
 FreeCADGui.addCommand("Silo_Open", Silo_Open())
 FreeCADGui.addCommand("Silo_New", Silo_New())
@@ -2955,3 +3464,5 @@ FreeCADGui.addCommand("Silo_SetStatus", Silo_SetStatus())
 FreeCADGui.addCommand("Silo_Settings", Silo_Settings())
 
 FreeCADGui.addCommand("Silo_Auth", Silo_Auth())
+FreeCADGui.addCommand("Silo_StartPanel", Silo_StartPanel())
+FreeCADGui.addCommand("Silo_Diag", Silo_Diag())

freecad/silo_origin.py

@@ -299,9 +299,7 @@ class SiloOrigin:
             Created App.Document or None
         """
         try:
-            cmd = FreeCADGui.Command.get("Silo_New")
-            if cmd:
-                cmd.Activated()
+            FreeCADGui.runCommand("Silo_New")
             return FreeCAD.ActiveDocument
         except Exception as e:
             FreeCAD.Console.PrintError(f"Silo new document failed: {e}\n")
@@ -322,9 +320,7 @@ class SiloOrigin:
         if not identity:
             # No identity - show search dialog
             try:
-                cmd = FreeCADGui.Command.get("Silo_Open")
-                if cmd:
-                    cmd.Activated()
+                FreeCADGui.runCommand("Silo_Open")
                 return FreeCAD.ActiveDocument
             except Exception as e:
                 FreeCAD.Console.PrintError(f"Silo open failed: {e}\n")
@@ -354,9 +350,7 @@ class SiloOrigin:
             Opened App.Document or None
         """
         try:
-            cmd = FreeCADGui.Command.get("Silo_Open")
-            if cmd:
-                cmd.Activated()
+            FreeCADGui.runCommand("Silo_Open")
             return FreeCAD.ActiveDocument
         except Exception as e:
             FreeCAD.Console.PrintError(f"Silo open failed: {e}\n")
@@ -473,10 +467,8 @@ class SiloOrigin:
             True if command was executed
         """
         try:
-            cmd = FreeCADGui.Command.get("Silo_Commit")
-            if cmd:
-                cmd.Activated()
-                return True
+            FreeCADGui.runCommand("Silo_Commit")
+            return True
         except Exception as e:
             FreeCAD.Console.PrintError(f"Silo commit failed: {e}\n")
         return False
@@ -493,10 +485,8 @@ class SiloOrigin:
             True if command was executed
         """
         try:
-            cmd = FreeCADGui.Command.get("Silo_Pull")
-            if cmd:
-                cmd.Activated()
-                return True
+            FreeCADGui.runCommand("Silo_Pull")
+            return True
         except Exception as e:
             FreeCAD.Console.PrintError(f"Silo pull failed: {e}\n")
         return False
@@ -513,10 +503,8 @@ class SiloOrigin:
             True if command was executed
         """
         try:
-            cmd = FreeCADGui.Command.get("Silo_Push")
-            if cmd:
-                cmd.Activated()
-                return True
+            FreeCADGui.runCommand("Silo_Push")
+            return True
         except Exception as e:
             FreeCAD.Console.PrintError(f"Silo push failed: {e}\n")
         return False
@@ -530,9 +518,7 @@ class SiloOrigin:
             doc: FreeCAD App.Document
         """
         try:
-            cmd = FreeCADGui.Command.get("Silo_Info")
-            if cmd:
-                cmd.Activated()
+            FreeCADGui.runCommand("Silo_Info")
         except Exception as e:
             FreeCAD.Console.PrintError(f"Silo info failed: {e}\n")
 
@@ -545,9 +531,7 @@ class SiloOrigin:
             doc: FreeCAD App.Document
         """
         try:
-            cmd = FreeCADGui.Command.get("Silo_BOM")
-            if cmd:
-                cmd.Activated()
+            FreeCADGui.runCommand("Silo_BOM")
         except Exception as e:
             FreeCAD.Console.PrintError(f"Silo BOM failed: {e}\n")
 

freecad/silo_start.py

@@ -0,0 +1,444 @@
+"""Silo Start Page — dual-mode start view for Kindred Create.
+
+Replaces the default Start page with either:
+- A QWebEngineView showing the Silo web app (when Silo is reachable)
+- A native Qt offline fallback with recent files and connectivity status
+
+The command override is activated by calling ``register()`` at module level
+from InitGui.py, which overwrites the C++ ``Start_Start`` command.
+"""
+
+import os
+import ssl
+import urllib.error
+import urllib.parse
+import urllib.request
+from datetime import datetime
+from pathlib import Path
+
+import FreeCAD
+import FreeCADGui
+from PySide import QtCore, QtGui, QtWidgets
+
+# Try to import QtWebEngineWidgets — not all builds ship it
+_HAS_WEBENGINE = False
+try:
+    from PySide import QtWebEngineWidgets
+
+    _HAS_WEBENGINE = True
+except ImportError:
+    FreeCAD.Console.PrintLog(
+        "Silo Start: QtWebEngineWidgets not available, using offline mode only\n"
+    )
+
+# ---------------------------------------------------------------------------
+# Catppuccin Mocha palette
+# ---------------------------------------------------------------------------
+_MOCHA = {
+    "base": "#1e1e2e",
+    "mantle": "#181825",
+    "crust": "#11111b",
+    "surface0": "#313244",
+    "surface1": "#45475a",
+    "surface2": "#585b70",
+    "text": "#cdd6f4",
+    "subtext0": "#a6adc8",
+    "subtext1": "#bac2de",
+    "blue": "#89b4fa",
+    "green": "#a6e3a1",
+    "red": "#f38ba8",
+    "peach": "#fab387",
+    "lavender": "#b4befe",
+    "overlay0": "#6c7086",
+}
+
+_PREF_GROUP = "User parameter:BaseApp/Preferences/Mod/KindredSilo"
+_POLL_INTERVAL_MS = 5000
+_CONNECT_TIMEOUT_S = 2
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _get_silo_base_url() -> str:
+    """Return the Silo web UI root URL (without /api)."""
+    param = FreeCAD.ParamGet(_PREF_GROUP)
+    url = param.GetString("ApiUrl", "")
+    if not url:
+        url = os.environ.get("SILO_API_URL", "http://localhost:8080/api")
+    url = url.rstrip("/")
+    # Strip trailing /api to get the web root
+    if url.endswith("/api"):
+        url = url[:-4]
+    return url
+
+
+def _get_ssl_context() -> ssl.SSLContext:
+    """Build an SSL context respecting the Silo SSL preference."""
+    param = FreeCAD.ParamGet(_PREF_GROUP)
+    if param.GetBool("SslVerify", True):
+        return ssl.create_default_context()
+    ctx = ssl.create_default_context()
+    ctx.check_hostname = False
+    ctx.verify_mode = ssl.CERT_NONE
+    return ctx
+
+
+def _check_connectivity(url: str) -> bool:
+    """HEAD-request the Silo base URL, return True if reachable."""
+    try:
+        req = urllib.request.Request(url, method="HEAD")
+        req.add_header("User-Agent", "kindred-create/1.0")
+        urllib.request.urlopen(req, timeout=_CONNECT_TIMEOUT_S, context=_get_ssl_context())
+        return True
+    except Exception:
+        return False
+
+
+def _get_recent_files() -> list:
+    """Read recent files from FreeCAD preferences."""
+    group = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/RecentFiles")
+    count = group.GetInt("RecentFiles", 0)
+    files = []
+    for i in range(count):
+        path = group.GetString(f"MRU{i}", "")
+        if path and os.path.exists(path):
+            p = Path(path)
+            mtime = datetime.fromtimestamp(p.stat().st_mtime)
+            files.append({"path": str(p), "name": p.name, "modified": mtime})
+    return files
+
+
+# ---------------------------------------------------------------------------
+# Offline fallback widget
+# ---------------------------------------------------------------------------
+
+
+class _OfflineWidget(QtWidgets.QWidget):
+    """Native Qt fallback showing Silo status and recent local files."""
+
+    retry_clicked = QtCore.Signal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._build_ui()
+        self.update_status(False, _get_silo_base_url())
+
+    def _build_ui(self):
+        layout = QtWidgets.QVBoxLayout(self)
+        layout.setContentsMargins(40, 30, 40, 20)
+        layout.setSpacing(0)
+
+        # --- Status banner ---
+        banner = QtWidgets.QFrame()
+        banner.setObjectName("SiloStatusBanner")
+        banner_layout = QtWidgets.QHBoxLayout(banner)
+        banner_layout.setContentsMargins(16, 12, 16, 12)
+
+        self._status_icon = QtWidgets.QLabel()
+        self._status_icon.setFixedSize(12, 12)
+        banner_layout.addWidget(self._status_icon)
+
+        self._status_label = QtWidgets.QLabel()
+        self._status_label.setWordWrap(True)
+        banner_layout.addWidget(self._status_label, 1)
+
+        self._retry_btn = QtWidgets.QPushButton("Retry")
+        self._retry_btn.setFixedWidth(80)
+        self._retry_btn.setCursor(QtCore.Qt.PointingHandCursor)
+        self._retry_btn.clicked.connect(self.retry_clicked.emit)
+        banner_layout.addWidget(self._retry_btn)
+
+        layout.addWidget(banner)
+        layout.addSpacing(24)
+
+        # --- Recent files header ---
+        header = QtWidgets.QLabel("Recent Files")
+        header.setObjectName("SiloRecentHeader")
+        layout.addWidget(header)
+        layout.addSpacing(12)
+
+        # --- Recent files list ---
+        self._file_list = QtWidgets.QListWidget()
+        self._file_list.setObjectName("SiloRecentList")
+        self._file_list.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+        self._file_list.itemDoubleClicked.connect(self._on_file_clicked)
+        layout.addWidget(self._file_list, 1)
+
+        layout.addSpacing(16)
+
+        # --- Footer ---
+        footer = QtWidgets.QHBoxLayout()
+        footer.addStretch()
+        self._startup_cb = QtWidgets.QCheckBox("Don't show this page on startup")
+        start_prefs = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/Start")
+        show = start_prefs.GetBool("ShowOnStartup", True)
+        self._startup_cb.setChecked(not show)
+        self._startup_cb.toggled.connect(self._on_startup_toggled)
+        footer.addWidget(self._startup_cb)
+        layout.addLayout(footer)
+
+        self._apply_style()
+
+    def _apply_style(self):
+        self.setStyleSheet(f"""
+            _OfflineWidget {{
+                background-color: {_MOCHA["base"]};
+            }}
+            #SiloStatusBanner {{
+                background-color: {_MOCHA["surface0"]};
+                border-radius: 8px;
+            }}
+            #SiloStatusBanner QLabel {{
+                color: {_MOCHA["text"]};
+                font-size: 13px;
+            }}
+            #SiloStatusBanner QPushButton {{
+                background-color: {_MOCHA["blue"]};
+                color: {_MOCHA["crust"]};
+                border: none;
+                border-radius: 4px;
+                padding: 6px 12px;
+                font-weight: bold;
+                font-size: 12px;
+            }}
+            #SiloStatusBanner QPushButton:hover {{
+                background-color: {_MOCHA["lavender"]};
+            }}
+            #SiloRecentHeader {{
+                color: {_MOCHA["text"]};
+                font-size: 20px;
+                font-weight: bold;
+            }}
+            #SiloRecentList {{
+                background-color: {_MOCHA["mantle"]};
+                border: 1px solid {_MOCHA["surface0"]};
+                border-radius: 6px;
+                padding: 4px;
+            }}
+            #SiloRecentList::item {{
+                padding: 10px 12px;
+                border-bottom: 1px solid {_MOCHA["surface0"]};
+                color: {_MOCHA["text"]};
+            }}
+            #SiloRecentList::item:last {{
+                border-bottom: none;
+            }}
+            #SiloRecentList::item:hover {{
+                background-color: {_MOCHA["surface0"]};
+            }}
+            #SiloRecentList::item:selected {{
+                background-color: {_MOCHA["surface1"]};
+            }}
+            QCheckBox {{
+                color: {_MOCHA["subtext0"]};
+                font-size: 12px;
+            }}
+            QCheckBox::indicator {{
+                width: 14px;
+                height: 14px;
+            }}
+        """)
+
+    def update_status(self, connected: bool, url: str, error: str = ""):
+        if connected:
+            self._status_icon.setStyleSheet(
+                f"background-color: {_MOCHA['green']}; border-radius: 6px;"
+            )
+            self._status_label.setText(f"Silo connected — {url}")
+            self._retry_btn.hide()
+        else:
+            self._status_icon.setStyleSheet(
+                f"background-color: {_MOCHA['red']}; border-radius: 6px;"
+            )
+            msg = f"Silo not reachable — {url}"
+            if error:
+                msg += f"  ({error})"
+            if not _HAS_WEBENGINE:
+                msg += "  [WebEngine not available]"
+            self._status_label.setText(msg)
+            self._retry_btn.show()
+
+    def refresh_recent_files(self):
+        self._file_list.clear()
+        files = _get_recent_files()
+        if not files:
+            item = QtWidgets.QListWidgetItem("No recent files")
+            item.setFlags(QtCore.Qt.NoItemFlags)
+            self._file_list.addItem(item)
+            return
+        for f in files:
+            label = f"{f['name']}\n{f['path']}\nModified: {f['modified']:%Y-%m-%d %H:%M}"
+            item = QtWidgets.QListWidgetItem(label)
+            item.setData(QtCore.Qt.UserRole, f["path"])
+            self._file_list.addItem(item)
+
+    def _on_file_clicked(self, item: QtWidgets.QListWidgetItem):
+        path = item.data(QtCore.Qt.UserRole)
+        if path:
+            try:
+                FreeCADGui.open(path)
+            except Exception as e:
+                FreeCAD.Console.PrintError(f"Silo Start: failed to open {path}: {e}\n")
+
+    @staticmethod
+    def _on_startup_toggled(checked: bool):
+        prefs = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/Start")
+        prefs.SetBool("ShowOnStartup", not checked)
+
+
+# ---------------------------------------------------------------------------
+# Web engine page (navigation filter)
+# ---------------------------------------------------------------------------
+
+if _HAS_WEBENGINE:
+
+    class _SiloPage(QtWebEngineWidgets.QWebEnginePage):
+        """Custom page that keeps navigation within the Silo origin."""
+
+        def __init__(self, silo_origin: str, parent=None):
+            super().__init__(parent)
+            self._silo_origin = silo_origin
+
+        def acceptNavigationRequest(self, url, nav_type, is_main_frame):
+            if nav_type == QtWebEngineWidgets.QWebEnginePage.NavigationTypeLinkClicked:
+                target = url.toString()
+                if not target.startswith(self._silo_origin):
+                    QtGui.QDesktopServices.openUrl(url)
+                    return False
+            return super().acceptNavigationRequest(url, nav_type, is_main_frame)
+
+
+# ---------------------------------------------------------------------------
+# Main start view
+# ---------------------------------------------------------------------------
+
+
+class SiloStartView(QtWidgets.QWidget):
+    """Dual-mode start page: Silo webview (online) / offline fallback."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setObjectName("SiloStartView")
+
+        self._silo_url = _get_silo_base_url()
+        self._connected = False
+
+        # Stack: page 0 = webview (or placeholder), page 1 = offline
+        self._stack = QtWidgets.QStackedWidget(self)
+        root_layout = QtWidgets.QVBoxLayout(self)
+        root_layout.setContentsMargins(0, 0, 0, 0)
+        root_layout.addWidget(self._stack)
+
+        # Page 0: web view
+        self._web_view = None
+        if _HAS_WEBENGINE:
+            self._web_view = QtWebEngineWidgets.QWebEngineView()
+            page = _SiloPage(self._silo_url, self._web_view)
+            self._web_view.setPage(page)
+            self._stack.addWidget(self._web_view)  # index 0
+        else:
+            # placeholder so indices stay consistent
+            placeholder = QtWidgets.QWidget()
+            self._stack.addWidget(placeholder)  # index 0
+
+        # Page 1: offline fallback
+        self._offline = _OfflineWidget()
+        self._offline.retry_clicked.connect(self._check_now)
+        self._offline.refresh_recent_files()
+        self._stack.addWidget(self._offline)  # index 1
+
+        # Start on offline page, then check connectivity
+        self._stack.setCurrentIndex(1)
+
+        # Connectivity polling timer
+        self._poll_timer = QtCore.QTimer(self)
+        self._poll_timer.setInterval(_POLL_INTERVAL_MS)
+        self._poll_timer.timeout.connect(self._poll)
+        self._poll_timer.start()
+
+        # Immediate first check
+        QtCore.QTimer.singleShot(0, self._check_now)
+
+    def _check_now(self):
+        """Run an immediate connectivity check and update the view."""
+        self._silo_url = _get_silo_base_url()
+        connected = _check_connectivity(self._silo_url)
+        self._set_connected(connected)
+
+    def _poll(self):
+        """Periodic connectivity check."""
+        self._silo_url = _get_silo_base_url()
+        connected = _check_connectivity(self._silo_url)
+        self._set_connected(connected)
+
+    def _set_connected(self, connected: bool):
+        if connected == self._connected:
+            return
+        self._connected = connected
+        if connected and self._web_view:
+            self._web_view.setUrl(QtCore.QUrl(self._silo_url))
+            self._stack.setCurrentIndex(0)
+            FreeCAD.Console.PrintLog(f"Silo Start: connected to {self._silo_url}\n")
+        else:
+            self._offline.update_status(False, self._silo_url)
+            self._offline.refresh_recent_files()
+            self._stack.setCurrentIndex(1)
+            if not connected:
+                FreeCAD.Console.PrintLog(f"Silo Start: cannot reach {self._silo_url}\n")
+        self._offline.update_status(connected, self._silo_url)
+
+
+# ---------------------------------------------------------------------------
+# Command override
+# ---------------------------------------------------------------------------
+
+
+class _SiloStartCommand:
+    """Replacement for the C++ Start_Start command."""
+
+    def Activated(self):
+        mw = FreeCADGui.getMainWindow()
+        mdi = mw.findChild(QtWidgets.QMdiArea)
+        if not mdi:
+            return
+
+        # Reuse existing view if open
+        for sw in mdi.subWindowList():
+            if sw.widget() and sw.widget().objectName() == "SiloStartView":
+                mdi.setActiveSubWindow(sw)
+                sw.show()
+                return
+
+        # Create new view as MDI subwindow
+        view = SiloStartView()
+        sw = mdi.addSubWindow(view)
+        sw.setWindowTitle("Start")
+        sw.setWindowIcon(QtGui.QIcon(":/icons/StartCommandIcon.svg"))
+        sw.show()
+        mdi.setActiveSubWindow(sw)
+
+    def GetResources(self):
+        return {
+            "MenuText": "&Start Page",
+            "ToolTip": "Displays the start page",
+            "Pixmap": "StartCommandIcon",
+        }
+
+    def IsActive(self):
+        return True
+
+
+def register():
+    """Override the Start_Start command with the Silo start page.
+
+    Call this from InitGui.py at module level so the override is in
+    place before the C++ StartLauncher fires (100ms after GUI init).
+    """
+    try:
+        FreeCADGui.addCommand("Start_Start", _SiloStartCommand())
+        FreeCAD.Console.PrintMessage("Silo Start: registered start page override\n")
+    except Exception as e:
+        FreeCAD.Console.PrintWarning(f"Silo Start: failed to register override: {e}\n")