pinokiod 7.0.3 → 7.0.5

package/package.json

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

package/prototype/system/SKILL_PINOKIO.md

@@ -40,7 +40,7 @@ Failure handling:
 
 Use direct `pterm` commands for control-plane operations:
 
-`pterm search`, `pterm status`, `pterm run`, `pterm logs`, `pterm which`, `pterm stars`, `pterm star` / `pterm unstar`, `pterm registry search`, `pterm download`
+`pterm search`, `pterm status`, `pterm run`, `pterm logs`, `pterm upload`, `pterm which`, `pterm stars`, `pterm star` / `pterm unstar`, `pterm registry search`, `pterm download`
 
 Do not run update commands from this skill.
 Once a Pinokio-managed app is selected, treat `pterm` and the launcher-managed interfaces as the source of truth for lifecycle and execution. Do not switch to repo-local CLIs or bundled app binaries unless the user explicitly asks for CLI mode.
@@ -52,6 +52,7 @@ Follow these sections in order:
 2. Only use Registry Fallback if Search App found no suitable installed app and the user approved it.
 3. Then use Run App.
 4. Then use API Call Strategy if the app exposes an automatable API.
+5. Only use Parallel Mode when the user explicitly asks to use multiple apps or multiple machines in parallel.
 
 ### 1. Search App
 
@@ -76,6 +77,8 @@ Follow these sections in order:
     - relevant apps with `ready=true`
     - otherwise relevant apps with `running=true`
     - otherwise relevant offline apps
+  - This runtime priority applies across all relevant candidates, not just the same app on different machines.
+  - If multiple different apps can satisfy the request, prefer the already-ready one over launching another offline app.
   - Within the selected runtime tier, rank by user preference:
     - exact `app_id`/title match (for explicit app requests)
     - `starred=true`
@@ -86,7 +89,7 @@ Follow these sections in order:
     - higher `score`
 - If the top candidate is not clearly better than alternatives, ask user once with top 3 candidates.
 - If a suitable installed app is found, select it and continue to Run App.
-- Federated search may return apps from other Pinokio machines on the LAN:
+- Search results may include apps from other reachable Pinokio machines:
   - remote results use `app_id` in the form `<app_id>@<source.host>`
   - `source.local=false` means the result is from another machine
   - treat remote results as separate apps; do not merge them with the local app of the same name
@@ -106,33 +109,39 @@ Follow these sections in order:
 
 ### 3. Run App
 
-- Once you have a selected local app, use `pterm status`.
+- Once you have a selected app, use `pterm status`.
 - Poll every 2s.
 - Use status fields from pterm output:
   - `path`: absolute app path to use with `pterm run`
   - `running`: script is running
   - `ready`: app is reachable/ready
   - `ready_url`: default base URL for API calls when available
-  - `external_ready_urls`: optional ordered non-loopback app URLs for caller-side access; use them only when `ready_url` fails due to loopback restrictions
+  - `external_ready_urls`: optional ordered non-loopback app URLs for caller-side access; use them only when `ready_url` is missing or unusable due to loopback restrictions
   - `state`: `offline | starting | online`
-  - `source`: machine identity for federated results
+  - `source`: machine identity for results from other reachable Pinokio machines
 - Use `--probe` only for readiness confirmation before first API call (or when status is uncertain).
 - Use `--timeout=<ms>` only when you need a non-default probe timeout.
 - Treat `offline` as expected before first run.
 - If `app_id` contains `@<host>` or `source.local=false`, the app is remote:
   - treat `path` and `ready_url` as source-local fields, not caller-usable local paths/URLs
   - use `external_ready_urls` in order for caller-side API access when available
-  - do not assume `pterm run <path>` can launch a remote app from the current machine
+  - use `pterm run <app_id>` for remote launch; do not use a remote machine's `path` value as a local path
+  - for remote path-based tasks:
+    - this applies only when the task expects filesystem paths such as `/path/to/file`
+    - do not pass local paths from this machine to the remote app
+    - first run `pterm upload <app_id> <file...>`
+    - then use the returned remote `path` values
 - If app is offline or not ready, run it:
-  - Run `pterm run <app_path>`.
+  - For remote apps, run `pterm run <app_id>`.
+  - Otherwise run `pterm run <app_path>`.
   - If the launcher has no explicit default item or the launch action depends on current menu state, infer one or more ordered selectors from the launcher's current menu and pass them via repeated `--default`.
   - Prefer stable launcher selectors such as `run.js?mode=Default`, then broader fallbacks like `run.js`, then installation fallback like `install.js`.
   - Continue polling with `pterm status <app_id>`.
   - Default startup timeout: 180s.
 - Success criteria:
   - `state=online` and `ready=true`
-  - use `ready_url` by default
-  - if `ready_url` fails because the client cannot access loopback and `external_ready_urls` exists, try those URLs in order
+  - use `ready_url` by default when it exists and is caller-usable
+  - if `ready_url` is missing, or it fails because the client cannot access loopback, and `external_ready_urls` exists, try those URLs in order
   - missing `external_ready_urls` is normal; it usually means network sharing is off
 - Failure criteria:
   - timeout before success
@@ -165,6 +174,27 @@ Follow these sections in order:
 - Do not execute the app's internal Python/Node/bundled CLI as a fallback when `pterm` has already selected a launcher-managed app.
 - If no automatable API exists after the app is running, report that clearly instead of bypassing the launcher with an internal CLI.
 
+### 5. Parallel Mode (explicit only)
+
+- Use this section only when the user explicitly asks to:
+  - run on multiple machines
+  - use multiple apps in parallel
+  - compare multiple relevant apps side by side
+  - generate multiple outputs concurrently
+- Do not use this mode by default.
+- Keep each selected app as a separate target, including remote results like `<app_id>@<source.host>`.
+- Selection rules:
+  - if the user asks for all relevant apps, use all relevant search results that can perform the task
+  - if the user asks for a specific count, use the top N relevant search results after normal search ranking
+  - if the user asks for parallel use but does not specify how many apps or machines to use, ask once
+- Ranking still applies in this mode:
+  - prefer `ready` apps first
+  - then `running` apps
+  - then offline apps if more targets are still needed
+- Run and monitor each selected target independently.
+- Keep outputs labeled by target `app_id`.
+- For remote path-based tasks, run `pterm upload <app_id> <file...>` separately for each remote target and use that target's returned remote `path` values.
+
 ## Behavior Rules
 
 - Do not add app-specific hardcoding when user gave only capability (for example "tts").

package/server/routes/apps.js

@@ -1,8 +1,15 @@
 const express = require('express')
+const fs = require('fs')
+const path = require('path')
+const crypto = require('crypto')
 const axios = require('axios')
+const multer = require('multer')
+const FormData = require('form-data')
+const sanitize = require('sanitize-filename')
 
 const DEFAULT_PEER_PORT = 42000
 const DEFAULT_PEER_TIMEOUT_MS = 2500
+const DEFAULT_PEER_UPLOAD_TIMEOUT_MS = 30000
 const IPV4_HOST_PATTERN = /^(?:\d{1,3}\.){3}\d{1,3}$/
 
 const isQualifiedHost = (value = '') => {
@@ -55,6 +62,7 @@ module.exports = function registerAppRoutes(app, { registry, preferences, appSea
   }
 
   const router = express.Router()
+  const upload = multer()
 
   const asyncHandler = (fn) => (req, res, next) => {
     Promise.resolve(fn(req, res, next)).catch(next)
@@ -189,6 +197,60 @@ module.exports = function registerAppRoutes(app, { registry, preferences, appSea
     }
     return Object.keys(info).filter((host) => host && host !== localHost)
   }
+  const uniqueUploadPath = async (directory, originalName) => {
+    const parsed = path.parse(originalName)
+    const baseName = parsed.name || 'upload'
+    const ext = parsed.ext || ''
+    let counter = 0
+    while (true) {
+      const candidateName = counter === 0
+        ? `${baseName}${ext}`
+        : `${baseName}-${counter}${ext}`
+      const candidatePath = path.join(directory, candidateName)
+      try {
+        await fs.promises.access(candidatePath)
+        counter += 1
+      } catch (_) {
+        return {
+          name: candidateName,
+          path: candidatePath
+        }
+      }
+    }
+  }
+  const storeAppUploads = async (appPath, files = []) => {
+    const token = crypto.randomBytes(16).toString('hex')
+    const uploadDir = path.join(appPath, '.pinokio-temp', 'uploads', token)
+    await fs.promises.mkdir(uploadDir, { recursive: true })
+    const stored = []
+    for (const file of files) {
+      if (!file || !file.buffer) {
+        continue
+      }
+      const originalName = path.basename(typeof file.originalname === 'string' && file.originalname.trim()
+        ? file.originalname.trim()
+        : 'upload')
+      const safeName = sanitize(originalName) || `upload-${Date.now()}`
+      const target = await uniqueUploadPath(uploadDir, safeName)
+      await fs.promises.writeFile(target.path, file.buffer)
+      stored.push({
+        name: originalName,
+        path: target.path,
+        size: typeof file.size === 'number' ? file.size : file.buffer.length,
+        mimeType: typeof file.mimetype === 'string' ? file.mimetype : ''
+      })
+    }
+    return {
+      token,
+      files: stored
+    }
+  }
+  const decorateUploadResult = (uploadResult, source, appId) => {
+    const next = uploadResult && typeof uploadResult === 'object' ? { ...uploadResult } : {}
+    next.app_id = qualifyAppId(appId || next.app_id || '', source.host)
+    next.source = source
+    return next
+  }
   const mergeSearchApps = (localApps, remoteApps, query = '') => {
     const merged = []
     const seen = new Set()
@@ -393,6 +455,72 @@ module.exports = function registerAppRoutes(app, { registry, preferences, appSea
     })
   }))
 
+  router.post('/apps/:app_id/upload', upload.any(), asyncHandler(async (req, res) => {
+    const parsedAppId = parseQualifiedAppId(req.params.app_id)
+    const requestedAppId = parsedAppId.app_id || req.params.app_id
+    const remoteHost = parsedAppId.qualified ? parsedAppId.host : null
+    const files = Array.isArray(req.files) ? req.files : []
+    if (files.length === 0) {
+      res.status(400).json({ error: 'No files provided' })
+      return
+    }
+    if (remoteHost && remoteHost !== currentPeerHost()) {
+      try {
+        const form = new FormData()
+        for (const file of files) {
+          if (!file || !file.buffer) {
+            continue
+          }
+          form.append('files', file.buffer, {
+            filename: path.basename(file.originalname || 'upload'),
+            contentType: file.mimetype || 'application/octet-stream',
+            knownLength: typeof file.size === 'number' ? file.size : file.buffer.length
+          })
+        }
+        const response = await axios.post(`http://${remoteHost}:${peerPort()}/apps/${encodeURIComponent(requestedAppId)}/upload`, form, {
+          timeout: DEFAULT_PEER_UPLOAD_TIMEOUT_MS,
+          maxBodyLength: Infinity,
+          maxContentLength: Infinity,
+          headers: {
+            ...peerRequestHeaders(req),
+            ...form.getHeaders()
+          }
+        })
+        res.json(decorateUploadResult(response.data, buildSource(remoteHost, false), requestedAppId))
+        return
+      } catch (error) {
+        if (error && error.response) {
+          res.status(error.response.status).json(error.response.data)
+          return
+        }
+        res.status(502).json({
+          error: 'Peer upload unavailable',
+          app_id: qualifyAppId(requestedAppId, remoteHost),
+          source: buildSource(remoteHost, false)
+        })
+        return
+      }
+    }
+    const appId = registry.normalizeAppId(requestedAppId)
+    if (!appId) {
+      res.status(400).json({ error: 'Invalid app_id' })
+      return
+    }
+    const status = await registry.buildAppStatus(appId, {
+      source: req.$source || null
+    })
+    if (!status || !status.path) {
+      res.status(404).json({ error: 'App not found', app_id: appId })
+      return
+    }
+    const payload = await storeAppUploads(status.path, files)
+    if (!Array.isArray(payload.files) || payload.files.length === 0) {
+      res.status(400).json({ error: 'No valid files provided', app_id: appId })
+      return
+    }
+    res.json(decorateUploadResult(payload, buildSource(currentPeerHost(), true), appId))
+  }))
+
   router.get('/apps/status/:app_id', asyncHandler(async (req, res) => {
     const parsedAppId = parseQualifiedAppId(req.params.app_id)
     const requestedAppId = parsedAppId.app_id || req.params.app_id
@@ -449,7 +577,45 @@ module.exports = function registerAppRoutes(app, { registry, preferences, appSea
   }))
 
   router.get('/apps/logs/:app_id', asyncHandler(async (req, res) => {
-    const appId = registry.normalizeAppId(req.params.app_id)
+    const parsedAppId = parseQualifiedAppId(req.params.app_id)
+    const requestedAppId = parsedAppId.app_id || req.params.app_id
+    const remoteHost = parsedAppId.qualified ? parsedAppId.host : null
+    if (remoteHost && remoteHost !== currentPeerHost()) {
+      try {
+        const params = {}
+        if (typeof req.query.script === 'string' && req.query.script.trim()) {
+          params.script = req.query.script
+        }
+        const tail = registry.parseTailCount(req.query.tail, 200)
+        if (Number.isFinite(tail) && tail > 0) {
+          params.tail = String(tail)
+        }
+        const response = await axios.get(`http://${remoteHost}:${peerPort()}/apps/logs/${encodeURIComponent(requestedAppId)}`, {
+          timeout: DEFAULT_PEER_TIMEOUT_MS,
+          headers: peerRequestHeaders(req),
+          params
+        })
+        const payload = response && response.data && typeof response.data === 'object'
+          ? { ...response.data }
+          : {}
+        payload.app_id = qualifyAppId(requestedAppId, remoteHost)
+        payload.source = buildSource(remoteHost, false)
+        res.json(payload)
+        return
+      } catch (error) {
+        if (error && error.response) {
+          res.status(error.response.status).json(error.response.data)
+          return
+        }
+        res.status(502).json({
+          error: 'Peer logs unavailable',
+          app_id: qualifyAppId(requestedAppId, remoteHost),
+          source: buildSource(remoteHost, false)
+        })
+        return
+      }
+    }
+    const appId = registry.normalizeAppId(requestedAppId)
     if (!appId) {
       res.status(400).json({ error: 'Invalid app_id' })
       return