pinokiod 3.183.0 → 3.185.0

package/kernel/api/terminal/index.js

@@ -28,8 +28,20 @@ class Terminal {
     await fs.promises.mkdir(uploadRoot, { recursive: true })
 
     const saved = []
+    const failures = []
+
+    const remoteFiles = []
+    const localFiles = []
 
     for (const file of files) {
+      if (file && typeof file.url === 'string' && file.url.trim().length > 0) {
+        remoteFiles.push(file)
+      } else {
+        localFiles.push(file)
+      }
+    }
+
+    for (const file of localFiles) {
       const key = file && file.key
       if (!key || !buffers[key]) {
         continue
@@ -66,11 +78,62 @@ class Terminal {
 
     }
 
+    for (const file of remoteFiles) {
+      const url = typeof file.url === 'string' ? file.url.trim() : ''
+      if (!url) {
+        continue
+      }
+      let originalName = typeof file.name === 'string' && file.name.trim().length > 0
+        ? file.name.trim()
+        : null
+      if (!originalName) {
+        try {
+          const parsed = new URL(url)
+          const baseSegment = parsed.pathname ? parsed.pathname.split('/').filter(Boolean).pop() : null
+          originalName = baseSegment || 'download'
+        } catch (_) {
+          originalName = 'download'
+        }
+      }
+      let sanitized = sanitize(originalName) || 'download'
+      const targetName = await this.uniqueFilename(uploadRoot, sanitized)
+      const targetPath = path.join(uploadRoot, targetName)
+      try {
+        await kernel.download({ uri: url, path: uploadRoot, filename: targetName }, ondata || (() => {}))
+        const stats = await fs.promises.stat(targetPath)
+        const size = stats.size
+        const homeRelativePath = path.relative(kernel.homedir, targetPath)
+        const normalizedHomeRelativePath = homeRelativePath.split(path.sep).join('/')
+        const cliPath = targetPath
+        const cliBase = baseCwd || kernel.homedir
+        const cliRelative = cliBase ? path.relative(cliBase, targetPath) : null
+        const cliRelativePath = cliRelative ? cliRelative.split(path.sep).join('/') : null
+
+        saved.push({
+          originalName,
+          storedAs: targetName,
+          path: targetPath,
+          size,
+          mimeType: typeof file.type === 'string' ? file.type : '',
+          homeRelativePath: normalizedHomeRelativePath,
+          displayPath: `~/${normalizedHomeRelativePath}`,
+          cliPath,
+          cliRelativePath,
+          sourceUrl: url
+        })
+      } catch (error) {
+        failures.push({ url, error: error.message })
+        try {
+          await fs.promises.rm(targetPath, { force: true })
+        } catch (_) {}
+      }
+    }
+
     if (saved.length === 0) {
       if (ondata) {
         ondata({ raw: "\r\nNo files were saved.\r\n" })
       }
-      return { files: saved }
+      return { files: saved, errors: failures }
     }
 
     const marker = '[attachment] '
@@ -95,7 +158,7 @@ class Terminal {
       req.params.buffers = {}
     }
 
-    return { files: saved }
+    return { files: saved, errors: failures }
   }
 
   resolveShellInstance(params, kernel) {

package/package.json

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

package/server/index.js

@@ -26,6 +26,7 @@ const axios = require('axios')
 const crypto = require('crypto')
 const serveIndex = require('./serveIndex')
 const registerFileRoutes = require('./routes/files')
+const TerminalApi = require('../kernel/api/terminal')
 
 const git = require('isomorphic-git')
 const http = require('isomorphic-git/http/node')
@@ -4799,6 +4800,79 @@ class Server {
         res.json({ error: e.stack })
       }
     }))
+    this.app.post("/terminal/url-upload", ex(async (req, res) => {
+      const payload = req.body || {}
+      const id = typeof payload.id === 'string' ? payload.id.trim() : ''
+      const cwd = typeof payload.cwd === 'string' ? payload.cwd : null
+      const inputUrls = Array.isArray(payload.urls) ? payload.urls : []
+      if (!id) {
+        res.status(400).json({ error: 'terminal id is required' })
+        return
+      }
+      if (inputUrls.length === 0) {
+        res.status(400).json({ error: 'at least one url is required' })
+        return
+      }
+      const normalized = []
+      const hostHeader = typeof req.get === 'function' ? req.get('host') : null
+      const baseOrigin = hostHeader ? `${req.protocol || 'http'}://${hostHeader}` : null
+      const seen = new Set()
+      for (const entry of inputUrls) {
+        const rawHref = (entry && typeof entry === 'object') ? entry.href : entry
+        const nameHint = entry && typeof entry === 'object' && typeof entry.name === 'string' ? entry.name : undefined
+        if (typeof rawHref !== 'string') {
+          continue
+        }
+        const trimmed = rawHref.trim()
+        if (!trimmed) {
+          continue
+        }
+        let resolved
+        try {
+          resolved = baseOrigin ? new URL(trimmed, baseOrigin) : new URL(trimmed)
+        } catch (_) {
+          try {
+            resolved = new URL(trimmed)
+          } catch (_) {
+            continue
+          }
+        }
+        if (!resolved || !/^https?:$/i.test(resolved.protocol)) {
+          continue
+        }
+        const href = resolved.href
+        if (seen.has(href)) {
+          continue
+        }
+        seen.add(href)
+        const item = { url: href }
+        if (nameHint && nameHint.trim()) {
+          item.name = nameHint.trim()
+        }
+        normalized.push(item)
+      }
+      if (normalized.length === 0) {
+        res.status(400).json({ error: 'no valid urls' })
+        return
+      }
+      const terminalApi = new TerminalApi()
+      const requestPayload = {
+        params: {
+          id,
+          cwd,
+          files: normalized,
+          buffers: {}
+        }
+      }
+      try {
+        const result = await terminalApi.upload(requestPayload, () => {}, this.kernel)
+        const files = result && Array.isArray(result.files) ? result.files : []
+        const errors = result && Array.isArray(result.errors) ? result.errors : []
+        res.json({ files, errors })
+      } catch (error) {
+        res.status(500).json({ error: error && error.message ? error.message : 'remote upload failed' })
+      }
+    }))
     this.app.post("/push", ex(async (req, res) => {
       try {
         const payload = { ...(req.body || {}) }

package/server/public/common.js

@@ -2190,21 +2190,209 @@ document.addEventListener("DOMContentLoaded", () => {
   });
   observer.observe(document.body, { attributes: true });
   
-  if (document.querySelector("#screenshot")) {
-    document.querySelector("#screenshot").addEventListener("click", (e) => {
-      screenshot()
-    })
+  const createFrameHistoryController = () => {
+    const sanitizeStack = (input) => {
+      if (!Array.isArray(input)) {
+        return []
+      }
+      return input.filter((value) => typeof value === 'string' && value.length > 0)
+    }
+    const resolveFrameKey = () => {
+      try {
+        if (typeof window.name === 'string' && window.name.length > 0) {
+          return `name:${window.name}`
+        }
+      } catch (_) {}
+      try {
+        if (window.frameElement && window.frameElement.id) {
+          return `frame:${window.frameElement.id}`
+        }
+      } catch (_) {}
+      return 'top'
+    }
+    const frameKey = resolveFrameKey()
+    const storageKey = `pinokio:frame-history:v1:${frameKey}`
+    const MAX_ENTRIES = 64
+    let storageFailed = false
+
+    const normalizeState = (value) => {
+      const past = sanitizeStack(value && value.past)
+      const future = sanitizeStack(value && value.future)
+      const trimmedPast = past.length > MAX_ENTRIES ? past.slice(-MAX_ENTRIES) : past
+      const trimmedFuture = future.length > MAX_ENTRIES ? future.slice(-MAX_ENTRIES) : future
+      return { past: trimmedPast.slice(), future: trimmedFuture.slice() }
+    }
+    const readState = () => {
+      if (storageFailed) {
+        return { past: [], future: [] }
+      }
+      try {
+        const raw = sessionStorage.getItem(storageKey)
+        if (!raw) {
+          return { past: [], future: [] }
+        }
+        return normalizeState(JSON.parse(raw))
+      } catch (_) {
+        storageFailed = true
+        return { past: [], future: [] }
+      }
+    }
+    const writeState = (state) => {
+      if (storageFailed) {
+        return false
+      }
+      try {
+        sessionStorage.setItem(storageKey, JSON.stringify(normalizeState(state)))
+        return true
+      } catch (_) {
+        storageFailed = true
+        return false
+      }
+    }
+
+    const ensureCurrentRecorded = () => {
+      const state = readState()
+      if (storageFailed) {
+        return
+      }
+      const currentUrl = window.location.href
+      const last = state.past[state.past.length - 1]
+      if (last !== currentUrl) {
+        state.past.push(currentUrl)
+        if (state.past.length > MAX_ENTRIES) {
+          state.past = state.past.slice(-MAX_ENTRIES)
+        }
+        state.future = []
+        if (!writeState(state)) {
+          return
+        }
+      }
+    }
+
+    try {
+      ensureCurrentRecorded()
+    } catch (_) {
+      storageFailed = true
+    }
+
+    if (storageFailed) {
+      return null
+    }
+
+    const navigateByDelta = (delta) => {
+      if (!Number.isFinite(delta) || delta === 0) {
+        return false
+      }
+      if (storageFailed) {
+        return false
+      }
+      const state = readState()
+      if (storageFailed) {
+        return false
+      }
+      if (delta < 0) {
+        const available = state.past.length - 1
+        if (available <= 0) {
+          return true
+        }
+        let steps = Math.min(-delta, available)
+        while (steps > 0) {
+          const current = state.past.pop()
+          if (typeof current === 'string' && current.length > 0) {
+            state.future.push(current)
+          }
+          steps -= 1
+        }
+        if (state.future.length > MAX_ENTRIES) {
+          state.future = state.future.slice(-MAX_ENTRIES)
+        }
+        const target = state.past[state.past.length - 1]
+        if (!target) {
+          return false
+        }
+        if (!writeState(state)) {
+          return false
+        }
+        try {
+          window.location.replace(target)
+        } catch (_) {
+          window.location.href = target
+        }
+        return true
+      }
+      if (delta > 0) {
+        if (state.future.length === 0) {
+          return true
+        }
+        let steps = Math.min(delta, state.future.length)
+        let target = null
+        while (steps > 0) {
+          target = state.future.pop() || target
+          if (target) {
+            state.past.push(target)
+          }
+          steps -= 1
+        }
+        if (!target) {
+          return false
+        }
+        if (state.past.length > MAX_ENTRIES) {
+          state.past = state.past.slice(-MAX_ENTRIES)
+        }
+        if (!writeState(state)) {
+          return false
+        }
+        try {
+          window.location.replace(target)
+        } catch (_) {
+          window.location.href = target
+        }
+        return true
+      }
+      return false
+    }
+
+    return {
+      get enabled() {
+        return !storageFailed
+      },
+      go: (delta) => {
+        if (storageFailed) {
+          return false
+        }
+        return navigateByDelta(delta)
+      }
+    }
   }
-  if (document.querySelector("#back")) {
-    document.querySelector("#back").addEventListener("click", (e) => {
-      history.back()
+
+  const frameHistoryController = createFrameHistoryController()
+  const bindHistoryButton = (selector, delta) => {
+    const button = document.querySelector(selector)
+    if (!button) {
+      return
+    }
+    button.addEventListener("click", (event) => {
+      if (frameHistoryController && frameHistoryController.enabled) {
+        event.preventDefault()
+        event.stopPropagation()
+        frameHistoryController.go(delta)
+        return
+      }
+      if (delta < 0) {
+        history.back()
+      } else if (delta > 0) {
+        history.forward()
+      }
     })
   }
-  if (document.querySelector("#forward")) {
-    document.querySelector("#forward").addEventListener("click", (e) => {
-      history.forward()
+
+  if (document.querySelector("#screenshot")) {
+    document.querySelector("#screenshot").addEventListener("click", (e) => {
+      screenshot()
     })
   }
+  bindHistoryButton("#back", -1)
+  bindHistoryButton("#forward", 1)
   if (document.querySelector("#refresh-page")) {
     document.querySelector("#refresh-page").addEventListener("click", (e) => {
       try {

package/server/views/layout.ejs

@@ -33,7 +33,7 @@
       background: var(--layout-gutter-bg);
     }
     body.dark > #dragger {
-      background: rgb(27, 28, 29);
+      background: var(--layout-gutter-bg); 
     }
 
     body {

package/server/views/shell.ejs

@@ -829,7 +829,8 @@ document.addEventListener("DOMContentLoaded", async () => {
       await this.start(mode)
     }
     async uploadFiles(files, overlay) {
-      if (!files || files.length === 0) {
+      const localFiles = Array.isArray(files) ? files : []
+      if (localFiles.length === 0) {
         return
       }
       if (!this.socket || !this.socket.ws || this.socket.ws.readyState !== WebSocket.OPEN) {
@@ -840,8 +841,8 @@ document.addEventListener("DOMContentLoaded", async () => {
         return
       }
       const entries = []
-      for (let i = 0; i < files.length; i++) {
-        const file = files[i]
+      for (let i = 0; i < localFiles.length; i++) {
+        const file = localFiles[i]
         if (!file || typeof file.arrayBuffer !== "function") {
           continue
         }
@@ -893,6 +894,226 @@ document.addEventListener("DOMContentLoaded", async () => {
         }
       }
     }
+    async uploadRemoteResources(resources, overlay) {
+      const remoteItems = Array.isArray(resources) ? resources.filter((item) => item && typeof item.href === "string" && item.href.trim()) : []
+      if (remoteItems.length === 0) {
+        return
+      }
+      const payload = {
+        id: shell_id,
+        cwd: this.uploadContext.cwd,
+        urls: remoteItems
+      }
+      try {
+        if (overlay) {
+          overlay.classList.add("active")
+          overlay.textContent = "Downloading..."
+        }
+        const response = await fetch('/terminal/url-upload', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify(payload)
+        })
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}`)
+        }
+        const result = await response.json().catch(() => ({}))
+        const files = Array.isArray(result.files) ? result.files : []
+        const failures = Array.isArray(result.errors) ? result.errors : []
+        if (files.length > 0) {
+          try {
+            refreshParent({
+              type: "terminal.upload",
+              files
+            })
+            if (typeof reloadMemory === 'function') {
+              reloadMemory()
+            }
+          } catch (_) {}
+          n.Noty({
+            text: files.length > 1 ? `${files.length} files attached` : `File attached`,
+            timeout: 4000
+          })
+        }
+        if (failures.length > 0) {
+          const plural = failures.length > 1
+          n.Noty({
+            text: plural ? `${failures.length} remote files failed to download` : `Remote file failed to download`,
+            type: "error",
+            timeout: 5000
+          })
+        }
+      } catch (error) {
+        n.Noty({
+          text: `Remote upload failed: ${error.message}`,
+          type: "error"
+        })
+      } finally {
+        if (overlay) {
+          overlay.classList.remove("active")
+          overlay.textContent = "Drop files to upload"
+        }
+      }
+    }
+    async collectFilesFromDataTransfer(dataTransfer) {
+      if (!dataTransfer) {
+        return { urls: [] }
+      }
+      const resourceMap = new Map()
+      const ensureResource = (input, nameHint) => {
+        if (!input) {
+          return
+        }
+        let resolved
+        try {
+          resolved = new URL(input, window.location.href)
+        } catch (_) {
+          return
+        }
+        if (!resolved || !resolved.protocol || !/^https?:$/i.test(resolved.protocol)) {
+          return
+        }
+        const href = resolved.href
+        const existing = resourceMap.get(href)
+        if (existing) {
+          if (nameHint && !existing.nameHint) {
+            existing.nameHint = nameHint
+          }
+          return
+        }
+        resourceMap.set(href, { href, url: resolved, nameHint: nameHint || null })
+      }
+      const handleDownloadUrl = (value) => {
+        if (!value) {
+          return
+        }
+        const firstColon = value.indexOf(":")
+        const lastColon = value.lastIndexOf(":")
+        if (firstColon === -1 || lastColon === -1 || lastColon <= firstColon) {
+          ensureResource(value, null)
+          return
+        }
+        const filename = value.slice(firstColon + 1, lastColon)
+        const url = value.slice(lastColon + 1)
+        ensureResource(url, filename)
+      }
+      const handleStringEntry = (type, rawValue) => {
+        if (!rawValue) {
+          return
+        }
+        if (type === "DownloadURL") {
+          handleDownloadUrl(rawValue)
+          return
+        }
+        const value = rawValue.trim()
+        if (!value) {
+          return
+        }
+        if (type === "text/html") {
+          try {
+            const parser = new DOMParser()
+            const doc = parser.parseFromString(value, "text/html")
+            const anchors = doc.querySelectorAll("a[href]")
+            anchors.forEach((anchor) => {
+              const href = anchor.getAttribute("href")
+              const nameHint = anchor.getAttribute("download") || (anchor.textContent ? anchor.textContent.trim() : null)
+              ensureResource(href, nameHint)
+            })
+            const srcElements = doc.querySelectorAll("[src]")
+            srcElements.forEach((element) => {
+              const src = element.getAttribute("src")
+              if (!src) {
+                return
+              }
+              const title = element.getAttribute("download") || element.getAttribute("title") || element.getAttribute("alt") || null
+              ensureResource(src, title)
+            })
+          } catch (error) {
+            console.warn("Failed to parse dropped HTML for resources", error)
+          }
+          return
+        }
+        if (type === "text/x-moz-url") {
+          const parts = value.split(/\r?\n/)
+          const url = parts[0] ? parts[0].trim() : ""
+          const title = parts[1] ? parts[1].trim() : null
+          if (url) {
+            ensureResource(url, title)
+          }
+          return
+      }
+      const lines = value.split(/\r?\n/)
+      for (const line of lines) {
+        const candidate = line.trim()
+        if (!candidate || candidate.startsWith("#")) {
+          continue
+        }
+        let resolvedHref
+        try {
+          const resolved = new URL(candidate, window.location.href)
+          resolvedHref = resolved.href
+        } catch (_) {
+          continue
+        }
+        let decodedHref = resolvedHref
+        try {
+          decodedHref = decodeURIComponent(resolvedHref)
+        } catch (_) {}
+        if (/[<>"']/.test(decodedHref)) {
+          continue
+        }
+        ensureResource(resolvedHref, null)
+      }
+    }
+      const items = dataTransfer.items ? Array.from(dataTransfer.items) : []
+      const stringItems = items.filter((item) => item && item.kind === "string" && typeof item.getAsString === "function")
+      if (stringItems.length > 0) {
+        const stringValues = await Promise.all(stringItems.map((item) => new Promise((resolve) => {
+          try {
+            item.getAsString((value) => resolve({ type: item.type || "text/plain", value }))
+          } catch (_) {
+            resolve(null)
+          }
+        })))
+        for (const entry of stringValues) {
+          if (entry) {
+            handleStringEntry(entry.type, entry.value)
+          }
+        }
+      }
+      const fallbackTypes = ["DownloadURL", "text/uri-list", "text/plain", "text/html", "text/x-moz-url"]
+      if (typeof dataTransfer.getData === "function") {
+        for (const type of fallbackTypes) {
+          try {
+            const value = dataTransfer.getData(type)
+            if (value) {
+              handleStringEntry(type, value)
+            }
+          } catch (_) {}
+        }
+      }
+      const resources = Array.from(resourceMap.values())
+      if (!resources.length) {
+        return { urls: [] }
+      }
+      const urls = resources.map((resource) => {
+        const basePath = resource.url ? resource.url.pathname : new URL(resource.href).pathname
+        let filename = resource.nameHint || basePath.split("/").pop() || "download"
+        try {
+          filename = decodeURIComponent(filename)
+        } catch (_) {}
+        if (!filename) {
+          filename = "download"
+        }
+        return {
+          href: resource.href,
+          name: filename
+        }
+      })
+      return { urls }
+    }
     async createTerm (_theme) {
       console.log(xtermTheme)
       if (!this.term) {
@@ -964,11 +1185,40 @@ document.addEventListener("DOMContentLoaded", async () => {
           prevent(event)
           dragDepth = 0
           dropOverlay.classList.remove("active")
-          const dropped = Array.from(event.dataTransfer ? event.dataTransfer.files || [] : [])
-          if (!dropped.length) {
+          const files = Array.from(event.dataTransfer ? event.dataTransfer.files || [] : [])
+          let remoteResources = []
+          try {
+            const extra = await this.collectFilesFromDataTransfer(event.dataTransfer)
+            if (extra && Array.isArray(extra.urls) && extra.urls.length) {
+              const seenUrls = new Set()
+              remoteResources = extra.urls.filter((item) => {
+                if (!item || typeof item.href !== "string") {
+                  return false
+                }
+                const key = item.href.trim()
+                if (!key || seenUrls.has(key)) {
+                  return false
+                }
+                seenUrls.add(key)
+                return true
+              })
+            }
+          } catch (error) {
+            console.warn("Failed to collect files from drop payload", error)
+          }
+          if (!files.length && (!remoteResources || remoteResources.length === 0)) {
             return
           }
-          await this.uploadFiles(dropped, dropOverlay)
+          try {
+            if (remoteResources && remoteResources.length > 0) {
+              await this.uploadRemoteResources(remoteResources, dropOverlay)
+            }
+          } catch (error) {
+            console.warn("Remote upload failed", error)
+          }
+          if (files.length > 0) {
+            await this.uploadFiles(files, dropOverlay)
+          }
           this.term.focus()
         })
         term.attachCustomKeyEventHandler(event => {

package/server/views/terminal.ejs

@@ -916,7 +916,8 @@ document.addEventListener("DOMContentLoaded", async () => {
       await this.start(mode)
     }
     async uploadFiles(files, overlay) {
-      if (!files || files.length === 0) {
+      const localFiles = Array.isArray(files) ? files : []
+      if (localFiles.length === 0) {
         return
       }
       if (!this.socket || !this.socket.ws || this.socket.ws.readyState !== WebSocket.OPEN) {
@@ -927,8 +928,8 @@ document.addEventListener("DOMContentLoaded", async () => {
         return
       }
       const entries = []
-      for (let i = 0; i < files.length; i++) {
-        const file = files[i]
+      for (let i = 0; i < localFiles.length; i++) {
+        const file = localFiles[i]
         if (!file || typeof file.arrayBuffer !== "function") {
           continue
         }
@@ -980,6 +981,235 @@ document.addEventListener("DOMContentLoaded", async () => {
         }
       }
     }
+    async uploadRemoteResources(resources, overlay) {
+      const remoteItems = Array.isArray(resources) ? resources.filter((item) => item && typeof item.href === "string" && item.href.trim()) : []
+      if (remoteItems.length === 0) {
+        return
+      }
+      const payload = {
+        id: shell_id,
+        cwd: this.uploadContext.cwd,
+        urls: remoteItems
+      }
+      try {
+        if (overlay) {
+          overlay.classList.add("active")
+          overlay.textContent = "Downloading..."
+        }
+        const response = await fetch('/terminal/url-upload', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify(payload)
+        })
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}`)
+        }
+        const result = await response.json().catch(() => ({}))
+        const files = Array.isArray(result.files) ? result.files : []
+        const failures = Array.isArray(result.errors) ? result.errors : []
+        if (files.length > 0) {
+          const mappedFiles = files.map((file) => ({
+            originalName: file.originalName || file.name || file.storedAs,
+            storedAs: file.storedAs,
+            path: file.path,
+            displayPath: file.displayPath || file.path,
+            homeRelativePath: file.homeRelativePath || '',
+            cliPath: file.cliPath || null,
+            cliRelativePath: file.cliRelativePath || null
+          }))
+          try {
+            refreshParent({
+              type: "terminal.upload",
+              files: mappedFiles
+            })
+            if (typeof reloadMemory === 'function') {
+              reloadMemory()
+            }
+          } catch (_) {}
+          n.Noty({
+            text: mappedFiles.length > 1 ? `${mappedFiles.length} files attached` : `File attached`,
+            timeout: 4000
+          })
+        }
+        if (failures.length > 0) {
+          const plural = failures.length > 1
+          n.Noty({
+            text: plural ? `${failures.length} remote files failed to download` : `Remote file failed to download`,
+            type: "error",
+            timeout: 5000
+          })
+        }
+      } catch (error) {
+        n.Noty({
+          text: `Remote upload failed: ${error.message}`,
+          type: "error"
+        })
+      } finally {
+        if (overlay) {
+          overlay.classList.remove("active")
+          overlay.textContent = "Drop files to upload"
+        }
+      }
+    }
+    async collectFilesFromDataTransfer(dataTransfer) {
+      if (!dataTransfer) {
+        return { urls: [] }
+      }
+      const resourceMap = new Map()
+      const ensureResource = (input, nameHint) => {
+        if (!input) {
+          return
+        }
+        let resolved
+        try {
+          resolved = new URL(input, window.location.href)
+        } catch (_) {
+          return
+        }
+        if (!resolved || !resolved.protocol || !/^https?:$/i.test(resolved.protocol)) {
+          return
+        }
+        const href = resolved.href
+        const existing = resourceMap.get(href)
+        if (existing) {
+          if (nameHint && !existing.nameHint) {
+            existing.nameHint = nameHint
+          }
+          return
+        }
+        resourceMap.set(href, { href, url: resolved, nameHint: nameHint || null })
+      }
+      const handleDownloadUrl = (value) => {
+        if (!value) {
+          return
+        }
+        const firstColon = value.indexOf(":")
+        const lastColon = value.lastIndexOf(":")
+        if (firstColon === -1 || lastColon === -1 || lastColon <= firstColon) {
+          ensureResource(value, null)
+          return
+        }
+        const filename = value.slice(firstColon + 1, lastColon)
+        const url = value.slice(lastColon + 1)
+        ensureResource(url, filename)
+      }
+      const handleStringEntry = (type, rawValue) => {
+        if (!rawValue) {
+          return
+        }
+        if (type === "DownloadURL") {
+          handleDownloadUrl(rawValue)
+          return
+        }
+        const value = rawValue.trim()
+        if (!value) {
+          return
+        }
+        if (type === "text/html") {
+          try {
+            const parser = new DOMParser()
+            const doc = parser.parseFromString(value, "text/html")
+            const anchors = doc.querySelectorAll("a[href]")
+            anchors.forEach((anchor) => {
+              const href = anchor.getAttribute("href")
+              const nameHint = anchor.getAttribute("download") || (anchor.textContent ? anchor.textContent.trim() : null)
+              ensureResource(href, nameHint)
+            })
+            const srcElements = doc.querySelectorAll("[src]")
+            srcElements.forEach((element) => {
+              const src = element.getAttribute("src")
+              if (!src) {
+                return
+              }
+              const title = element.getAttribute("download") || element.getAttribute("title") || element.getAttribute("alt") || null
+              ensureResource(src, title)
+            })
+          } catch (error) {
+            console.warn("Failed to parse dropped HTML for resources", error)
+          }
+          return
+        }
+        if (type === "text/x-moz-url") {
+          const parts = value.split(/\r?\n/)
+          const url = parts[0] ? parts[0].trim() : ""
+          const title = parts[1] ? parts[1].trim() : null
+          if (url) {
+            ensureResource(url, title)
+          }
+          return
+      }
+      const lines = value.split(/\r?\n/)
+      for (const line of lines) {
+        const candidate = line.trim()
+        if (!candidate || candidate.startsWith("#")) {
+          continue
+        }
+        let resolvedHref
+        try {
+          const resolved = new URL(candidate, window.location.href)
+          resolvedHref = resolved.href
+        } catch (_) {
+          continue
+        }
+        let decodedHref = resolvedHref
+        try {
+          decodedHref = decodeURIComponent(resolvedHref)
+        } catch (_) {}
+        if (/[<>"']/.test(decodedHref)) {
+          continue
+        }
+        ensureResource(resolvedHref, null)
+      }
+    }
+      const items = dataTransfer.items ? Array.from(dataTransfer.items) : []
+      const stringItems = items.filter((item) => item && item.kind === "string" && typeof item.getAsString === "function")
+      if (stringItems.length > 0) {
+        const stringValues = await Promise.all(stringItems.map((item) => new Promise((resolve) => {
+          try {
+            item.getAsString((value) => resolve({ type: item.type || "text/plain", value }))
+          } catch (_) {
+            resolve(null)
+          }
+        })))
+        for (const entry of stringValues) {
+          if (entry) {
+            handleStringEntry(entry.type, entry.value)
+          }
+        }
+      }
+      const fallbackTypes = ["DownloadURL", "text/uri-list", "text/plain", "text/html", "text/x-moz-url"]
+      if (typeof dataTransfer.getData === "function") {
+        for (const type of fallbackTypes) {
+          try {
+            const value = dataTransfer.getData(type)
+            if (value) {
+              handleStringEntry(type, value)
+            }
+          } catch (_) {}
+        }
+      }
+      const resources = Array.from(resourceMap.values())
+      if (!resources.length) {
+        return { urls: [] }
+      }
+      const urls = resources.map((resource) => {
+        const basePath = resource.url ? resource.url.pathname : new URL(resource.href).pathname
+        let filename = resource.nameHint || basePath.split("/").pop() || "download"
+        try {
+          filename = decodeURIComponent(filename)
+        } catch (_) {}
+        if (!filename) {
+          filename = "download"
+        }
+        return {
+          href: resource.href,
+          name: filename
+        }
+      })
+      return { urls }
+    }
     async createTerm (_theme) {
       if (!this.term) {
         const theme = Object.assign({ }, _theme, {
@@ -1048,11 +1278,44 @@ document.addEventListener("DOMContentLoaded", async () => {
           prevent(event)
           dragDepth = 0
           dropOverlay.classList.remove("active")
-          const dropped = Array.from(event.dataTransfer ? event.dataTransfer.files || [] : [])
-          if (!dropped.length) {
+          const files = Array.from(event.dataTransfer ? event.dataTransfer.files || [] : [])
+          let remoteResources = []
+          try {
+            const extra = await this.collectFilesFromDataTransfer(event.dataTransfer)
+            if (extra && Array.isArray(extra.urls) && extra.urls.length) {
+              const seenUrls = new Set()
+              remoteResources = extra.urls.filter((item) => {
+                if (!item || typeof item.href !== "string") {
+                  return false
+                }
+                const key = item.href.trim()
+                if (!key || seenUrls.has(key)) {
+                  return false
+                }
+                seenUrls.add(key)
+                return true
+              })
+            }
+          } catch (error) {
+            console.warn("Failed to collect files from drop payload", error)
+          }
+          if (!files.length && (!remoteResources || remoteResources.length === 0)) {
+            n.Noty({
+              text: "Dropped item did not include an accessible file",
+              type: "error"
+            })
             return
           }
-          await this.uploadFiles(dropped, dropOverlay)
+          try {
+            if (remoteResources && remoteResources.length > 0) {
+              await this.uploadRemoteResources(remoteResources, dropOverlay)
+            }
+          } catch (error) {
+            console.warn("Remote upload failed", error)
+          }
+          if (files.length > 0) {
+            await this.uploadFiles(files, dropOverlay)
+          }
           this.term.focus()
         })
         term.attachCustomKeyEventHandler(event => {