add: publish personal notebooks to global

Author: righel

api/app/repositories/lab.py

@@ -283,29 +283,53 @@ def clear_outputs(
 
 
 def fork_notebook(
-    db: Session, notebook_id: int, current_user_id: int
+    db: Session,
+    notebook_id: int,
+    current_user_id: int,
+    target_visibility: str = "personal",
 ) -> Optional[lab_models.LabNotebook]:
-    """Duplicate a visible notebook into a new personal one owned by the current user.
+    """Duplicate a visible notebook into a new one owned by the current user.
+
+    ``target_visibility`` selects where the copy lands:
 
-    Cell ids inside ``source`` are regenerated so the original and the fork
+    - ``"personal"`` (default) — the classic "fork to a private copy" flow,
+      used when readers want to mutate / execute a library or shared notebook.
+    - ``"global"`` — "publish to global" flow, used by an owner to share their
+      personal notebook with the rest of the workbench. Library notebooks
+      cannot be published this way (use the CLI seeder instead).
+
+    Cell ids inside ``source`` are regenerated so the original and the copy
     can be open simultaneously without execution conflicts; ``cell_outputs``
     is rewritten to use the new ids.
     """
+    if target_visibility not in ("personal", "global"):
+        raise ValueError("target_visibility must be 'personal' or 'global'")
+
     src = get_notebook_by_id(db, notebook_id, current_user_id)
     if src is None:
         return None
 
+    if target_visibility == "global" and src.visibility == "library":
+        raise ValueError(
+            "library notebooks cannot be published to global; seed via CLI"
+        )
+
     new_source, id_map = _regenerate_cell_ids(src.source or "")
     new_outputs: dict[str, list[dict]] = {}
     for old_id, new_id in id_map.items():
         if old_id in (src.cell_outputs or {}):
             new_outputs[new_id] = src.cell_outputs[old_id]
 
+    # Personal forks keep the "(fork)" suffix so the tree disambiguates them
+    # from the source. Global publishes keep the original name — they're the
+    # canonical shared copy.
+    name = src.name if target_visibility == "global" else f"{src.name} (fork)"
+
     fork = lab_models.LabNotebook(
         user_id=current_user_id,
         folder_id=None,
-        visibility="personal",
-        name=f"{src.name} (fork)",
+        visibility=target_visibility,
+        name=name,
         description=src.description,
         source=new_source,
         cell_outputs=new_outputs,

api/app/routers/lab.py

@@ -7,6 +7,7 @@
 """
 
 import json
+from typing import Literal
 
 from fastapi import (
     APIRouter,
@@ -222,10 +223,16 @@ async def clear_outputs(
 )
 async def fork_notebook(
     notebook_id: int,
+    visibility: Literal["personal", "global"] = "personal",
     db: Session = Depends(get_db),
     user: user_schemas.User = Security(get_current_active_user, scopes=["lab:create"]),
 ):
-    nb = lab_repository.fork_notebook(db, notebook_id, current_user_id=user.id)
+    try:
+        nb = lab_repository.fork_notebook(
+            db, notebook_id, current_user_id=user.id, target_visibility=visibility
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
     if nb is None:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND, detail="Notebook not found"

api/app/tests/api/test_lab.py

@@ -361,6 +361,68 @@ def test_fork_global_notebook_creates_personal_copy(
         assert "aaaa1111-aaaa-aaaa-aaaa-aaaaaaaaaaaa" not in data["source"]
         assert "[id=" in data["source"]
 
+    @pytest.mark.parametrize("scopes", [["lab:create"]])
+    def test_publish_personal_to_global_creates_global_copy(
+        self,
+        client: TestClient,
+        db: Session,
+        api_tester_user: user_models.User,
+        auth_token: auth.Token,
+    ):
+        original_source = (
+            "# %% [id=aaaa2222-aaaa-aaaa-aaaa-aaaaaaaaaaaa] code\n"
+            "y = 2\n"
+        )
+        nb = lab_repository.create_notebook(
+            db,
+            lab_schemas.LabNotebookCreate(
+                name="shareable",
+                visibility="personal",
+                source=original_source,
+            ),
+            current_user_id=api_tester_user.id,
+        )
+        response = client.post(
+            f"/tech-lab/notebooks/{nb.id}/fork?visibility=global",
+            headers={"Authorization": "Bearer " + auth_token},
+        )
+        assert response.status_code == status.HTTP_201_CREATED, response.text
+        data = response.json()
+        assert data["user_id"] == api_tester_user.id
+        assert data["visibility"] == "global"
+        # Global publish keeps the original name (no "(fork)" suffix).
+        assert data["name"] == "shareable"
+        assert data["folder_id"] is None
+        assert "aaaa2222-aaaa-aaaa-aaaa-aaaaaaaaaaaa" not in data["source"]
+        assert "[id=" in data["source"]
+        # Personal original is untouched.
+        db.refresh(nb)
+        assert nb.visibility == "personal"
+
+    @pytest.mark.parametrize("scopes", [["lab:create"]])
+    def test_publish_library_to_global_rejected(
+        self,
+        client: TestClient,
+        db: Session,
+        api_tester_user: user_models.User,
+        auth_token: auth.Token,
+    ):
+        nb = lab_repository.create_notebook(
+            db,
+            lab_schemas.LabNotebookCreate(
+                name="lib-thing",
+                visibility="library",
+                source="# %% code\nprint('hi')\n",
+            ),
+            current_user_id=api_tester_user.id,
+            via_api=False,
+        )
+        response = client.post(
+            f"/tech-lab/notebooks/{nb.id}/fork?visibility=global",
+            headers={"Authorization": "Bearer " + auth_token},
+        )
+        assert response.status_code == status.HTTP_400_BAD_REQUEST
+
 
 class TestLabExecution(ApiTester):
     """Execute-flow tests with the celery task stubbed to a synchronous runner."""

frontend/src/components/notebooks/NotebookEditor.vue

@@ -22,6 +22,7 @@ import {
   faBroom,
   faPlus,
   faFileLines,
+  faGlobe,
 } from "@fortawesome/free-solid-svg-icons";
 import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
 import KernelStatusPill from "./KernelStatusPill.vue";
@@ -450,6 +451,26 @@ async function fork() {
   }
 }
 
+async function publishToGlobal() {
+  if (!currentNotebook.value) return;
+  if (
+    !confirm(
+      "Create a global copy of this notebook? Everyone in the workbench will be able to view and fork it. The personal original stays put.",
+    )
+  )
+    return;
+  try {
+    const gnb = await notebooksStore.forkNotebook(
+      currentNotebook.value.id,
+      "global",
+    );
+    toastsStore.push(`Published "${gnb.name}" to Global.`, "success");
+    emit("select-notebook", gnb);
+  } catch (err) {
+    toastsStore.push(`Publish failed: ${err?.message || err}`, "danger");
+  }
+}
+
 async function exportIpynb() {
   if (!currentNotebook.value) return;
   await flushSave(currentNotebook.value.id);
@@ -617,6 +638,15 @@ const saveLabel = computed(() => {
             <FontAwesomeIcon :icon="faCodeBranch" class="me-1" />
             Fork to personal
           </button>
+          <button
+            v-if="isOwner && currentNotebook.visibility === 'personal'"
+            class="btn btn-outline-info btn-sm"
+            @click="publishToGlobal"
+            title="Create a global copy others can view and fork"
+          >
+            <FontAwesomeIcon :icon="faGlobe" class="me-1" />
+            Publish to global
+          </button>
         </div>
       </template>
       <template v-else>

frontend/src/stores/notebooks.store.js

@@ -108,13 +108,14 @@ export const useNotebooksStore = defineStore({
       delete this.saveStatus[id];
       await this.loadTree();
     },
-    async forkNotebook(id) {
+    async forkNotebook(id, visibility = "personal") {
       this.status.forking = true;
       try {
-        const nb = await fetchWrapper.post(
-          `${baseUrl}/notebooks/${id}/fork`,
-          {},
-        );
+        const url =
+          visibility === "personal"
+            ? `${baseUrl}/notebooks/${id}/fork`
+            : `${baseUrl}/notebooks/${id}/fork?visibility=${encodeURIComponent(visibility)}`;
+        const nb = await fetchWrapper.post(url, {});
         this.notebooks[nb.id] = nb;
         await this.loadTree();
         return nb;