pinokiod 7.5.20 → 7.5.23

package/kernel/plugin_sources.js

@@ -75,6 +75,13 @@ const normalizePluginPath = (value) => {
   return normalized
 }
 
+const systemPluginPathForLocalPath = (value) => {
+  const normalized = normalizePluginPath(value)
+  const localPrefix = "/plugin/"
+  if (!normalized.startsWith(localPrefix)) return ""
+  return `${SYSTEM_PLUGIN_RUN_PREFIX}/${normalized.slice(localPrefix.length)}`
+}
+
 const pluginSelectionMatches = (src, selectedValue) => {
   const selectedPlugin = normalizeSlashes(typeof selectedValue === "string" ? selectedValue.trim() : "")
   if (!selectedPlugin || !src) return false
@@ -297,6 +304,7 @@ module.exports = {
   isSystemPluginPath,
   isLegacyPluginCodePath,
   normalizePluginPath,
+  systemPluginPathForLocalPath,
   pluginSelectionMatches,
   resolveRunPath,
   pluginPathToAbsolute,

package/package.json

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

package/server/index.js

@@ -78,6 +78,7 @@ const { createTerminalSessionHelpers } = require("./lib/terminal_session_helpers
 const { createLauncherInstructionBootstrap } = require("./lib/launcher_instruction_bootstrap")
 const { createTerminalGitResetHandler } = require("./lib/terminal_git_reset")
 const { createDesktopEventRouter } = require("./lib/desktop_event_router")
+const { deletePluginFolder } = require("./lib/plugin_delete")
 const { createInjectRouter, resolveInjectList } = require("./lib/inject_router")
 const { createTaskPackageService } = require("./lib/task_packages")
 const { createTaskWorkspaceLinkService } = require("./lib/task_workspace_links")
@@ -7203,6 +7204,8 @@ class Server {
         link: pluginItem?.link || "",
         image: pluginItem?.image || null,
         icon: pluginItem?.icon || null,
+        source: pluginItem?.source || "",
+        system: pluginItem?.system === true,
         default: pluginItem?.default === true,
         pluginPath: normalizedPluginPath,
         pluginKey: normalizePluginLookupKey(normalizedPluginPath),
@@ -7335,7 +7338,18 @@ class Server {
       if (!targetKey) {
         return null
       }
-      return plugins.find((plugin) => plugin && plugin.pluginKey === targetKey) || null
+      const exact = plugins.find((plugin) => plugin && plugin.pluginKey === targetKey)
+      if (exact) {
+        return exact
+      }
+      return findSystemPluginFallbackByPath(plugins, targetPath, targetKey)
+    }
+    const findSystemPluginFallbackByPath = (plugins, targetPath, targetKey = "") => {
+      const systemFallbackKey = normalizePluginLookupKey(PluginSources.systemPluginPathForLocalPath(targetPath))
+      if (!systemFallbackKey || systemFallbackKey === targetKey) {
+        return null
+      }
+      return plugins.find((plugin) => plugin && plugin.system === true && plugin.pluginKey === systemFallbackKey) || null
     }
     const buildSerializedPluginFromValidation = (validation) => {
       const context = validation && validation.context && typeof validation.context === "object"
@@ -7383,6 +7397,10 @@ class Server {
       const pluginRoot = path.resolve(this.kernel.path("plugin"))
       const managedRoot = path.resolve(pluginRoot, "code")
       const normalizedPath = normalizePluginPath(plugin && plugin.pluginPath ? plugin.pluginPath : "")
+      const isSystemPlugin = Boolean(plugin && (plugin.system === true || plugin.source === "system"))
+      const systemPluginPath = PluginSources.isSystemPluginPath(normalizedPath)
+        ? normalizedPath
+        : (isSystemPlugin ? PluginSources.systemPluginPathForLocalPath(normalizedPath) : "")
       const emptyState = {
         ownership: "bundled",
         manageable: false,
@@ -7396,8 +7414,8 @@ class Server {
         localLabel: "",
         managedPrefix: "",
       }
-      if (PluginSources.isSystemPluginPath(normalizedPath)) {
-        const relativeSystemPath = normalizedPath.replace(/^\/pinokio\/run\/+/, "")
+      if (isSystemPlugin || systemPluginPath) {
+        const relativeSystemPath = (systemPluginPath || normalizedPath).replace(/^\/pinokio\/run\/+/, "")
         return {
           ...emptyState,
           ownership: "system",
@@ -7511,6 +7529,27 @@ class Server {
         }
       }
 
+      if (localState.ownership === "system") {
+        return {
+          ownership: "system",
+          manageable: false,
+          canOpenFolder: false,
+          dir: "",
+          localLabel: localState.localLabel,
+          remoteUrl: "",
+          remoteWebUrl: "",
+          githubConnected: false,
+          gitInitialized: false,
+          hasCommit: false,
+          changeCount: 0,
+          changes: [],
+          branch: "HEAD",
+          commitUrl: "",
+          createUrl: "",
+          pushUrl: "",
+        }
+      }
+
       if (localState.ownership === "managed") {
         let changes = []
         try {
@@ -7726,6 +7765,7 @@ class Server {
         changePreview,
         extraChangeCount: Math.max(changes.length - changePreview.length, 0),
         canManageSource: ownership === "local",
+        showSidebar: ownership !== "system",
         canOpenFolder: Boolean(shareState && shareState.canOpenFolder && shareState.dir),
         openFolderPath: shareState && shareState.canOpenFolder ? shareState.dir : "",
         isManagedSource: ownership === "managed",
@@ -7758,17 +7798,29 @@ class Server {
         res.redirect("/plugins")
         return
       }
-      const validation = await contentValidation.validatePluginByPath(requestedPath)
-      if (!validation.valid) {
-        await this.renderInvalidContentPage(req, res, validation, {
-          sidebarSelected: "plugins",
-          backHref: "/plugins",
-          backLabel: "Back to Plugins",
-        })
-        return
+      let plugins = null
+      const loadPluginsOnce = async () => {
+        if (!plugins) {
+          plugins = await loadSerializedPlugins()
+        }
+        return plugins
+      }
+      let plugin = null
+      if (PluginSources.systemPluginPathForLocalPath(requestedPath)) {
+        plugin = findPluginByPath(await loadPluginsOnce(), requestedPath)
+      }
+      if (!plugin) {
+        const validation = await contentValidation.validatePluginByPath(requestedPath)
+        if (!validation.valid) {
+          await this.renderInvalidContentPage(req, res, validation, {
+            sidebarSelected: "plugins",
+            backHref: "/plugins",
+            backLabel: "Back to Plugins",
+          })
+          return
+        }
+        plugin = findPluginByPath(await loadPluginsOnce(), requestedPath) || buildSerializedPluginFromValidation(validation)
       }
-      const plugins = await loadSerializedPlugins()
-      const plugin = findPluginByPath(plugins, requestedPath) || buildSerializedPluginFromValidation(validation)
       if (!plugin) {
         res.status(404).send("Plugin not found.")
         return
@@ -7818,6 +7870,54 @@ class Server {
         share: shareState
       })
     }))
+    this.app.post("/plugin/delete", ex(async (req, res) => {
+      const requestedPath = typeof req.body.path === "string" ? req.body.path.trim() : ""
+      if (!requestedPath) {
+        res.status(400).json({
+          ok: false,
+          error: "Plugin path is required."
+        })
+        return
+      }
+      try {
+        const plugins = await loadSerializedPlugins()
+        let plugin = findPluginByPath(plugins, requestedPath)
+        if (!plugin) {
+          const validation = await contentValidation.validatePluginByPath(requestedPath)
+          if (!validation.valid) {
+            res.status(404).json({
+              ok: false,
+              error: validation.message || "Plugin not found."
+            })
+            return
+          }
+          plugin = buildSerializedPluginFromValidation(validation)
+        }
+        if (!plugin) {
+          res.status(404).json({
+            ok: false,
+            error: "Plugin not found."
+          })
+          return
+        }
+
+        const target = await deletePluginFolder({ kernel: this.kernel, plugin })
+        res.set("Cache-Control", "no-store")
+        res.json({
+          ok: true,
+          redirect: "/plugins",
+          deleted: {
+            pluginPath: target.pluginPath,
+            localLabel: target.localLabel,
+          }
+        })
+      } catch (error) {
+        res.status(error && error.status ? error.status : 500).json({
+          ok: false,
+          error: error && error.message ? error.message : "Failed to delete plugin."
+        })
+      }
+    }))
     this.app.get("/api/plugin/menu", ex(async (req, res) => {
       try {
         const workspacePath = resolveProjectShellWorkspace(req.query.workspace)

package/server/lib/plugin_delete.js

@@ -0,0 +1,89 @@
+const fs = require("fs")
+const path = require("path")
+const PluginSources = require("../../kernel/plugin_sources")
+
+const isPathInsideRoot = (candidatePath, rootPath) => {
+  const relative = path.relative(rootPath, candidatePath)
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))
+}
+
+const httpError = (status, message) => {
+  const error = new Error(message)
+  error.status = status
+  return error
+}
+
+const assertFinalRmTargetInsidePluginRoot = async (target) => {
+  const pluginRoot = path.resolve(target.pluginRoot)
+  const rmPath = path.resolve(target.pluginDir)
+  if (!isPathInsideRoot(rmPath, pluginRoot) || rmPath === pluginRoot) {
+    throw httpError(403, "Plugin folder is outside the downloaded plugin folder.")
+  }
+
+  const [realPluginRoot, realRmPath] = await Promise.all([
+    fs.promises.realpath(pluginRoot),
+    fs.promises.realpath(rmPath),
+  ])
+  if (!isPathInsideRoot(realRmPath, realPluginRoot) || realRmPath === realPluginRoot) {
+    throw httpError(403, "Plugin folder is outside the downloaded plugin folder.")
+  }
+}
+
+const resolvePluginDeleteTarget = ({ kernel, plugin }) => {
+  if (!kernel || typeof kernel.path !== "function") {
+    throw httpError(500, "Plugin home path is unavailable.")
+  }
+
+  const normalizedPath = PluginSources.normalizePluginPath(plugin && plugin.pluginPath ? plugin.pluginPath : "")
+  if (!normalizedPath) {
+    throw httpError(400, "Plugin path is required.")
+  }
+  if ((plugin && (plugin.system === true || plugin.source === "system")) || PluginSources.isSystemPluginPath(normalizedPath)) {
+    throw httpError(403, "Built-in plugins cannot be deleted.")
+  }
+  if (!normalizedPath.startsWith("/plugin/") || PluginSources.isLegacyPluginCodePath(normalizedPath)) {
+    throw httpError(403, "Only downloaded plugin folders can be deleted.")
+  }
+
+  const pluginRoot = path.resolve(kernel.path("plugin"))
+  const pluginFilePath = path.resolve(kernel.path(normalizedPath.slice(1)))
+  if (!isPathInsideRoot(pluginFilePath, pluginRoot)) {
+    throw httpError(403, "Plugin path is outside the downloaded plugin folder.")
+  }
+
+  const pluginDir = path.dirname(pluginFilePath)
+  if (pluginDir === pluginRoot) {
+    throw httpError(403, "The plugin root folder cannot be deleted from this page.")
+  }
+
+  const relativeDir = path.relative(pluginRoot, pluginDir).split(path.sep).join("/")
+  return {
+    pluginPath: normalizedPath,
+    pluginRoot,
+    pluginFilePath,
+    pluginDir,
+    relativeDir,
+    localLabel: relativeDir ? `plugin/${relativeDir}` : "plugin",
+  }
+}
+
+const deletePluginFolder = async ({ kernel, plugin }) => {
+  const target = resolvePluginDeleteTarget({ kernel, plugin })
+
+  const [fileStat, dirStat] = await Promise.all([
+    fs.promises.stat(target.pluginFilePath).catch(() => null),
+    fs.promises.stat(target.pluginDir).catch(() => null),
+  ])
+  if (!fileStat || !fileStat.isFile() || !dirStat || !dirStat.isDirectory()) {
+    throw httpError(404, "Plugin folder was not found.")
+  }
+
+  await assertFinalRmTargetInsidePluginRoot(target)
+  await fs.promises.rm(target.pluginDir, { recursive: true, force: true })
+  return target
+}
+
+module.exports = {
+  deletePluginFolder,
+  resolvePluginDeleteTarget,
+}

package/server/public/common.js

@@ -3699,9 +3699,13 @@ document.addEventListener("DOMContentLoaded", () => {
         const type = trigger.dataset && typeof trigger.dataset.universalLauncherOpen === 'string'
           ? trigger.dataset.universalLauncherOpen.trim()
           : '';
-        createLauncherDebugLog('universal launcher trigger clicked', { type });
+        const mode = trigger.dataset && typeof trigger.dataset.universalLauncherMode === 'string'
+          ? trigger.dataset.universalLauncherMode.trim()
+          : '';
+        createLauncherDebugLog('universal launcher trigger clicked', { type, mode });
         guardUniversalLauncher(api, {
-          type: type || 'create_app'
+          type: type || 'create_app',
+          mode: mode || ''
         });
       });
     });

package/server/public/plugin-detail.js

@@ -34,6 +34,7 @@
     uninstall: "fa-solid fa-trash-can",
     update: "fa-solid fa-rotate-right"
   };
+  const EVENT_PANEL_STATUS_EVENT = "pinokio:event-panel-status";
 
   const noteEl = document.querySelector("[data-plugin-share-note]");
   const nextTitleEl = document.querySelector("[data-plugin-share-next-title]");
@@ -43,6 +44,7 @@
   const createCancel = document.querySelector("[data-plugin-share-create-cancel]");
   const repoNameInput = document.querySelector("[data-plugin-share-repo-name]");
   const visibilitySelect = document.querySelector("[data-plugin-share-visibility]");
+  const staticActions = document.querySelector("[data-plugin-share-static-actions]");
   const remoteLink = document.querySelector("[data-plugin-share-remote-link]");
   const refreshButton = document.querySelector("[data-plugin-share-refresh]");
   const shareCopyEl = document.querySelector("[data-plugin-share-copy]");
@@ -59,9 +61,11 @@
   const aiPermissionClear = document.querySelector("[data-plugin-ai-permission-clear]");
   const aiPermissionPath = document.querySelector("[data-plugin-ai-permission-path]");
   const aiPermissionStatus = document.querySelector("[data-plugin-ai-permission-status]");
+  const deleteButton = document.querySelector("[data-plugin-delete]");
 
   let refreshInFlight = false;
   let createFormOpen = false;
+  let activeActionModal = null;
   const AI_CONSENT_PREFIX = "pinokio:ai-consent:";
 
   function readDownloadState() {
@@ -182,6 +186,72 @@
     }
   }
 
+  async function confirmPluginDelete() {
+    if (!deleteButton || !plugin || !plugin.pluginPath) {
+      return;
+    }
+
+    const pluginTitle = plugin.title || "this plugin";
+    const localLabel = share && share.localLabel ? share.localLabel : "this plugin folder";
+    let confirmed = false;
+    if (window.Swal && typeof Swal.fire === "function") {
+      const result = await Swal.fire({
+        title: `Delete ${pluginTitle}?`,
+        html: `This permanently deletes <code>${escapeHtml(localLabel)}</code>. Only this plugin folder will be removed.`,
+        showCancelButton: true,
+        confirmButtonText: "Delete plugin",
+        cancelButtonText: "Cancel",
+        focusCancel: true,
+        reverseButtons: true,
+        buttonsStyling: false,
+        customClass: {
+          confirmButton: "task-button danger",
+          cancelButton: "task-button"
+        }
+      });
+      confirmed = !!(result && result.isConfirmed);
+    } else {
+      confirmed = window.confirm(`Delete ${pluginTitle}? This permanently deletes ${localLabel}.`);
+    }
+    if (!confirmed) {
+      return;
+    }
+
+    const originalHtml = deleteButton.innerHTML;
+    deleteButton.disabled = true;
+    deleteButton.classList.add("is-busy");
+    try {
+      const response = await fetch("/plugin/delete", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ path: plugin.pluginPath })
+      });
+      const payload = await response.json().catch(() => ({}));
+      if (!response.ok || !payload.ok) {
+        throw new Error(payload && payload.error ? payload.error : `HTTP ${response.status}`);
+      }
+      window.location.href = payload.redirect || "/plugins";
+    } catch (error) {
+      deleteButton.disabled = false;
+      deleteButton.classList.remove("is-busy");
+      deleteButton.innerHTML = originalHtml;
+      const message = error && error.message ? error.message : "Failed to delete plugin.";
+      if (window.Swal && typeof Swal.fire === "function") {
+        Swal.fire({
+          title: "Delete failed",
+          text: message,
+          confirmButtonText: "Close",
+          buttonsStyling: false,
+          customClass: {
+            confirmButton: "task-button"
+          }
+        });
+      } else {
+        alert(message);
+      }
+    }
+  }
+
   function clearNode(node) {
     while (node && node.firstChild) {
       node.removeChild(node.firstChild);
@@ -233,10 +303,38 @@
     if (plugin.defaultCwd) {
       params.set("cwd", plugin.defaultCwd);
     }
+    params.set("__pinokio_event_panel", "1");
     params.set("ts", String(Date.now()));
     return `/action/${encodeURIComponent(actionType)}/${encodedPath}?${params.toString()}`;
   }
 
+  function finishActionModal(modalState) {
+    if (!modalState || modalState.completed) {
+      return;
+    }
+    modalState.completed = true;
+    Swal.close();
+  }
+
+  function handleActionCompleteMessage(event) {
+    const data = event && event.data && typeof event.data === "object" ? event.data : null;
+    if (!data || data.e !== EVENT_PANEL_STATUS_EVENT || !activeActionModal) {
+      return;
+    }
+    if (event.origin !== window.location.origin) {
+      return;
+    }
+    const modalState = activeActionModal;
+    if (data.success === false) {
+      return;
+    }
+    const iframe = modalState.iframe;
+    if (!iframe || event.source !== iframe.contentWindow) {
+      return;
+    }
+    finishActionModal(modalState);
+  }
+
   function showActionModal(actionType) {
     const targetUrl = buildActionUrl(actionType);
     if (!targetUrl) {
@@ -261,6 +359,11 @@
         </div>
       </div>
     `;
+    const modalState = {
+      iframe: null,
+      completed: false
+    };
+    activeActionModal = modalState;
 
     Swal.fire({
       html: modalHtml,
@@ -278,10 +381,19 @@
       didOpen: (popup) => {
         const iframe = popup.querySelector("iframe");
         if (iframe) {
+          modalState.iframe = iframe;
           iframe.dataset.forceVisible = "true";
           iframe.classList.remove("hidden");
           iframe.removeAttribute("hidden");
         }
+      },
+      didClose: () => {
+        if (activeActionModal === modalState) {
+          activeActionModal = null;
+        }
+        if (modalState.completed) {
+          window.location.reload();
+        }
       }
     });
   }
@@ -761,6 +873,9 @@
   }
 
   function renderRemoteState() {
+    const hasRemote = !!share.remoteUrl;
+    const hasRemoteWebUrl = !!share.remoteWebUrl;
+    const showStaticRefresh = hasRemote && !!share.githubConnected;
     if (noteEl) {
       if (!share.manageable) {
         noteEl.textContent = "Read only";
@@ -776,8 +891,14 @@
         noteEl.textContent = "Setup needed";
       }
     }
+    if (staticActions) {
+      staticActions.classList.toggle("task-hidden", !hasRemoteWebUrl && !showStaticRefresh);
+    }
+    if (refreshButton) {
+      refreshButton.classList.toggle("task-hidden", !showStaticRefresh);
+    }
     if (remoteLink) {
-      if (share.remoteWebUrl) {
+      if (hasRemoteWebUrl) {
         remoteLink.href = share.remoteWebUrl;
         remoteLink.classList.remove("task-hidden", "is-disabled");
         remoteLink.removeAttribute("aria-disabled");
@@ -936,6 +1057,8 @@
     });
   }
 
+  window.addEventListener("message", handleActionCompleteMessage);
+
   document.querySelectorAll("[data-plugin-action]").forEach((button) => {
     button.addEventListener("click", (event) => {
       event.preventDefault();
@@ -998,6 +1121,13 @@
     updateAiPermissionStatus();
   }
 
+  if (deleteButton) {
+    deleteButton.addEventListener("click", (event) => {
+      event.preventDefault();
+      confirmPluginDelete();
+    });
+  }
+
   render();
   applyDownloadedState();
 })();