codex-autorunner 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

codex_autorunner/routes/workspace.py

@@ -1,271 +1,3 @@
-from __future__ import annotations
+"""Backward-compatible workspace routes."""
 
-import io
-import zipfile
-from dataclasses import asdict
-
-from fastapi import APIRouter, File, Form, HTTPException, Request, UploadFile
-from fastapi.responses import FileResponse, PlainTextResponse, StreamingResponse
-
-from ..core import drafts as draft_utils
-from ..tickets.spec_ingest import (
-    SpecIngestTicketsError,
-    ingest_workspace_spec_to_tickets,
-)
-from ..web.schemas import (
-    SpecIngestTicketsResponse,
-    WorkspaceFileListResponse,
-    WorkspaceResponse,
-    WorkspaceTreeResponse,
-    WorkspaceUploadResponse,
-    WorkspaceWriteRequest,
-)
-from ..workspace.paths import (
-    PINNED_DOC_FILENAMES,
-    WORKSPACE_DOC_KINDS,
-    list_workspace_files,
-    list_workspace_tree,
-    normalize_workspace_rel_path,
-    read_workspace_doc,
-    read_workspace_file,
-    sanitize_workspace_filename,
-    workspace_dir,
-    workspace_doc_path,
-    write_workspace_doc,
-    write_workspace_file,
-)
-
-
-def build_workspace_routes() -> APIRouter:
-    router = APIRouter(prefix="/api", tags=["workspace"])
-
-    @router.get("/workspace", response_model=WorkspaceResponse)
-    def get_workspace(request: Request):
-        repo_root = request.app.state.engine.repo_root
-        return {
-            "active_context": read_workspace_doc(repo_root, "active_context"),
-            "decisions": read_workspace_doc(repo_root, "decisions"),
-            "spec": read_workspace_doc(repo_root, "spec"),
-        }
-
-    @router.get("/workspace/file", response_class=PlainTextResponse)
-    def read_workspace(request: Request, path: str):
-        repo_root = request.app.state.engine.repo_root
-        try:
-            content = read_workspace_file(repo_root, path)
-        except ValueError as exc:  # invalid path
-            raise HTTPException(status_code=400, detail=str(exc)) from exc
-        return PlainTextResponse(content)
-
-    @router.put("/workspace/file", response_class=PlainTextResponse)
-    def write_workspace(request: Request, payload: WorkspaceWriteRequest, path: str):
-        repo_root = request.app.state.engine.repo_root
-        try:
-            # Normalize path the same way workspace helpers do to avoid traversal
-            safe_path, rel_posix = normalize_workspace_rel_path(repo_root, path)
-            content = write_workspace_file(repo_root, path, payload.content)
-            try:
-                rel_repo_path = safe_path.relative_to(repo_root).as_posix()
-                draft_utils.invalidate_drafts_for_path(repo_root, rel_repo_path)
-                state_key = f"workspace_{rel_posix.replace('/', '_')}"
-                draft_utils.remove_draft(repo_root, state_key)
-            except Exception:
-                pass
-        except ValueError as exc:
-            raise HTTPException(status_code=400, detail=str(exc)) from exc
-        return PlainTextResponse(content)
-
-    @router.put("/workspace/{kind}", response_model=WorkspaceResponse)
-    def put_workspace(kind: str, payload: WorkspaceWriteRequest, request: Request):
-        key = (kind or "").strip().lower()
-        if key not in WORKSPACE_DOC_KINDS:
-            raise HTTPException(status_code=400, detail="invalid workspace doc kind")
-        repo_root = request.app.state.engine.repo_root
-        write_workspace_doc(repo_root, key, payload.content)
-        try:
-            rel_path = workspace_doc_path(repo_root, key).relative_to(repo_root)
-            draft_utils.invalidate_drafts_for_path(repo_root, rel_path.as_posix())
-            state_key = f"workspace_{rel_path.name}"
-            draft_utils.remove_draft(repo_root, state_key)
-        except Exception:
-            # best-effort invalidation; avoid blocking writes
-            pass
-        return {
-            "active_context": read_workspace_doc(repo_root, "active_context"),
-            "decisions": read_workspace_doc(repo_root, "decisions"),
-            "spec": read_workspace_doc(repo_root, "spec"),
-        }
-
-    @router.get("/workspace/files", response_model=WorkspaceFileListResponse)
-    def list_files(request: Request):
-        repo_root = request.app.state.engine.repo_root
-        files = [asdict(item) for item in list_workspace_files(repo_root)]
-        return {"files": files}
-
-    @router.get("/workspace/tree", response_model=WorkspaceTreeResponse)
-    def get_workspace_tree(request: Request):
-        repo_root = request.app.state.engine.repo_root
-        tree = [asdict(item) for item in list_workspace_tree(repo_root)]
-        return {"tree": tree}
-
-    @router.post("/workspace/upload", response_model=WorkspaceUploadResponse)
-    async def upload_workspace_files(
-        request: Request,
-        files: list[UploadFile] = File(...),  # noqa: B008
-        subdir: str = Form(""),
-    ):
-        if not files:
-            raise HTTPException(status_code=400, detail="no files provided")
-
-        repo_root = request.app.state.engine.repo_root
-        base = workspace_dir(repo_root)
-        target_dir = base
-        if subdir:
-            try:
-                target_dir, _ = normalize_workspace_rel_path(repo_root, subdir)
-            except ValueError as exc:
-                raise HTTPException(status_code=400, detail=str(exc)) from exc
-
-        target_dir.mkdir(parents=True, exist_ok=True)
-
-        uploaded: list[dict[str, str | int]] = []
-        for upload in files:
-            filename = sanitize_workspace_filename(upload.filename or "")
-            try:
-                data = await upload.read()
-            except (
-                Exception
-            ) as exc:  # pragma: no cover - handled by FastAPI for most cases
-                raise HTTPException(
-                    status_code=400, detail="failed to read upload"
-                ) from exc
-
-            dest = target_dir / filename
-            dest.write_bytes(
-                data
-            )  # codeql[py/path-injection] dest sits under normalized workspace dir
-            rel_path = dest.relative_to(base).as_posix()
-            uploaded.append({"filename": filename, "path": rel_path, "size": len(data)})
-
-        return {"status": "ok", "uploaded": uploaded}
-
-    @router.get("/workspace/download")
-    async def download_workspace_file(request: Request, path: str):
-        repo_root = request.app.state.engine.repo_root
-        try:
-            safe_path, _ = normalize_workspace_rel_path(repo_root, path)
-        except ValueError as exc:
-            raise HTTPException(status_code=400, detail=str(exc)) from exc
-
-        if not safe_path.exists() or safe_path.is_dir():
-            raise HTTPException(status_code=404, detail="file not found")
-
-        return FileResponse(
-            path=safe_path, filename=safe_path.name
-        )  # codeql[py/path-injection] safe_path validated by normalize_workspace_rel_path
-
-    @router.get("/workspace/download-zip")
-    async def download_workspace_zip(request: Request, path: str = ""):
-        repo_root = request.app.state.engine.repo_root
-        base = workspace_dir(repo_root)
-        base.mkdir(parents=True, exist_ok=True)
-
-        target_dir = base
-        zip_name = "workspace.zip"
-        if path:
-            try:
-                target_dir, _ = normalize_workspace_rel_path(repo_root, path)
-            except ValueError as exc:
-                raise HTTPException(status_code=400, detail=str(exc)) from exc
-            if not target_dir.exists() or not target_dir.is_dir():
-                raise HTTPException(status_code=404, detail="folder not found")
-            zip_name = f"{target_dir.name}.zip"
-
-        buffer = io.BytesIO()
-        base_real = base.resolve()
-        with zipfile.ZipFile(buffer, "w", zipfile.ZIP_DEFLATED) as zf:
-            for file_path in target_dir.rglob("*"):
-                if file_path.is_dir():
-                    continue
-                if file_path.is_symlink():
-                    try:
-                        file_path.resolve().relative_to(base_real)
-                    except Exception:
-                        continue
-                arc_name = file_path.relative_to(target_dir).as_posix()
-                zf.write(
-                    file_path, arc_name
-                )  # codeql[py/path-injection] file_path constrained to workspace dir
-
-        buffer.seek(0)
-        return StreamingResponse(
-            buffer,
-            media_type="application/zip",
-            headers={"Content-Disposition": f'attachment; filename="{zip_name}"'},
-        )
-
-    @router.post("/workspace/folder")
-    async def create_workspace_folder(request: Request, path: str):
-        repo_root = request.app.state.engine.repo_root
-        try:
-            safe_path, rel_posix = normalize_workspace_rel_path(repo_root, path)
-        except ValueError as exc:
-            raise HTTPException(status_code=400, detail=str(exc)) from exc
-
-        if safe_path.exists():
-            raise HTTPException(status_code=400, detail="path already exists")
-
-        safe_path.mkdir(parents=True, exist_ok=True)
-        return {"status": "created", "path": rel_posix}
-
-    @router.delete("/workspace/folder")
-    async def delete_workspace_folder(request: Request, path: str):
-        repo_root = request.app.state.engine.repo_root
-        try:
-            safe_path, rel_posix = normalize_workspace_rel_path(repo_root, path)
-        except ValueError as exc:
-            raise HTTPException(status_code=400, detail=str(exc)) from exc
-
-        if not safe_path.exists():
-            raise HTTPException(status_code=404, detail="folder not found")
-        if not safe_path.is_dir():
-            raise HTTPException(status_code=400, detail="not a folder")
-        if any(safe_path.iterdir()):
-            raise HTTPException(status_code=400, detail="folder not empty")
-
-        safe_path.rmdir()
-        return {"status": "deleted", "path": rel_posix}
-
-    @router.delete("/workspace/file")
-    async def delete_workspace_file(request: Request, path: str):
-        repo_root = request.app.state.engine.repo_root
-        base = workspace_dir(repo_root)
-        try:
-            safe_path, rel_posix = normalize_workspace_rel_path(repo_root, path)
-        except ValueError as exc:
-            raise HTTPException(status_code=400, detail=str(exc)) from exc
-
-        if safe_path.parent == base and safe_path.name in PINNED_DOC_FILENAMES:
-            raise HTTPException(status_code=400, detail="cannot delete pinned docs")
-        if not safe_path.exists():
-            raise HTTPException(status_code=404, detail="file not found")
-        if safe_path.is_dir():
-            raise HTTPException(status_code=400, detail="use folder delete endpoint")
-
-        safe_path.unlink()  # codeql[py/path-injection] safe_path validated by normalize_workspace_rel_path
-        return {"status": "deleted", "path": rel_posix}
-
-    @router.post("/workspace/spec/ingest", response_model=SpecIngestTicketsResponse)
-    def ingest_workspace_spec(request: Request):
-        repo_root = request.app.state.engine.repo_root
-        try:
-            result = ingest_workspace_spec_to_tickets(repo_root)
-        except SpecIngestTicketsError as exc:
-            raise HTTPException(status_code=400, detail=str(exc)) from exc
-        return {
-            "status": "ok",
-            "created": result.created,
-            "first_ticket_path": result.first_ticket_path,
-        }
-
-    return router
+from ..surfaces.web.routes.workspace import *  # noqa: F401,F403

codex_autorunner/server.py

@@ -1,12 +1,12 @@
 from importlib import resources
 
-from .core.engine import Engine, LockError, clear_stale_lock, doctor
-from .web.app import create_app, create_hub_app, create_repo_app
-from .web.middleware import BasePathRouterMiddleware
+from .core.runtime import LockError, RuntimeContext, clear_stale_lock, doctor
+from .surfaces.web.app import create_app, create_hub_app, create_repo_app
+from .surfaces.web.middleware import BasePathRouterMiddleware
 
 __all__ = [
-    "Engine",
     "LockError",
+    "RuntimeContext",
     "BasePathRouterMiddleware",
     "clear_stale_lock",
     "create_app",

codex_autorunner/static/agentControls.js

@@ -1,9 +1,13 @@
 // GENERATED FILE - do not edit directly. Source: static_src/
 import { api, flash } from "./utils.js";
+import { createSmartRefresh } from "./smartRefresh.js";
+import { REPO_ID } from "./env.js";
+const API_PREFIX = REPO_ID ? "/api" : "/hub/pma";
+const STORAGE_PREFIX = REPO_ID ? "car.agent" : "car.pma.agent";
 const STORAGE_KEYS = {
-    selected: "car.agent.selected",
-    model: (agent) => `car.agent.${agent}.model`,
-    reasoning: (agent) => `car.agent.${agent}.reasoning`,
+    selected: `${STORAGE_PREFIX}.selected`,
+    model: (agent) => `${STORAGE_PREFIX}.${agent}.model`,
+    reasoning: (agent) => `${STORAGE_PREFIX}.${agent}.reasoning`,
 };
 const FALLBACK_AGENTS = [
     { id: "codex", name: "Codex" },
@@ -15,6 +19,22 @@ let agentList = [...FALLBACK_AGENTS];
 let defaultAgent = "codex";
 const modelCatalogs = new Map();
 const modelCatalogPromises = new Map();
+const agentControlsRefresh = createSmartRefresh({
+    getSignature: (payload) => {
+        const agentsSig = payload.agents
+            .map((agent) => `${agent.id}:${agent.name || ""}:${agent.version || ""}:${agent.protocol_version || ""}`)
+            .join("|");
+        const catalogSig = payload.catalog
+            ? `${payload.catalog.default_model || ""}:${payload.catalog.models
+                .map((model) => `${model.id}:${model.display_name || ""}:${model.supports_reasoning ? "1" : "0"}:${model.reasoning_options.join(",")}`)
+                .join("|")}`
+            : "none";
+        return `${agentsSig}::${payload.defaultAgent}::${catalogSig}`;
+    },
+    render: (payload) => {
+        renderAgentControls(payload);
+    },
+});
 function safeGetStorage(key) {
     try {
         return localStorage.getItem(key);
@@ -75,7 +95,7 @@ async function loadAgents() {
     }
     agentsLoadPromise = (async () => {
         try {
-            const data = await api("/api/agents", { method: "GET" });
+            const data = await api(`${API_PREFIX}/agents`, { method: "GET" });
             const agents = Array.isArray(data?.agents) ? data.agents : [];
             // Only use API response if it contains valid agents
             if (agents.length > 0 && agents.every((a) => a && typeof a.id === "string")) {
@@ -135,7 +155,7 @@ async function loadModelCatalog(agent) {
     if (modelCatalogPromises.has(agent)) {
         return await modelCatalogPromises.get(agent) || null;
     }
-    const promise = api(`/api/agents/${encodeURIComponent(agent)}/models`, {
+    const promise = api(`${API_PREFIX}/agents/${encodeURIComponent(agent)}/models`, {
         method: "GET",
     })
         .then((data) => {
@@ -242,7 +262,7 @@ function resolveSelectedReasoning(agent, model) {
     }
     return model.reasoning_options[0] || "";
 }
-async function refreshControls() {
+async function loadAgentControlsPayload() {
     try {
         await loadAgents();
     }
@@ -251,11 +271,6 @@ async function refreshControls() {
         ensureFallbackAgents();
     }
     const selectedAgent = getSelectedAgent();
-    // Always update agent options first (uses in-memory agentList)
-    controls.forEach((control) => {
-        ensureAgentOptions(control.agentSelect);
-    });
-    // Then try to load model catalog
     let catalog = modelCatalogs.get(selectedAgent);
     if (!catalog) {
         try {
@@ -266,6 +281,20 @@ async function refreshControls() {
             catalog = null;
         }
     }
+    return {
+        agents: [...agentList],
+        defaultAgent,
+        selectedAgent,
+        catalog: catalog || null,
+    };
+}
+function renderAgentControls(payload) {
+    const selectedAgent = payload.selectedAgent;
+    // Always update agent options first (uses in-memory agentList)
+    controls.forEach((control) => {
+        ensureAgentOptions(control.agentSelect);
+    });
+    const catalog = payload.catalog;
     // Update model and reasoning options
     controls.forEach((control) => {
         ensureModelOptions(control.modelSelect, catalog);
@@ -288,6 +317,9 @@ async function refreshControls() {
         }
     });
 }
+export async function refreshAgentControls(request = {}) {
+    await agentControlsRefresh.refresh(loadAgentControlsPayload, request);
+}
 async function handleAgentChange(nextAgent) {
     const previous = getSelectedAgent();
     setSelectedAgent(nextAgent);
@@ -298,17 +330,17 @@ async function handleAgentChange(nextAgent) {
         setSelectedAgent(previous);
         flash(`Failed to load ${getLabelText(nextAgent)} models; staying on ${getLabelText(previous)}.`, "error");
     }
-    await refreshControls();
+    await refreshAgentControls({ force: true, reason: "manual" });
 }
 async function handleModelChange(nextModel) {
     const agent = getSelectedAgent();
     setSelectedModel(agent, nextModel);
-    await refreshControls();
+    await refreshAgentControls({ force: true, reason: "manual" });
 }
 async function handleReasoningChange(nextReasoning) {
     const agent = getSelectedAgent();
     setSelectedReasoning(agent, nextReasoning);
-    await refreshControls();
+    await refreshAgentControls({ force: true, reason: "manual" });
 }
 /**
  * @param {AgentControlConfig} [config]
@@ -343,10 +375,23 @@ export function initAgentControls(config = {}) {
         });
     }
     // Async refresh to load from API (will update if API returns different data)
-    refreshControls().catch((err) => {
+    refreshAgentControls({ force: true, reason: "initial" }).catch((err) => {
         console.warn("Failed to refresh agent controls", err);
     });
 }
 export async function ensureAgentCatalog() {
-    await refreshControls();
+    await refreshAgentControls({ force: true, reason: "manual" });
+}
+export function clearAgentSelectionStorage() {
+    if (REPO_ID)
+        return;
+    safeSetStorage(STORAGE_KEYS.selected, "");
+    const candidates = new Set([
+        ...agentList.map((agent) => agent.id),
+        ...FALLBACK_AGENTS.map((agent) => agent.id),
+    ]);
+    candidates.forEach((agentId) => {
+        safeSetStorage(STORAGE_KEYS.model(agentId), "");
+        safeSetStorage(STORAGE_KEYS.reasoning(agentId), "");
+    });
 }

codex_autorunner/static/app.js

@@ -1,18 +1,122 @@
 // GENERATED FILE - do not edit directly. Source: static_src/
 import { REPO_ID, HUB_BASE } from "./env.js";
 import { initHub } from "./hub.js";
-import { initTabs, registerTab } from "./tabs.js";
+import { initTabs, registerTab, registerHamburgerAction } from "./tabs.js";
 import { initTerminal } from "./terminal.js";
 import { initTicketFlow } from "./tickets.js";
 import { initMessages, initMessageBell } from "./messages.js";
 import { initMobileCompact } from "./mobileCompact.js";
 import { subscribe } from "./bus.js";
-import { initRepoSettingsPanel } from "./settings.js";
-import { flash } from "./utils.js";
+import { initRepoSettingsPanel, openRepoSettings } from "./settings.js";
+import { flash, getAuthToken, repairModalBackgroundIfStuck, resolvePath, updateUrlParams, } from "./utils.js";
 import { initLiveUpdates } from "./liveUpdates.js";
 import { initHealthGate } from "./health.js";
 import { initWorkspace } from "./workspace.js";
 import { initDashboard } from "./dashboard.js";
+import { initArchive } from "./archive.js";
+import { initPMA } from "./pma.js";
+import { initNotifications } from "./notifications.js";
+let pmaInitialized = false;
+async function initPMAView() {
+    if (!pmaInitialized) {
+        await initPMA();
+        pmaInitialized = true;
+    }
+}
+function showHubView() {
+    const hubShell = document.getElementById("hub-shell");
+    const pmaShell = document.getElementById("pma-shell");
+    if (hubShell)
+        hubShell.classList.remove("hidden");
+    if (pmaShell)
+        pmaShell.classList.add("hidden");
+    updateModeToggle("manual");
+    updateUrlParams({ view: null });
+}
+function showPMAView() {
+    const hubShell = document.getElementById("hub-shell");
+    const pmaShell = document.getElementById("pma-shell");
+    if (hubShell)
+        hubShell.classList.add("hidden");
+    if (pmaShell)
+        pmaShell.classList.remove("hidden");
+    updateModeToggle("pma");
+    void initPMAView();
+    updateUrlParams({ view: "pma" });
+}
+function updateModeToggle(mode) {
+    const manualBtns = document.querySelectorAll('[data-hub-mode="manual"]');
+    const pmaBtns = document.querySelectorAll('[data-hub-mode="pma"]');
+    manualBtns.forEach((btn) => {
+        const active = mode === "manual";
+        btn.classList.toggle("active", active);
+        btn.setAttribute("aria-selected", active ? "true" : "false");
+    });
+    pmaBtns.forEach((btn) => {
+        const active = mode === "pma";
+        btn.classList.toggle("active", active);
+        btn.setAttribute("aria-selected", active ? "true" : "false");
+    });
+}
+async function probePMAEnabled() {
+    const headers = {};
+    const token = getAuthToken();
+    if (token) {
+        headers.Authorization = `Bearer ${token}`;
+    }
+    try {
+        const res = await fetch(resolvePath("/hub/pma/agents"), {
+            method: "GET",
+            headers,
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function initHubShell() {
+    const hubShell = document.getElementById("hub-shell");
+    const repoShell = document.getElementById("repo-shell");
+    const manualBtns = Array.from(document.querySelectorAll('[data-hub-mode="manual"]'));
+    const pmaBtns = Array.from(document.querySelectorAll('[data-hub-mode="pma"]'));
+    if (hubShell)
+        hubShell.classList.remove("hidden");
+    if (repoShell)
+        repoShell.classList.add("hidden");
+    initHub();
+    initNotifications();
+    manualBtns.forEach((btn) => {
+        btn.addEventListener("click", () => {
+            showHubView();
+        });
+    });
+    pmaBtns.forEach((btn) => {
+        btn.addEventListener("click", () => {
+            showPMAView();
+        });
+    });
+    const urlParams = new URLSearchParams(window.location.search);
+    const requestedPMA = urlParams.get("view") === "pma";
+    const pmaEnabled = await probePMAEnabled();
+    if (!pmaEnabled) {
+        pmaBtns.forEach((btn) => {
+            btn.disabled = true;
+            btn.setAttribute("aria-disabled", "true");
+            btn.title = "Enable PMA in config to use Project Manager";
+            btn.classList.add("hidden");
+            btn.classList.remove("active");
+            btn.setAttribute("aria-selected", "false");
+        });
+        if (requestedPMA) {
+            showHubView();
+        }
+        return;
+    }
+    if (requestedPMA) {
+        showPMAView();
+    }
+}
 async function initRepoShell() {
     await initHealthGate();
     if (REPO_ID) {
@@ -36,9 +140,13 @@ async function initRepoShell() {
     const defaultTab = REPO_ID ? "tickets" : "analytics";
     registerTab("tickets", "Tickets");
     registerTab("inbox", "Inbox");
-    registerTab("analytics", "Analytics");
     registerTab("workspace", "Workspace");
     registerTab("terminal", "Terminal");
+    // Menu tabs (shown in hamburger menu)
+    registerTab("analytics", "Analytics", { menuTab: true, icon: "📊" });
+    registerTab("archive", "Archive", { menuTab: true, icon: "📦" });
+    // Settings action in hamburger menu
+    registerHamburgerAction("settings", "Settings", "⚙", () => openRepoSettings());
     const initializedTabs = new Set();
     const lazyInit = (tabId) => {
         if (initializedTabs.has(tabId))
@@ -52,6 +160,9 @@ async function initRepoShell() {
         else if (tabId === "analytics") {
             initDashboard();
         }
+        else if (tabId === "archive") {
+            initArchive();
+        }
         else if (tabId === "tickets") {
             initTicketFlow();
         }
@@ -80,22 +191,23 @@ async function initRepoShell() {
     if (repoShell?.hasAttribute("inert")) {
         const openModals = document.querySelectorAll(".modal-overlay:not([hidden])");
         const count = openModals.length;
-        flash(count
-            ? `UI inert: ${count} modal${count === 1 ? "" : "s"} open`
-            : "UI inert but no modal is visible", "error");
+        if (!count && repairModalBackgroundIfStuck()) {
+            flash("Recovered from stuck modal state (UI was inert).", "info");
+        }
+        else {
+            flash(count
+                ? `UI inert: ${count} modal${count === 1 ? "" : "s"} open`
+                : "UI inert but no modal is visible", "error");
+        }
     }
 }
 function bootstrap() {
-    const hubShell = document.getElementById("hub-shell");
-    const repoShell = document.getElementById("repo-shell");
     if (!REPO_ID) {
-        if (hubShell)
-            hubShell.classList.remove("hidden");
-        if (repoShell)
-            repoShell.classList.add("hidden");
-        initHub();
+        void initHubShell();
         return;
     }
+    const hubShell = document.getElementById("hub-shell");
+    const repoShell = document.getElementById("repo-shell");
     if (repoShell)
         repoShell.classList.remove("hidden");
     if (hubShell)