pinokiod 8.0.13 → 8.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "8.0.13",
+  "version": "8.0.14",
   "description": "",
   "main": "index.js",
   "scripts": {

package/server/index.js

@@ -16619,6 +16619,7 @@ class Server {
     this.app.post("/pinokio/install", ex((req, res) => {
       req.session.requirements = req.body.requirements
       req.session.callback = req.body.callback
+      req.session.fresh = req.body.fresh === "1"
       res.redirect("/pinokio/install")
     }))
     this.app.post("/pinokio/install/validate", ex(async (req, res) => {
@@ -16630,8 +16631,10 @@ class Server {
       res.set("Cache-Control", "no-store")
       let requirements = req.session.requirements
       let callback = req.session.callback
+      let fresh = req.session.fresh === true
       req.session.requirements = null
       req.session.callback = null
+      req.session.fresh = null
       res.render("install", {
         logo: this.logo,
         theme: this.theme,
@@ -16640,7 +16643,8 @@ class Server {
         display: ["form"],
 //        query: req.query,
         requirements,
-        callback
+        callback,
+        fresh,
       })
     }))
     this.app.get("/pinokio", ex((req, res) => {

package/server/public/task-launcher.css

@@ -1902,16 +1902,6 @@ body.dark .setup-requirement-row.needs-update .setup-requirement-state {
   color: var(--task-muted);
 }
 
-.setup-reset-loading {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  margin-top: 12px;
-  color: var(--task-muted);
-  font-size: 12px;
-  line-height: 1.45;
-}
-
 .setup-state-root {
   min-height: 260px;
   display: flex;

package/server/views/install.ejs

@@ -540,6 +540,7 @@ body.install-page #terminal .xterm {
 </div>
 <input id='requirements' type='hidden' value="<%=requirements%>">
 <input id='callback' type='hidden' value="<%=callback%>">
+<input id='fresh' type='hidden' value="<%=fresh ? '1' : '0'%>">
 <script>
 //
 // /install_bin?type=bin&uri=conda
@@ -731,6 +732,29 @@ const navigateToCallback = () => {
   }
   location.href = href
 }
+const prepareFreshInstall = async () => {
+  if (document.querySelector("#fresh").value !== "1") return true
+  try {
+    const result = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
+      method: "post",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ type: "bin", background })
+    }))
+    if (result.cancelled) {
+      navigateToCallback()
+      return false
+    }
+    if (result.error) throw new Error(result.error)
+    return true
+  } catch (error) {
+    ModalInput({
+      title: "Error",
+      type: "modal",
+      description: error && error.message ? error.message : "Unable to reset managed tools."
+    })
+    return false
+  }
+}
 const resumeInstall = () => {
   const form = document.createElement("form")
   form.method = "post"
@@ -803,6 +827,7 @@ const createTerm = async (_theme) => {
 }
 document.addEventListener("DOMContentLoaded", async () => {
   applyInstallSpinnerVariant(randomInstallSpinnerVariant())
+  if (!await prepareFreshInstall()) return
   const n = new N()
   let socket = new Socket()
   <% if (theme === "dark") { %>

package/server/views/setup.ejs

@@ -177,18 +177,18 @@
                     <%= install_required ? 'This uses the same install flow as before.' : 'Pinokio can reopen the same destination without reinstalling anything.' %>
                   </p>
 
+                  <form class="task-hidden" id="fresh-install-form" method="post" action="/pinokio/install">
+                    <input type="hidden" name="requirements" value="<%= JSON.stringify(requirementList) %>">
+                    <input type="hidden" name="callback" value="<%= targetPath %>">
+                    <input type="hidden" name="fresh" value="1">
+                  </form>
                   <div class="setup-secondary-actions">
                     <span class="task-inline-help">Not working?</span>
-                    <button class="task-button" type="button" id="del-bin">
+                    <button class="task-button" type="submit" form="fresh-install-form">
                       <i class="fa-solid fa-trash" aria-hidden="true"></i>
                       <span>Try a fresh install</span>
                     </button>
                   </div>
-
-                  <div class="reset-bin-loading hidden setup-reset-loading">
-                    <i class="fa-solid fa-circle-notch fa-spin" aria-hidden="true"></i>
-                    <span>Stand by. Do not close this window.</span>
-                  </div>
                 </section>
               </div>
             </div>
@@ -383,30 +383,6 @@
         showWaitError(error && error.message ? error.message : "Failed to restart Pinokio")
       }
     <% } %>
-    if (document.querySelector("#del-bin")) {
-      document.querySelector("#del-bin").addEventListener("click", async () => {
-        let proceed = confirm("Are you sure you wish to delete the bin folder?")
-        if (proceed) {
-          document.querySelector(".reset-bin-loading").classList.remove("hidden")
-          document.querySelector("#del-bin").classList.add("hidden")
-          let res = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
-            method: "post",
-            headers: {
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({ type: "bin", background })
-          }))
-          document.querySelector(".reset-bin-loading").classList.add("hidden")
-          if (res.cancelled) {
-            document.querySelector("#del-bin").classList.remove("hidden")
-          } else if (res.error) {
-            alert(res.error)
-          } else {
-            document.querySelector("#install-form").submit()
-          }
-        }
-      })
-    }
   })
   </script>
   <%- include('partials/app_common_scripts') %>

package/server/views/tools.ejs

@@ -501,7 +501,8 @@
                           <form class="tools-reinstall-form" method="post" action="/pinokio/install">
                             <input type="hidden" name="requirements" value="<%= JSON.stringify(bundle.requirements) %>">
                             <input type="hidden" name="callback" value="/tools">
-                            <button class="task-link-button" type="button" data-tools-reinstall data-bundle-title="<%= bundle.title %>">
+                            <input type="hidden" name="fresh" value="1">
+                            <button class="task-link-button" type="submit">
                               <i class="fa-solid fa-rotate" aria-hidden="true"></i>
                               <span>Reinstall</span>
                             </button>
@@ -840,46 +841,6 @@
       });
     };
 
-    const registerToolsReinstall = () => {
-      document.querySelectorAll("[data-tools-reinstall]").forEach((button) => {
-        button.addEventListener("click", async () => {
-          const bundleTitle = button.dataset.bundleTitle || "this bundle";
-          const proceed = confirm(`Reinstall ${bundleTitle} from scratch? This removes the entire managed tools folder before reinstalling the selected bundle.`);
-          if (!proceed) return;
-
-          const form = button.closest("form");
-          const icon = button.querySelector("i");
-          const restoreButton = () => {
-            button.disabled = false;
-            button.removeAttribute("aria-busy");
-            if (icon) icon.classList.remove("fa-spin");
-          };
-          button.disabled = true;
-          button.setAttribute("aria-busy", "true");
-          if (icon) icon.classList.add("fa-spin");
-          let result;
-          try {
-            result = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
-              method: "post",
-              headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({ type: "bin", background })
-            }));
-          } catch (error) {
-            restoreButton();
-            alert(error && error.message ? error.message : "Unable to reset managed tools.");
-            return;
-          }
-
-          if (result.cancelled || result.error) {
-            restoreButton();
-            if (result.error) alert(result.error);
-            return;
-          }
-          form.submit();
-        });
-      });
-    };
-
     document.addEventListener("DOMContentLoaded", function() {
       const isPending = <%= pending ? 'true' : 'false' %>;
 
@@ -892,7 +853,6 @@
 
       registerPackageInstallSheets();
       registerPackageInstallForms();
-      registerToolsReinstall();
 
       const tabs = document.querySelectorAll(".tools-tab-button");
       const panels = document.querySelectorAll(".tools-package-panel");

package/test/path-removal-ui.test.js

@@ -393,6 +393,7 @@ test("successful runtime cleanup resubmits the interrupted install", async (t) =
   const html = ejs.render(source, {
     agent: "web",
     callback: "/tools",
+    fresh: false,
     requirements,
     theme: "dark",
   }, { filename: installViewPath })
@@ -457,3 +458,65 @@ test("successful runtime cleanup resubmits the interrupted install", async (t) =
     fields: { requirements, callback: "/tools" },
   })
 })
+
+test("fresh install removes bin on the install page before starting the installer", async (t) => {
+  const source = await fs.readFile(installViewPath, "utf8")
+  const requirements = '[{"name":"conda"}]'
+  const html = ejs.render(source, {
+    agent: "web",
+    callback: "/tools",
+    fresh: true,
+    requirements,
+    theme: "dark",
+  }, { filename: installViewPath })
+
+  let removal
+  let started
+  const startedPromise = new Promise((resolve) => { started = resolve })
+  const dom = new JSDOM(html, {
+    runScripts: "dangerously",
+    url: "http://localhost/pinokio/install",
+    beforeParse(window) {
+      window.fetch = async (url, options) => {
+        if (url === "/pinokio/delete") {
+          removal = { url, options }
+          return { ok: true, status: 200, json: async () => ({ success: true }) }
+        }
+        return { ok: true, status: 200, json: async () => ({ config: {} }) }
+      }
+      window.matchMedia = () => ({ matches: false, addEventListener() {}, removeEventListener() {} })
+      window.ResizeObserver = class { observe() {} }
+      window.N = class { Noty() {} }
+      window.Terminal = class {
+        constructor() { this.cols = 80; this.rows = 24 }
+        attachCustomKeyEventHandler() {}
+        focus() {}
+        hasSelection() { return false }
+        loadAddon() {}
+        onData() {}
+        open() {}
+        write() {}
+      }
+      window.FitAddon = { FitAddon: class { fit() {} } }
+      window.WebLinksAddon = { WebLinksAddon: class {} }
+      window.xtermTheme = { FrontEndDelight: {} }
+      window.PinokioTouch = { bindTerminalFocus() {} }
+      window.PinokioPathRemoval = {
+        request: async (remove) => (await remove(false)).json(),
+      }
+      window.Socket = class {
+        emit() {}
+        run(request) {
+          assert.ok(removal, "fresh removal must finish before the installer starts")
+          assert.equal(request.params, requirements)
+          started()
+        }
+      }
+    },
+  })
+  t.after(() => dom.window.close())
+
+  await startedPromise
+  assert.equal(removal.url, "/pinokio/delete")
+  assert.deepEqual(JSON.parse(removal.options.body), { type: "bin", background: false })
+})

package/test/tools-reinstall-ui.test.js

@@ -6,6 +6,7 @@ const ejs = require("ejs")
 const { JSDOM } = require("jsdom")
 
 const viewPath = path.resolve(__dirname, "../server/views/tools.ejs")
+const setupViewPath = path.resolve(__dirname, "../server/views/setup.ejs")
 
 async function renderTools() {
   const source = await fs.readFile(viewPath, "utf8")
@@ -27,78 +28,57 @@ async function renderTools() {
   })
 }
 
-test("Tools reinstall removes bin and submits the selected bundle", async (t) => {
+test("Tools reinstall immediately submits a fresh install request", async (t) => {
   const html = await renderTools()
-  let request
   let submission
   const dom = new JSDOM(html, {
-    runScripts: "dangerously",
     url: "http://localhost/tools",
-    beforeParse(window) {
-      window.matchMedia = () => ({ matches: false, addEventListener() {}, removeEventListener() {} })
-      window.requestAnimationFrame = (callback) => window.setTimeout(callback, 0)
-      window.confirm = () => true
-      window.PinokioPathRemoval = {
-        request: async (remove) => {
-          request = await remove(false)
-          return { success: true }
-        },
-      }
-      window.fetch = async (url, options) => ({ url, options })
-      window.HTMLFormElement.prototype.submit = function () {
-        submission = {
-          action: new URL(this.action).pathname,
-          fields: Object.fromEntries(new window.FormData(this)),
-        }
-      }
-    },
   })
   t.after(() => dom.window.close())
 
-  await new Promise((resolve) => dom.window.setTimeout(resolve, 0))
-  const button = dom.window.document.querySelector("[data-tools-reinstall]")
-  assert.ok(button)
+  const form = dom.window.document.querySelector(".tools-reinstall-form")
+  form.addEventListener("submit", (event) => {
+    event.preventDefault()
+    submission = {
+      action: new URL(form.action).pathname,
+      fields: Object.fromEntries(new dom.window.FormData(form)),
+    }
+  })
+  const button = form.querySelector("button[type=submit]")
   button.click()
-  await new Promise((resolve) => dom.window.setTimeout(resolve, 0))
 
-  assert.equal(request.url, "/pinokio/delete")
-  assert.equal(request.options.method, "post")
-  assert.deepEqual(JSON.parse(request.options.body), { type: "bin", background: false })
   assert.deepEqual(submission, {
     action: "/pinokio/install",
     fields: {
       requirements: '[{"name":"conda","type":"bin","installed":true}]',
       callback: "/tools",
+      fresh: "1",
     },
   })
 })
 
-test("Tools reinstall keeps the bundle intact when the user cancels", async (t) => {
-  const html = await renderTools()
-  let removed = false
-  let submitted = false
-  const dom = new JSDOM(html, {
-    runScripts: "dangerously",
-    url: "http://localhost/tools",
-    beforeParse(window) {
-      window.matchMedia = () => ({ matches: false, addEventListener() {}, removeEventListener() {} })
-      window.requestAnimationFrame = (callback) => window.setTimeout(callback, 0)
-      window.fetch = async () => ({ ok: true, json: async () => ({ status: "off" }) })
-      window.confirm = () => false
-      window.PinokioPathRemoval = {
-        request: async () => {
-          removed = true
-          return { success: true }
-        },
-      }
-      window.HTMLFormElement.prototype.submit = () => { submitted = true }
-    },
+test("setup fresh install is a direct form submission", async () => {
+  const source = await fs.readFile(setupViewPath, "utf8")
+  const start = source.indexOf('<form class="task-hidden" id="fresh-install-form"')
+  const end = source.indexOf("</div>", source.indexOf("</button>", start)) + 6
+  const fragment = ejs.render(source.slice(start, end), {
+    requirementList: [{ name: "conda", installed: true }],
+    targetPath: "/tools",
   })
-  t.after(() => dom.window.close())
+  const dom = new JSDOM(fragment, { url: "http://localhost/setup/dev" })
+  const form = dom.window.document.querySelector("#fresh-install-form")
+  let submission
+  form.addEventListener("submit", (event) => {
+    event.preventDefault()
+    submission = Object.fromEntries(new dom.window.FormData(form))
+  })
+  dom.window.document.querySelector('[form="fresh-install-form"]').click()
 
-  await new Promise((resolve) => dom.window.setTimeout(resolve, 0))
-  dom.window.document.querySelector("[data-tools-reinstall]").click()
-  await new Promise((resolve) => dom.window.setTimeout(resolve, 0))
-  assert.equal(removed, false)
-  assert.equal(submitted, false)
+  assert.deepEqual(submission, {
+    requirements: '[{"name":"conda","installed":true}]',
+    callback: "/tools",
+    fresh: "1",
+  })
+  dom.window.close()
+  assert.doesNotMatch(source, /id="del-bin"|setup-reset-loading/)
 })