Add row-level saved session actions and clarify library labels - PR 11.247

Author: DavidQ

docs/dev/reports/PR_11_247_saved_session_row_actions_report.md

@@ -0,0 +1,60 @@
+# PR_11_247 — Saved Session Row Actions + Clear Labels
+
+## Summary
+Implemented row-level Session Library actions so saved sessions are usable without copy/paste. Added explicit saved-vs-recent helper text and direct row controls for Copy ID, Use in Library, Load, and Delete Saved.
+
+## Files Changed
+- `tools/workspace-v2/index.html`
+- `tools/workspace-v2/index.js`
+- `tests/runtime/V2SavedSessionRowActions.test.mjs`
+
+## Implemented UI/Behavior
+- Updated helper text to:
+  - `Saved sessions are stored in Session Library. Recent sessions are temporary.`
+- Each saved library row now shows:
+  - readable label (`toolId` when available)
+  - full session ID
+  - `Copy ID`
+  - `Use in Library`
+  - `Load`
+  - `Delete Saved`
+- Row actions:
+  - `Use in Library` populates Session ID textbox.
+  - `Copy ID` copies exact saved session ID to clipboard.
+  - `Load` loads saved session directly and refreshes Session Library display.
+  - `Delete Saved` deletes only the saved library entry (no recent/sessionStorage deletion path).
+- Existing textbox actions are preserved:
+  - `Save Session`
+  - `Overwrite Session`
+  - `Load Session`
+  - `Delete Saved Session`
+- Existing library mutation path still recomputes Diff/Merge inventory via `writeSessionLibrary(...)`.
+
+## Validation Commands Run
+```powershell
+node --check tools/workspace-v2/index.js
+node --check tests/runtime/V2SavedSessionRowActions.test.mjs
+node tests/runtime/V2SavedSessionRowActions.test.mjs
+```
+
+## Validation Results
+- `node --check tools/workspace-v2/index.js` -> PASS
+- `node --check tests/runtime/V2SavedSessionRowActions.test.mjs` -> PASS
+- `node tests/runtime/V2SavedSessionRowActions.test.mjs` -> PASS
+  - output: `tmp/v2-saved-session-row-actions-results.json`
+  - failures: `[]`
+
+## Coverage Confirmed
+- saved rows expose Copy ID / Use in Library / Load / Delete Saved -> PASS
+- row Copy ID copies exact saved ID -> PASS
+- row Use in Library populates textbox -> PASS
+- row Load executes saved-session load path -> PASS
+- row Delete Saved removes saved entry only -> PASS
+- Recent Sessions unaffected by row Delete Saved -> PASS
+- textbox action methods remain present and wired -> PASS
+
+## Full Samples Smoke
+Skipped.
+
+Reason: PR scope is limited to Workspace V2 Session Library UI/action surface and targeted runtime validation. No schemas/samples/games/shared sample infrastructure changed.
+

tests/runtime/V2SavedSessionRowActions.test.mjs

@@ -0,0 +1,158 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = path.resolve(__dirname, "..", "..");
+const htmlPath = path.join(repoRoot, "tools", "workspace-v2", "index.html");
+const jsPath = path.join(repoRoot, "tools", "workspace-v2", "index.js");
+const resultsPath = path.join(repoRoot, "tmp", "v2-saved-session-row-actions-results.json");
+
+function readText(filePath) {
+  return fs.readFileSync(filePath, "utf8");
+}
+
+function checkSyntax(filePath) {
+  try {
+    execFileSync(process.execPath, ["--check", filePath], {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: (error?.stderr || error?.stdout || error?.message || "").toString().trim() };
+  }
+}
+
+function simulateDeleteSavedRow(sessionId, library, history, storage) {
+  const nextLibrary = { ...library };
+  const nextHistory = [...history];
+  const nextStorage = { ...storage };
+  if (Object.prototype.hasOwnProperty.call(nextLibrary, sessionId)) {
+    delete nextLibrary[sessionId];
+    return { message: "Saved session deleted.", nextLibrary, nextHistory, nextStorage };
+  }
+  return { message: "Saved session not found.", nextLibrary, nextHistory, nextStorage };
+}
+
+export function run() {
+  const failures = [];
+  const htmlExists = fs.existsSync(htmlPath);
+  const jsExists = fs.existsSync(jsPath);
+  const html = htmlExists ? readText(htmlPath) : "";
+  const js = jsExists ? readText(jsPath) : "";
+  const jsSyntax = checkSyntax(jsPath);
+  const testSyntax = checkSyntax(path.join(repoRoot, "tests", "runtime", "V2SavedSessionRowActions.test.mjs"));
+
+  if (!htmlExists) failures.push("Missing tools/workspace-v2/index.html.");
+  if (!jsExists) failures.push("Missing tools/workspace-v2/index.js.");
+  if (!jsSyntax.ok) failures.push("tools/workspace-v2/index.js failed syntax check.");
+  if (!testSyntax.ok) failures.push("tests/runtime/V2SavedSessionRowActions.test.mjs failed syntax check.");
+
+  if (!html.includes("Saved sessions are stored in Session Library. Recent sessions are temporary.")) {
+    failures.push("Helper text is not updated to saved-vs-recent clarification.");
+  }
+
+  const requiredRowTokens = [
+    "copyIdButton.textContent = \"Copy ID\";",
+    "useInLibraryButton.textContent = \"Use in Library\";",
+    "loadButton.textContent = \"Load\";",
+    "deleteSavedButton.textContent = \"Delete Saved\";",
+    "copySavedSessionIdToClipboard(sessionId)",
+    "useSavedSessionIdInLibraryInput(sessionId)",
+    "loadSavedSessionById(sessionId)",
+    "deleteSavedSessionById(sessionId)"
+  ];
+  requiredRowTokens.forEach((token) => {
+    if (!js.includes(token)) {
+      failures.push(`Missing required saved-row action token: ${token}`);
+    }
+  });
+
+  if (!js.includes("await navigator.clipboard.writeText(sessionId.trim());")) {
+    failures.push("Row Copy ID does not copy exact saved session ID.");
+  }
+  if (!js.includes("this.sessionNameNode.value = sessionId.trim();")) {
+    failures.push("Use in Library / row actions are not populating Session ID textbox.");
+  }
+  if (!js.includes("this.loadNamedSession();")) {
+    failures.push("Row Load is not wired to library load action.");
+  }
+  if (!js.includes("this.deleteNamedSession();")) {
+    failures.push("Row Delete Saved is not wired to library delete action.");
+  }
+  if (!js.includes("this.renderSessionLibrary();")) {
+    failures.push("Session Library refresh after row actions is missing.");
+  }
+  if (!js.includes("this.renderSessionDiffInputs();") || !js.includes("this.renderSessionMergeInputs();")) {
+    failures.push("Diff/Merge selector recompute hooks are missing.");
+  }
+
+  const library = {
+    "asset-browser-v2-1777676088718-3eff5h3y": { version: "v2", toolId: "asset-browser-v2", payloadJson: { a: 1 } },
+    "palette-manager-v2-1777676088720-abcd1234": { version: "v2", toolId: "palette-manager-v2", payloadJson: { b: 2 } }
+  };
+  const history = [{ hostContextId: "asset-browser-v2-1777676088718-3eff5h3y", tool: "asset-browser-v2", timestamp: "2026-05-01T00:00:00.000Z", payload: { version: "v2", toolId: "asset-browser-v2" } }];
+  const storage = { "asset-browser-v2-1777676088718-3eff5h3y": "{\"version\":\"v2\",\"toolId\":\"asset-browser-v2\"}" };
+
+  const deleted = simulateDeleteSavedRow("asset-browser-v2-1777676088718-3eff5h3y", library, history, storage);
+  if (deleted.message !== "Saved session deleted.") {
+    failures.push("Row Delete Saved should delete saved library entry.");
+  }
+  if (Object.prototype.hasOwnProperty.call(deleted.nextLibrary, "asset-browser-v2-1777676088718-3eff5h3y")) {
+    failures.push("Row Delete Saved did not remove saved entry.");
+  }
+  if (deleted.nextHistory.length !== history.length) {
+    failures.push("Row Delete Saved must not remove Recent Sessions.");
+  }
+  if (!Object.prototype.hasOwnProperty.call(deleted.nextStorage, "asset-browser-v2-1777676088718-3eff5h3y")) {
+    failures.push("Row Delete Saved must not remove sessionStorage payload.");
+  }
+
+  const textboxActionsStillPresent = [
+    "saveNamedSession(overwriteExisting)",
+    "loadNamedSession()",
+    "deleteNamedSession()",
+    "Saved session already exists. Use Overwrite Session.",
+    "Saved session not found.",
+    "Saved session loaded.",
+    "Saved session deleted."
+  ];
+  textboxActionsStillPresent.forEach((token) => {
+    if (!js.includes(token)) {
+      failures.push(`Textbox Session Library action token missing: ${token}`);
+    }
+  });
+
+  fs.mkdirSync(path.dirname(resultsPath), { recursive: true });
+  fs.writeFileSync(resultsPath, `${JSON.stringify({
+    generatedAt: new Date().toISOString(),
+    failures,
+    checks: {
+      htmlExists,
+      jsExists,
+      jsSyntax,
+      testSyntax
+    },
+    scenarios: {
+      deleted
+    }
+  }, null, 2)}\n`, "utf8");
+
+  console.log(`v2 saved-session-row-actions results: ${resultsPath}`);
+  assert.equal(failures.length, 0, `V2 saved-session-row-actions failures: ${failures.join(" | ")}`);
+  return { failures };
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  try {
+    const summary = run();
+    console.log(JSON.stringify(summary, null, 2));
+  } catch (error) {
+    console.error(error);
+    process.exitCode = 1;
+  }
+}

tools/workspace-v2/index.html

@@ -59,7 +59,7 @@ <h2>Share Session Link</h2>
         <h2>Session Library</h2>
         <label for="workspaceV2SessionName">Session ID (for Save / Load / Delete)</label>
         <input id="workspaceV2SessionName" type="text" placeholder="session-id" />
-        <p>Use a session ID from Recent Sessions or saved library.</p>
+        <p>Saved sessions are stored in Session Library. Recent sessions are temporary.</p>
         <div>
           <button id="workspaceV2SaveSessionButton" type="button">Save Session</button>
           <button id="workspaceV2OverwriteSessionButton" type="button">Overwrite Session</button>

tools/workspace-v2/index.js

@@ -434,19 +434,95 @@ class WorkspaceV2SessionProducer {
     this.libraryEmptyState.textContent = "No saved sessions in library.";
     sessionNames.forEach((sessionName) => {
       const item = document.createElement("li");
-      const button = document.createElement("button");
-      button.type = "button";
-      button.textContent = sessionName;
-      button.addEventListener("click", () => {
-        this.sessionNameNode.value = sessionName;
+      const payload = library[sessionName];
+      const label = document.createElement("strong");
+      const idLine = document.createElement("div");
+      const idLabel = document.createElement("span");
+      const idCode = document.createElement("code");
+      const copyIdButton = document.createElement("button");
+      const useInLibraryButton = document.createElement("button");
+      const loadButton = document.createElement("button");
+      const deleteSavedButton = document.createElement("button");
+      const readableLabel = payload && typeof payload.toolId === "string" && payload.toolId.trim()
+        ? payload.toolId.trim()
+        : "saved-session";
+      label.textContent = `${readableLabel} (${sessionName})`;
+      idLabel.textContent = "Session ID: ";
+      idCode.textContent = sessionName;
+      idCode.title = sessionName;
+      idLine.append(idLabel, idCode);
+      copyIdButton.type = "button";
+      copyIdButton.textContent = "Copy ID";
+      copyIdButton.addEventListener("click", () => {
+        this.copySavedSessionIdToClipboard(sessionName);
       });
-      item.appendChild(button);
+      useInLibraryButton.type = "button";
+      useInLibraryButton.textContent = "Use in Library";
+      useInLibraryButton.addEventListener("click", () => {
+        this.useSavedSessionIdInLibraryInput(sessionName);
+      });
+      loadButton.type = "button";
+      loadButton.textContent = "Load";
+      loadButton.addEventListener("click", () => {
+        this.loadSavedSessionById(sessionName);
+      });
+      deleteSavedButton.type = "button";
+      deleteSavedButton.textContent = "Delete Saved";
+      deleteSavedButton.addEventListener("click", () => {
+        this.deleteSavedSessionById(sessionName);
+      });
+      item.append(label, idLine, copyIdButton, useInLibraryButton, loadButton, deleteSavedButton);
       this.sessionListNode.appendChild(item);
     });
     this.renderSessionDiffInputs();
     this.renderSessionMergeInputs();
   }
 
+  async copySavedSessionIdToClipboard(sessionId) {
+    if (typeof sessionId !== "string" || !sessionId.trim()) {
+      this.setLibraryStatus("Copy ID failed: saved session ID is missing.");
+      return;
+    }
+    try {
+      if (!navigator.clipboard || typeof navigator.clipboard.writeText !== "function") {
+        this.setLibraryStatus("Copy ID is unavailable in this browser context.");
+        return;
+      }
+      await navigator.clipboard.writeText(sessionId.trim());
+      this.setLibraryStatus(`Saved session ID copied: ${sessionId.trim()}`);
+    } catch (error) {
+      this.setLibraryStatus(`Copy ID failed: ${error instanceof Error ? error.message : "unknown error"}`);
+    }
+  }
+
+  useSavedSessionIdInLibraryInput(sessionId) {
+    if (typeof sessionId !== "string" || !sessionId.trim()) {
+      this.setLibraryStatus("Use in Library failed: saved session ID is missing.");
+      return;
+    }
+    this.sessionNameNode.value = sessionId.trim();
+    this.setLibraryStatus(`Saved session ID ready for Library actions: ${sessionId.trim()}`);
+  }
+
+  loadSavedSessionById(sessionId) {
+    if (typeof sessionId !== "string" || !sessionId.trim()) {
+      this.setLibraryStatus("Enter a saved session ID before loading.");
+      return;
+    }
+    this.sessionNameNode.value = sessionId.trim();
+    this.loadNamedSession();
+    this.renderSessionLibrary();
+  }
+
+  deleteSavedSessionById(sessionId) {
+    if (typeof sessionId !== "string" || !sessionId.trim()) {
+      this.setLibraryStatus("Enter a saved session ID before deleting.");
+      return;
+    }
+    this.sessionNameNode.value = sessionId.trim();
+    this.deleteNamedSession();
+  }
+
   isValidSessionHistoryEntry(entry) {
     if (!entry || typeof entry !== "object" || Array.isArray(entry)) return false;
     if (typeof entry.hostContextId !== "string" || !entry.hostContextId.trim()) return false;