pterm 0.0.23 → 0.0.25

package/util.js

@@ -1,16 +1,54 @@
+const fs = require('fs')
 const os = require('os')
 const axios = require('axios')
 const path = require('path')
 const RPC = require('./rpc')
+const { resolveHttpBaseUrl, resolveWsBaseUrl } = require('./endpoint')
+const { isPinokioRef, parsePinokioRef, buildPinokioRef } = require('./target')
 class Util {
+  resolveLocalPath(value) {
+    const raw = String(value)
+    if (raw.startsWith('~/')) {
+      return path.resolve(os.homedir(), raw.slice(2))
+    }
+    return path.resolve(process.cwd(), raw)
+  }
   printJson(payload) {
     process.stdout.write(JSON.stringify(payload, null, 2))
     process.stdout.write("\n")
   }
+  formatRpcError(payload) {
+    if (typeof payload !== "string") {
+      return JSON.stringify(payload)
+    }
+    const [firstLine] = payload.split(/\r?\n/)
+    return firstLine || payload
+  }
   registryBase() {
     const value = String(process.env.PINOKIO_REGISTRY_API_BASE || "https://api.pinokio.co").trim()
     return value.replace(/\/$/, "")
   }
+  async resolveResourceRequestTarget(value) {
+    const raw = String(value || '').trim()
+    if (isPinokioRef(raw)) {
+      const parsedRef = parsePinokioRef(raw)
+      if (!parsedRef.valid) {
+        throw new Error(parsedRef.error || 'Invalid ref')
+      }
+      return {
+        baseUrl: await resolveHttpBaseUrl(),
+        ref: buildPinokioRef(parsedRef),
+        legacyId: null,
+        parsedRef
+      }
+    }
+    return {
+      baseUrl: await resolveHttpBaseUrl(),
+      ref: null,
+      legacyId: raw,
+      parsedRef: null
+    }
+  }
   async search(argv) {
     const query = (argv._.slice(1).join(" ") || argv.q || "").trim()
     const params = { q: query }
@@ -32,7 +70,8 @@ class Util {
         params.limit = String(limit)
       }
     }
-    const response = await axios.get("http://localhost:42000/apps/search", {
+    const baseUrl = await resolveHttpBaseUrl()
+    const response = await axios.get(`${baseUrl}/apps/search`, {
       params
     })
     this.printJson(response.data)
@@ -71,15 +110,20 @@ class Util {
       console.error("required argument: <app_id>")
       return
     }
-    const appId = argv._[1]
+    const target = await this.resolveResourceRequestTarget(argv._[1])
     const probe = argv.probe ? "1" : "0"
     const timeout = argv.timeout ? Number.parseInt(String(argv.timeout), 10) : null
     const params = new URLSearchParams()
+    if (target.ref) {
+      params.set("ref", target.ref)
+    }
     params.set("probe", probe)
     if (Number.isFinite(timeout) && timeout > 0) {
       params.set("timeout", String(timeout))
     }
-    const url = `http://localhost:42000/apps/status/${encodeURIComponent(appId)}?${params.toString()}`
+    const url = target.ref
+      ? `${target.baseUrl}/pinokio/resource/status?${params.toString()}`
+      : `${target.baseUrl}/apps/status/${encodeURIComponent(target.legacyId)}?${params.toString()}`
     const response = await axios.get(url)
     this.printJson(response.data)
   }
@@ -88,8 +132,11 @@ class Util {
       console.error("required argument: <app_id>")
       return
     }
-    const appId = argv._[1]
+    const target = await this.resolveResourceRequestTarget(argv._[1])
     const params = new URLSearchParams()
+    if (target.ref) {
+      params.set("ref", target.ref)
+    }
     if (argv.script) {
       params.set("script", String(argv.script))
     }
@@ -100,15 +147,71 @@ class Util {
       }
     }
     const suffix = params.toString() ? `?${params.toString()}` : ""
-    const url = `http://localhost:42000/apps/logs/${encodeURIComponent(appId)}${suffix}`
+    const url = target.ref
+      ? `${target.baseUrl}/pinokio/resource/logs${suffix}`
+      : `${target.baseUrl}/apps/logs/${encodeURIComponent(target.legacyId)}${suffix}`
     const response = await axios.get(url)
     this.printJson(response.data)
   }
+  async upload(argv) {
+    if (argv._.length <= 2) {
+      console.error("required arguments: <app_id> <file...>")
+      process.exitCode = 1
+      return
+    }
+    const target = await this.resolveResourceRequestTarget(argv._[1])
+    if (!target.ref && !target.legacyId) {
+      console.error("required argument: <app_id>")
+      process.exitCode = 1
+      return
+    }
+    const fileArgs = argv._.slice(2)
+    const form = new FormData()
+    for (const rawPath of fileArgs) {
+      const resolvedPath = this.resolveLocalPath(rawPath)
+      let stat
+      try {
+        stat = await fs.promises.stat(resolvedPath)
+      } catch (_) {
+        console.error(`file not found: ${resolvedPath}`)
+        process.exitCode = 1
+        return
+      }
+      if (!stat.isFile()) {
+        console.error(`not a file: ${resolvedPath}`)
+        process.exitCode = 1
+        return
+      }
+      const buffer = await fs.promises.readFile(resolvedPath)
+      form.append('files', new Blob([buffer]), path.basename(resolvedPath))
+    }
+    const uploadUrl = target.ref
+      ? `${target.baseUrl}/pinokio/resource/upload?ref=${encodeURIComponent(target.ref)}`
+      : `${target.baseUrl}/apps/${encodeURIComponent(target.legacyId)}/upload`
+    const response = await fetch(uploadUrl, {
+      method: 'POST',
+      body: form
+    })
+    const raw = await response.text()
+    let payload
+    try {
+      payload = raw ? JSON.parse(raw) : {}
+    } catch (_) {
+      payload = { error: raw || `Upload failed (${response.status})` }
+    }
+    if (!response.ok) {
+      this.printJson(payload)
+      process.exitCode = 1
+      return
+    }
+    this.printJson(payload)
+  }
   async stars(argv) {
     const query = (argv._.slice(1).join(" ") || argv.q || "").trim().toLowerCase()
+    const baseUrl = await resolveHttpBaseUrl()
     const [preferenceResponse, appResponse] = await Promise.all([
-      axios.get("http://localhost:42000/apps/preferences"),
-      axios.get("http://localhost:42000/info/apps")
+      axios.get(`${baseUrl}/apps/preferences`),
+      axios.get(`${baseUrl}/info/apps`)
     ])
     const preferenceItems = preferenceResponse && preferenceResponse.data && preferenceResponse.data.items
       ? preferenceResponse.data.items
@@ -158,7 +261,8 @@ class Util {
       return
     }
     const appId = argv._[1]
-    const response = await axios.put(`http://localhost:42000/apps/preferences/${encodeURIComponent(appId)}`, {
+    const baseUrl = await resolveHttpBaseUrl()
+    const response = await axios.put(`${baseUrl}/apps/preferences/${encodeURIComponent(appId)}`, {
       starred: Boolean(starred)
     })
     this.printJson(response.data)
@@ -174,7 +278,8 @@ class Util {
       return
     }
     try {
-      const response = await axios.get(`http://localhost:42000/pinokio/path/${encodeURIComponent(command)}`)
+      const baseUrl = await resolveHttpBaseUrl()
+      const response = await axios.get(`${baseUrl}/pinokio/path/${encodeURIComponent(command)}`)
       if (argv.json) {
         this.printJson(response.data)
       } else if (response.data && response.data.path) {
@@ -191,7 +296,8 @@ class Util {
     }
   }
   async home(argv) {
-    const response = await axios.get("http://localhost:42000/pinokio/home")
+    const baseUrl = await resolveHttpBaseUrl()
+    const response = await axios.get(`${baseUrl}/pinokio/home`)
     if (argv.json) {
       this.printJson(response.data)
     } else if (response.data && response.data.path) {
@@ -200,9 +306,9 @@ class Util {
     }
   }
   async filepicker(argv) {
-    const rpc = new RPC("ws://localhost:42000")
+    const rpc = new RPC(await resolveWsBaseUrl())
     if (argv.path) {
-      argv.path = path.resolve(process.cwd(), argv.path)
+      argv.path = this.resolveLocalPath(argv.path)
     }
     await rpc.run({
       method: "kernel.bin.filepicker",
@@ -229,7 +335,8 @@ class Util {
       if (argv._.length > 2) {
         payload.text = argv._[2]
       }
-      let response = await axios.post("http://localhost:42000/clipboard", payload)
+      const baseUrl = await resolveHttpBaseUrl()
+      let response = await axios.post(`${baseUrl}/clipboard`, payload)
       if (response.data && response.data.text) {
         console.log(response.data.text)
       }
@@ -240,19 +347,92 @@ class Util {
       argv.message = argv._[1]
     }
     if (argv.image && !path.isAbsolute(argv.image)) {
-      argv.image = path.resolve(process.cwd(), argv.image)
+      argv.image = this.resolveLocalPath(argv.image)
     }
-    let response = await axios.post("http://localhost:42000/push", argv)
+    const baseUrl = await resolveHttpBaseUrl()
+    let response = await axios.post(`${baseUrl}/push`, argv)
     return response
   }
   async open_url(url) {
-    let response = await axios.post("http://localhost:42000/go", { url })
+    const baseUrl = await resolveHttpBaseUrl()
+    let response = await axios.post(`${baseUrl}/go`, { url })
     return response
   }
+  async open(argv) {
+    if (argv._.length <= 1) {
+      console.error("required argument: <url>")
+      process.exitCode = 1
+      return
+    }
+    const url = String(argv._[1] || '').trim()
+    if (!url) {
+      console.error("required argument: <url>")
+      process.exitCode = 1
+      return
+    }
+    const payload = { url }
+    if (typeof argv.peer === 'string' && argv.peer.trim()) {
+      payload.peer = argv.peer.trim()
+    }
+    if (typeof argv.surface === 'string' && argv.surface.trim()) {
+      payload.surface = argv.surface.trim()
+    }
+    if (typeof argv.preset === 'string' && argv.preset.trim()) {
+      payload.preset = argv.preset.trim()
+    }
+    const baseUrl = await resolveHttpBaseUrl()
+    const response = await axios.post(`${baseUrl}/pinokio/open`, payload)
+    this.printJson(response.data)
+  }
+  async appDownload(argv) {
+    if (argv._.length <= 1) {
+      console.error("required argument: <uri>")
+      process.exitCode = 1
+      return
+    }
+    const uri = String(argv._[1]).trim()
+    const name = argv._.length > 2 ? String(argv._[2]).trim() : ""
+    const branch = typeof argv.b === "string"
+      ? argv.b.trim()
+      : (typeof argv.branch === "string" ? argv.branch.trim() : "")
+    const rpc = new RPC(await resolveWsBaseUrl())
+    let exitCode = 0
+    await rpc.run({
+      method: "app.download",
+      params: {
+        uri,
+        ...(name ? { name } : {}),
+        ...(branch ? { branch } : {})
+      }
+    }, (packet) => {
+      if (packet.type === "result") {
+        if (!packet.data || packet.data.ok === false) {
+          exitCode = 1
+          const message = packet.data && packet.data.error ? packet.data.error : "download failed"
+          if (packet.data && packet.data.path) {
+            console.error(`${message}: ${packet.data.path}`)
+          } else {
+            console.error(message)
+          }
+        }
+        rpc.close()
+      } else if (packet.type === "stream") {
+        process.stdout.write(packet.data.raw)
+      } else if (packet.type === "error") {
+        exitCode = 1
+        console.error(this.formatRpcError(packet.data))
+        rpc.close()
+      }
+    })
+    if (exitCode !== 0) {
+      process.exitCode = exitCode
+    }
+  }
+  // Keep the legacy URL download flow for `pterm run <url>`.
   async download(argv) {
     if (argv._.length > 1) {
       let uri = argv._[1]
-      const rpc = new RPC("ws://localhost:42000")
+      const rpc = new RPC(await resolveWsBaseUrl())
       await rpc.run({
         method: "kernel.bin.install2",
         params: {}