pinokiod 7.0.0 → 7.0.2

package/kernel/shells.js

@@ -254,6 +254,7 @@ class Shells {
     let liveEventAnsiCarry = ""
 
     // Keep cross-chunk event matching, but normalize terminal styling away first.
+    // Preserve line boundaries so later shell banners cannot fuse onto prior matches.
     const findLiveEventCarryIndex = (value = "") => {
       if (!value) {
         return value.length
@@ -319,7 +320,9 @@ class Shells {
       if (combined.length === 0) {
         return ""
       }
-      return sh.stripAnsi(combined).replaceAll(/[\r\n]/g, "")
+      return sh.stripAnsi(combined)
+        .replaceAll(/\r\n/g, "\n")
+        .replaceAll(/\r/g, "\n")
     }
 
     // if error doesn't exist, add default "error:" event

package/package.json

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

package/prototype/system/SKILL_PINOKIO.md

@@ -16,43 +16,33 @@ Assume `pterm` is preinstalled and up to date.
 
 If running outside Pinokio's own shell, do not assume `pterm` is on `PATH`.
 
-1. If the client can execute shell commands, first check whether `pterm` already works by name in the current shell.
-2. If `pterm` works by name, use that command form for all `pterm` commands in this skill.
-3. If `pterm` does not work by name or shell command execution is unavailable, resolve `pterm` via `GET http://127.0.0.1:42000/pinokio/path/pterm`.
-4. Read `path` from the response.
-5. Normalize the resolved path for the current platform and shell before executing it.
-   - On Windows, if the resolved path has no executable Windows extension, prefer a sibling shim such as `.cmd` or `.ps1` when present.
-6. Use the working command/path form consistently for all `pterm` commands in this skill.
-7. If lookup fails, do not immediately conclude that Pinokio is not running.
-8. Distinguish failure modes before stopping:
-   - `EPERM` / `EACCES` / sandbox denial to `127.0.0.1:42000`:
-     - treat this as a local permission problem, not a missing runtime
-     - ask for permission first if the client supports permission prompts, escalation, or tool approval
-     - rerun the same probe after permission is granted
-     - if permission prompts are unavailable, report that loopback access is blocked by the client/sandbox
-   - timeout / connection refused / DNS failure:
-     - report that the control plane is unreachable rather than claiming `pterm` is uninstalled
-   - HTTP success with missing/empty `path`:
-     - continue with fallback path checks below before concluding `pterm` is unavailable
-9. If the control-plane probe is blocked or returns an empty path, check common local `pterm` locations:
-   - `which pterm` or `where pterm`
-10. If a local `pterm` binary exists, normalize it for the current shell/platform, use it, and continue. If later `pterm` commands fail against `127.0.0.1:42000` with permission errors, report a loopback permission issue explicitly.
-11. Only report "`pterm` unavailable" when both the command-form probe and the resolved/fallback path checks fail.
+If `pterm` is not already executable, use the first executable match from these sources:
+
+- Pinokio-managed path from `~/.pinokio/config.json` file's `home` attribute:
+  macOS/Linux: `<home>/bin/npm/bin/pterm`
+  Windows: `<home>\\bin\\npm\\pterm`
+  Optional fallback: `<home>/bin/pterm`
+
+- Control-plane path lookup:
+  `GET http://127.0.0.1:42000/pinokio/path/pterm`
+  If loopback is unreachable and `access` exists in `~/.pinokio/config.json`, retry the same request against `<protocol>://<host>:<port>`.
+
+- Generic local lookup:
+  `which pterm` / `where pterm`
+
+Normalize whichever path you resolve before use.
+- On Windows, if the resolved path has no executable Windows extension, prefer a sibling `.cmd` or `.ps1`.
+
+Failure handling:
+- `EPERM` / `EACCES` / sandbox denial: treat as a client permission problem, ask for permission first when possible, and rerun the same probe or `pterm` command after permission is granted.
+- timeout / connection refused / DNS failure: report that the Pinokio control plane is unreachable rather than claiming `pterm` is uninstalled.
+- Only report "`pterm` unavailable" when the config/home-derived path, control-plane path resolution, and local path checks all fail.
 
 Use direct `pterm` commands for control-plane operations:
 
-1. `pterm search "<query>"`
-2. `pterm status <app_id>`
-3. `pterm run <app_path> [--default <selector>]...`
-4. `pterm logs <app_id> --tail 200`
-5. `pterm which <command>`
-6. `pterm stars` (optional: inspect user-pinned favorites)
-7. `pterm star <app_id>` / `pterm unstar <app_id>` (only when user explicitly asks to change preference)
-8. `pterm registry search "<query>"` (only after no suitable local result and user approval)
-9. `pterm download <uri> [name]` (only after a registry result is selected)
+`pterm search`, `pterm status`, `pterm run`, `pterm logs`, `pterm which`, `pterm stars`, `pterm star` / `pterm unstar`, `pterm registry search`, `pterm download`
 
 Do not run update commands from this skill.
-Use `pterm download` only after local search fails, the user approves registry search, and a registry app is selected.
 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.
 
 ## How to use
@@ -94,10 +84,12 @@ Follow these sections in order:
     - higher `launch_count_total` (if available)
     - more recent `last_launch_at` (if available)
     - higher `score`
-  - Do not choose an offline app over a relevant `ready` or `running` app.
-  - Do not choose a non-starred app over a relevant starred app in the same runtime tier unless the starred app is clearly not a useful match.
 - 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:
+  - 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
 
 ### 2. Registry Fallback
 
@@ -110,7 +102,6 @@ Follow these sections in order:
   - if `pterm download <uri>` fails with `already exists`, ask the user for a local folder name and retry with `pterm download <uri> <name>`
   - if the user wants a specific local folder name or another copy of the same repo, use `pterm download <uri> <name>`
   - then run the downloaded app with `pterm run <local_app_path_or_name>`
-- Do not use `pterm registry search` automatically.
 - Do not use `pterm run <url>` for the registry flow.
 
 ### 3. Run App
@@ -121,11 +112,17 @@ Follow these sections in order:
   - `path`: absolute app path to use with `pterm run`
   - `running`: script is running
   - `ready`: app is reachable/ready
-  - `ready_url`: base URL for API calls when available
+  - `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
   - `state`: `offline | starting | online`
+  - `source`: machine identity for federated results
 - 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
 - If app is offline or not ready, run it:
   - 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`.
@@ -134,8 +131,9 @@ Follow these sections in order:
   - Default startup timeout: 180s.
 - Success criteria:
   - `state=online` and `ready=true`
-  - if `ready_url` exists, use it as API base URL
-  - treat `ready_url` plus a generated or reused client as the default execution path for app functionality
+  - 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
+  - missing `external_ready_urls` is normal; it usually means network sharing is off
 - Failure criteria:
   - timeout before success
   - app drops back to `offline` during startup after a run attempt
@@ -176,24 +174,12 @@ Follow these sections in order:
 - Prefer returning full logs over brittle deterministic error parsing.
 - REST endpoints may be used for diagnostics only when pterm is unavailable; do not claim full install/launch lifecycle completion without compatible pterm commands.
 - Do not keep searching after app selection; move to status/run.
+- Do not assume `external_ready_urls` exists; localhost-only apps are normal.
 - Do not conflate loopback access failure, sandbox denial, or missing permission with "Pinokio is not running" or "`pterm` is not installed."
-- On localhost permission failure, prefer asking for permission over asking the user to manually run commands.
-- If `127.0.0.1:42000` is blocked but local `pterm` exists, explicitly tell the user this looks like a client permission/sandbox issue.
-
-## Example A (Capability Only)
-
-User: "Generate TTS from this text: hello world"
-
-1. Use the Search App workflow with `pterm search "tts speech synthesis" --mode balanced --min-match 2 --limit 8`.
-2. If a suitable installed app is found, continue to Run App.
-3. Otherwise, use the Registry Fallback workflow:
-   - ask before `pterm registry search`
-   - after selection: `pterm download <uri>`
-   - if needed after `already exists`, ask for a local folder name and retry with `pterm download <uri> <name>`
-   - then `pterm run <local_app_path_or_name>`
-4. Continue with Run App and then API Call Strategy.
+- On `pterm` permission failure, prefer asking for permission over asking the user to manually run commands.
+- If `pterm` exists locally but cannot reach the control plane, explicitly tell the user this looks like a client permission/sandbox issue.
 
-## Example B (No Launcher Default)
+## Example
 
 User: "Launch FaceFusion"
 

package/server/index.js

@@ -4119,6 +4119,31 @@ class Server {
     }
     return accessPoints
   }
+  persistAccessConfig() {
+    if (!this.kernel || !this.kernel.store) {
+      return
+    }
+    const host = this.kernel && this.kernel.peer && this.kernel.peer.host
+      ? String(this.kernel.peer.host).trim()
+      : ''
+    const candidates = Array.isArray(this.kernel?.peer?.host_candidates)
+      ? this.kernel.peer.host_candidates
+        .map((candidate) => candidate && candidate.address ? String(candidate.address).trim() : '')
+        .filter(Boolean)
+      : []
+    const accessHost = host || candidates[0] || ''
+    if (!accessHost || accessHost === '127.0.0.1' || accessHost === 'localhost') {
+      this.kernel.store.delete('access')
+      return
+    }
+    this.kernel.store.set('access', {
+      protocol: 'http',
+      host: accessHost,
+      port: this.port,
+      candidates: Array.from(new Set([accessHost].concat(candidates))),
+      updated_at: new Date().toISOString()
+    })
+  }
   async composePeerAccessPayload() {
     let peer_access_points = []
     try {
@@ -5066,6 +5091,7 @@ class Server {
       await Environment.init({}, this.kernel)
     }
     this.kernel.server_port = this.port
+    this.persistAccessConfig()
     this.kernel.peer.start(this.kernel)
 
 
@@ -5190,10 +5216,14 @@ class Server {
     this.app.use("/web", express.static(path.resolve(__dirname, "..", "..", "web")))
     this.app.set('view engine', 'ejs');
     this.app.use((req, res, next) => {
-      let protocol = req.get('X-Forwarded-Proto') || "http"
+      const peerForwarded = (req.get('X-Pinokio-Peer') || '').trim().toLowerCase()
+      const allowPeerSourceOverride = peerForwarded === '1' || peerForwarded === 'true'
+      const forwardedProtocol = allowPeerSourceOverride ? req.get('X-Pinokio-Source-Proto') : ''
+      const forwardedHost = allowPeerSourceOverride ? req.get('X-Pinokio-Source-Host') : ''
+      let protocol = forwardedProtocol || req.get('X-Forwarded-Proto') || "http"
       req.$source = {
         protocol,
-        host: req.get("host")
+        host: forwardedHost || req.get("host")
       }
       next()
     })

package/server/lib/app_registry.js

@@ -11,6 +11,173 @@ class AppRegistryService {
     this.kernel = kernel
   }
 
+  isLoopbackHostname(hostname = '') {
+    const normalized = String(hostname || '').trim().toLowerCase()
+    if (!normalized) {
+      return false
+    }
+    return normalized === 'localhost' ||
+      normalized === '0.0.0.0' ||
+      normalized === '::1' ||
+      normalized === '[::1]' ||
+      normalized.startsWith('127.')
+  }
+
+  normalizeSource(source = null) {
+    const protocolRaw = source && typeof source.protocol === 'string' ? source.protocol.trim().toLowerCase() : ''
+    const protocol = protocolRaw === 'https' ? 'https' : 'http'
+    const host = source && typeof source.host === 'string' ? source.host.trim() : ''
+    let hostname = ''
+    if (host) {
+      try {
+        hostname = new URL(`http://${host}`).hostname
+      } catch (_) {
+        hostname = ''
+      }
+    }
+    return {
+      protocol,
+      host,
+      hostname: hostname ? hostname.toLowerCase() : ''
+    }
+  }
+
+  findExternalHostEntries(port) {
+    const normalizedPort = Number.parseInt(String(port || ''), 10)
+    if (!Number.isFinite(normalizedPort) || normalizedPort <= 0) {
+      return []
+    }
+    const currentHost = this.kernel && this.kernel.peer ? this.kernel.peer.host : ''
+    const peerInfo = currentHost && this.kernel && this.kernel.peer && this.kernel.peer.info
+      ? this.kernel.peer.info[currentHost]
+      : null
+    const routerInfo = peerInfo && Array.isArray(peerInfo.router_info) ? peerInfo.router_info : []
+    const entries = []
+    const seen = new Set()
+    for (const item of routerInfo) {
+      if (!item || String(item.internal_port) !== String(normalizedPort)) {
+        continue
+      }
+      const externalHosts = Array.isArray(item.external_hosts) ? item.external_hosts : []
+      for (const externalHost of externalHosts) {
+        if (!externalHost || !externalHost.host || !externalHost.port) {
+          continue
+        }
+        const signature = `${externalHost.host}:${externalHost.port}`
+        if (seen.has(signature)) {
+          continue
+        }
+        seen.add(signature)
+        entries.push({
+          host: String(externalHost.host).trim(),
+          port: Number.parseInt(String(externalHost.port), 10),
+          scope: externalHost.scope || null,
+          interface: externalHost.interface || null
+        })
+      }
+      if (item.external_ip && typeof item.external_ip === 'string') {
+        try {
+          const parsed = new URL(`http://${item.external_ip}`)
+          const signature = `${parsed.hostname}:${parsed.port}`
+          if (!seen.has(signature) && parsed.hostname && parsed.port) {
+            seen.add(signature)
+            entries.push({
+              host: parsed.hostname,
+              port: Number.parseInt(parsed.port, 10),
+              scope: null,
+              interface: null
+            })
+          }
+        } catch (_) {}
+      }
+    }
+    return entries
+  }
+
+  sortExternalHostEntries(entries = [], source = null) {
+    const sourceInfo = this.normalizeSource(source)
+    const scopedEntries = Array.isArray(entries) ? entries.slice() : []
+    const scopeRank = (scope = '') => {
+      switch (String(scope || '').toLowerCase()) {
+        case 'lan':
+          return 0
+        case 'cgnat':
+          return 1
+        default:
+          return 2
+      }
+    }
+    return scopedEntries.sort((a, b) => {
+      const aHost = String(a && a.host ? a.host : '').toLowerCase()
+      const bHost = String(b && b.host ? b.host : '').toLowerCase()
+      const aMatchesCaller = sourceInfo.hostname && aHost === sourceInfo.hostname ? 1 : 0
+      const bMatchesCaller = sourceInfo.hostname && bHost === sourceInfo.hostname ? 1 : 0
+      if (aMatchesCaller !== bMatchesCaller) {
+        return bMatchesCaller - aMatchesCaller
+      }
+      const aScope = scopeRank(a && a.scope)
+      const bScope = scopeRank(b && b.scope)
+      if (aScope !== bScope) {
+        return aScope - bScope
+      }
+      return `${aHost}:${a && a.port ? a.port : ''}`.localeCompare(`${bHost}:${b && b.port ? b.port : ''}`)
+    })
+  }
+
+  buildExternalReadyUrls(url, source = null) {
+    if (!url || typeof url !== 'string') {
+      return []
+    }
+    const originalUrl = String(url)
+    let parsed
+    try {
+      parsed = new URL(originalUrl)
+    } catch (_) {
+      return []
+    }
+    const originalProtocol = parsed.protocol === 'https:' ? 'https:' : 'http:'
+    const hostname = (parsed.hostname || '').trim().toLowerCase()
+    if (!hostname || !this.isLoopbackHostname(hostname)) {
+      return []
+    }
+
+    const externalEntries = this.sortExternalHostEntries(this.findExternalHostEntries(parsed.port), source)
+    const results = []
+    const seen = new Set()
+    for (const entry of externalEntries) {
+      if (!entry || !entry.host || !entry.port) {
+        continue
+      }
+      const next = new URL(parsed.toString())
+      next.protocol = originalProtocol
+      next.hostname = entry.host
+      next.port = String(entry.port)
+      let nextUrl = next.toString()
+      if (/^https?:\/\/[^/?#]+$/i.test(originalUrl) && next.pathname === '/' && !next.search && !next.hash) {
+        nextUrl = nextUrl.replace(/\/$/, '')
+      }
+      if (seen.has(nextUrl)) {
+        continue
+      }
+      seen.add(nextUrl)
+      const item = {
+        url: nextUrl,
+        transport: 'ip',
+        scope: entry.scope || 'unknown'
+      }
+      if (entry.interface) {
+        item.interface = entry.interface
+      }
+      results.push(item)
+    }
+    return results
+  }
+
+  buildExternalReadyUrl(url, source = null) {
+    const externalReadyUrls = this.buildExternalReadyUrls(url, source)
+    return externalReadyUrls.length > 0 ? externalReadyUrls[0].url : null
+  }
+
   isPathWithin(parentPath, childPath) {
     if (!parentPath || !childPath) {
       return false
@@ -98,6 +265,7 @@ class AppRegistryService {
       ready: false,
       state: 'offline',
       ready_url: null,
+      external_ready_urls: [],
       ready_script: null,
       running_scripts: [],
       local_entries: []
@@ -275,6 +443,7 @@ class AppRegistryService {
     }
 
     const runtime = this.collectAppRuntime(appRoot)
+    runtime.external_ready_urls = this.buildExternalReadyUrls(runtime.ready_url, options.source || null)
     const installScript = await this.firstExistingScript(appRoot, ['install.js', 'install.json'])
     const startScript = await this.firstExistingScript(appRoot, ['start.js', 'start.json'])
     let defaultTarget = null
@@ -312,6 +481,7 @@ class AppRegistryService {
       running: runtime.running,
       ready,
       ready_url: runtime.ready_url,
+      external_ready_urls: runtime.external_ready_urls,
       state,
       running_scripts: runtime.running_scripts,
       ready_script: runtime.ready_script,

package/server/lib/app_search.js

@@ -512,15 +512,17 @@ class AppSearchService {
     })
   }
 
-  decorateAppWithRuntime(app, extras = {}) {
+  decorateAppWithRuntime(app, extras = {}, source = null) {
     const appRoot = this.kernel.path('api', app.name)
     const runtime = this.registry.collectAppRuntime(appRoot)
+    const externalReadyUrls = this.registry.buildExternalReadyUrls(runtime.ready_url, source)
     return {
       app_id: app.name,
       ...app,
       running: runtime.running,
       ready: runtime.ready,
       ready_url: runtime.ready_url,
+      external_ready_urls: externalReadyUrls,
       state: runtime.state,
       ...extras
     }
@@ -530,6 +532,7 @@ class AppSearchService {
     const options = rawOptions && typeof rawOptions === 'object' ? rawOptions : {}
     const q = typeof query === 'string' ? query.trim() : ''
     const normalizedQuery = q.toLowerCase()
+    const source = options.source || null
     const searchMode = this.normalizeSearchMode(options.mode)
     const resultLimit = this.parsePositiveInteger(options.limit, APP_SEARCH_DEFAULT_LIMIT)
     const preferenceMap = await this.readPreferenceMap()
@@ -546,7 +549,7 @@ class AppSearchService {
       const apps = rankedEntries
         .map((entry) => this.decorateAppWithRuntime(entry.app, {
           ...this.toPublicPreference(entry.preference)
-        }))
+        }, source))
         .slice(0, resultLimit)
       return {
         q: normalizedQuery,
@@ -692,7 +695,7 @@ class AppSearchService {
           matched_terms_count: matchedTerms.length,
           matched_terms: matchedTerms,
           ...this.toPublicPreference(entry.preference)
-        })
+        }, source)
       })
       return {
         q: normalizedQuery,
@@ -719,7 +722,7 @@ class AppSearchService {
       const apps = rankedEntries
         .map((entry) => this.decorateAppWithRuntime(entry.app, {
           ...this.toPublicPreference(entry.preference)
-        }))
+        }, source))
         .slice(0, resultLimit)
       return {
         q: normalizedQuery,

package/server/routes/apps.js

@@ -1,4 +1,53 @@
 const express = require('express')
+const axios = require('axios')
+
+const DEFAULT_PEER_PORT = 42000
+const DEFAULT_PEER_TIMEOUT_MS = 2500
+const IPV4_HOST_PATTERN = /^(?:\d{1,3}\.){3}\d{1,3}$/
+
+const isQualifiedHost = (value = '') => {
+  return IPV4_HOST_PATTERN.test(String(value || '').trim())
+}
+
+const parseQualifiedAppId = (value = '') => {
+  if (typeof value !== 'string') {
+    return {
+      app_id: '',
+      host: null,
+      qualified: false
+    }
+  }
+  const trimmed = value.trim()
+  if (!trimmed) {
+    return {
+      app_id: '',
+      host: null,
+      qualified: false
+    }
+  }
+  const atIndex = trimmed.lastIndexOf('@')
+  if (atIndex <= 0 || atIndex >= trimmed.length - 1) {
+    return {
+      app_id: trimmed,
+      host: null,
+      qualified: false
+    }
+  }
+  const appId = trimmed.slice(0, atIndex).trim()
+  const host = trimmed.slice(atIndex + 1).trim()
+  if (!appId || !isQualifiedHost(host)) {
+    return {
+      app_id: trimmed,
+      host: null,
+      qualified: false
+    }
+  }
+  return {
+    app_id: appId,
+    host,
+    qualified: true
+  }
+}
 
 module.exports = function registerAppRoutes(app, { registry, preferences, appSearch, appLogs, getTheme }) {
   if (!app || !registry || !preferences || !appSearch || !appLogs) {
@@ -34,6 +83,145 @@ module.exports = function registerAppRoutes(app, { registry, preferences, appSea
     }
     return fallback
   }
+  const includePeersForSearch = (req) => {
+    const scope = typeof req.query.peer_scope === 'string' ? req.query.peer_scope.trim().toLowerCase() : ''
+    if (scope === 'local') {
+      return false
+    }
+    return parseBooleanInput(req.query.include_peers, true)
+  }
+  const currentPeerHost = () => {
+    return registry?.kernel?.peer?.host ? String(registry.kernel.peer.host).trim() : ''
+  }
+  const currentPeerName = () => {
+    return registry?.kernel?.peer?.name ? String(registry.kernel.peer.name).trim() : ''
+  }
+  const buildSource = (host, local = false) => {
+    const peerInfo = host && registry?.kernel?.peer?.info ? registry.kernel.peer.info[host] : null
+    const name = peerInfo && peerInfo.name ? peerInfo.name : (local ? currentPeerName() : '')
+    return {
+      host: host || null,
+      name: name || host || null,
+      local: Boolean(local)
+    }
+  }
+  const qualifyAppId = (appId, host) => {
+    const normalizedAppId = typeof appId === 'string' ? appId.trim() : ''
+    if (!normalizedAppId || !host || host === currentPeerHost()) {
+      return normalizedAppId
+    }
+    return `${normalizedAppId}@${host}`
+  }
+  const decorateSearchResult = (appResult, source) => {
+    const next = appResult && typeof appResult === 'object' ? { ...appResult } : {}
+    next.app_id = qualifyAppId(next.app_id || next.name || '', source.host)
+    next.source = source
+    if (!source.local) {
+      next.ready_url = null
+    }
+    return next
+  }
+  const decorateStatusResult = (statusResult, source) => {
+    const next = statusResult && typeof statusResult === 'object' ? { ...statusResult } : {}
+    next.app_id = qualifyAppId(next.app_id || next.name || '', source.host)
+    next.source = source
+    if (!source.local) {
+      next.ready_url = null
+    }
+    return next
+  }
+  const peerRequestHeaders = (req) => {
+    const headers = {
+      'x-pinokio-peer': '1'
+    }
+    if (req && req.$source && typeof req.$source.host === 'string' && req.$source.host.trim()) {
+      headers['x-pinokio-source-host'] = req.$source.host.trim()
+    }
+    if (req && req.$source && typeof req.$source.protocol === 'string' && req.$source.protocol.trim()) {
+      headers['x-pinokio-source-proto'] = req.$source.protocol.trim()
+    }
+    return headers
+  }
+  const peerPort = () => {
+    const rawPort = Number.parseInt(String(registry?.kernel?.peer?.default_port || registry?.kernel?.server_port || DEFAULT_PEER_PORT), 10)
+    return Number.isFinite(rawPort) && rawPort > 0 ? rawPort : DEFAULT_PEER_PORT
+  }
+  const remotePeerHosts = () => {
+    const localHost = currentPeerHost()
+    const info = registry?.kernel?.peer?.info
+    if (!info || typeof info !== 'object') {
+      return []
+    }
+    return Object.keys(info).filter((host) => host && host !== localHost)
+  }
+  const mergeSearchApps = (localApps, remoteApps, query = '') => {
+    const merged = []
+    const seen = new Set()
+    const push = (items = []) => {
+      for (const item of items) {
+        if (!item || !item.app_id) {
+          continue
+        }
+        if (seen.has(item.app_id)) {
+          continue
+        }
+        seen.add(item.app_id)
+        merged.push(item)
+      }
+    }
+    push(localApps)
+    push(remoteApps)
+    const normalizedQuery = typeof query === 'string' ? query.trim() : ''
+    if (!normalizedQuery) {
+      return merged
+    }
+    return merged.sort((a, b) => {
+      const aAdjusted = typeof a.adjusted_score === 'number' ? a.adjusted_score : -Infinity
+      const bAdjusted = typeof b.adjusted_score === 'number' ? b.adjusted_score : -Infinity
+      if (aAdjusted !== bAdjusted) {
+        return bAdjusted - aAdjusted
+      }
+      const aScore = typeof a.score === 'number' ? a.score : -Infinity
+      const bScore = typeof b.score === 'number' ? b.score : -Infinity
+      if (aScore !== bScore) {
+        return bScore - aScore
+      }
+      return String(a.app_id || '').localeCompare(String(b.app_id || ''))
+    })
+  }
+  const fetchPeerSearchResults = async (req, { q, mode, minMatch, limit }) => {
+    const hosts = remotePeerHosts()
+    if (hosts.length === 0) {
+      return []
+    }
+    const timeout = DEFAULT_PEER_TIMEOUT_MS
+    const port = peerPort()
+    const headers = peerRequestHeaders(req)
+    const requests = hosts.map(async (host) => {
+      try {
+        const response = await axios.get(`http://${host}:${port}/apps/search`, {
+          timeout,
+          headers,
+          params: {
+            q,
+            mode,
+            min_match: minMatch,
+            limit,
+            peer_scope: 'local'
+          }
+        })
+        const source = buildSource(host, false)
+        const apps = Array.isArray(response?.data?.apps)
+          ? response.data.apps.map((appResult) => decorateSearchResult(appResult, source))
+          : []
+        return apps
+      } catch (_) {
+        return []
+      }
+    })
+    const results = await Promise.all(requests)
+    return results.flat()
+  }
 
   router.get('/apps/preferences', asyncHandler(async (req, res) => {
     const queryAppId = typeof req.query.app_id === 'string' ? registry.normalizeAppId(req.query.app_id) : ''
@@ -98,15 +286,44 @@ module.exports = function registerAppRoutes(app, { registry, preferences, appSea
     const payload = await appSearch.searchApps(q, {
       mode,
       min_match: minMatch,
-      limit
+      limit,
+      source: req.$source || null
     })
+    const localSource = buildSource(currentPeerHost(), true)
+    payload.apps = Array.isArray(payload.apps)
+      ? payload.apps.map((appResult) => decorateSearchResult(appResult, localSource))
+      : []
+    if (includePeersForSearch(req)) {
+      const remoteApps = await fetchPeerSearchResults(req, { q, mode, minMatch, limit })
+      payload.apps = mergeSearchApps(payload.apps, remoteApps, q)
+      payload.count = payload.apps.length
+    }
     res.json(payload)
   }))
   router.get('/apps/search/test', asyncHandler(async (req, res) => {
     const q = typeof req.query.q === 'string' ? req.query.q : ''
     const payload = q
-      ? await appSearch.searchApps(q)
+      ? await appSearch.searchApps(q, {
+        source: req.$source || null,
+        mode: typeof req.query.mode === 'string' ? req.query.mode : '',
+        min_match: typeof req.query.min_match === 'string' ? req.query.min_match : '',
+        limit: typeof req.query.limit === 'string' ? req.query.limit : ''
+      })
       : { q: '', count: 0, apps: [] }
+    const localSource = buildSource(currentPeerHost(), true)
+    payload.apps = Array.isArray(payload.apps)
+      ? payload.apps.map((appResult) => decorateSearchResult(appResult, localSource))
+      : []
+    if (q && includePeersForSearch(req)) {
+      const remoteApps = await fetchPeerSearchResults(req, {
+        q,
+        mode: typeof req.query.mode === 'string' ? req.query.mode : '',
+        minMatch: typeof req.query.min_match === 'string' ? req.query.min_match : '',
+        limit: typeof req.query.limit === 'string' ? req.query.limit : ''
+      })
+      payload.apps = mergeSearchApps(payload.apps, remoteApps, q)
+      payload.count = payload.apps.length
+    }
     res.render('app_search_test', {
       theme: readTheme(),
       agent: req.agent || '',
@@ -117,7 +334,41 @@ module.exports = function registerAppRoutes(app, { registry, preferences, appSea
   }))
 
   router.get('/apps/status/: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 timeout = Number.parseInt(String(req.query.timeout || ''), 10)
+        const params = {}
+        if (typeof req.query.probe !== 'undefined') {
+          params.probe = req.query.probe
+        }
+        if (Number.isFinite(timeout)) {
+          params.timeout = String(timeout)
+        }
+        const response = await axios.get(`http://${remoteHost}:${peerPort()}/apps/status/${encodeURIComponent(requestedAppId)}`, {
+          timeout: DEFAULT_PEER_TIMEOUT_MS,
+          headers: peerRequestHeaders(req),
+          params
+        })
+        const payload = decorateStatusResult(response.data, 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 status 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
@@ -126,14 +377,15 @@ module.exports = function registerAppRoutes(app, { registry, preferences, appSea
     const timeout = Number.parseInt(String(req.query.timeout || ''), 10)
     const status = await registry.buildAppStatus(appId, {
       probe,
-      timeout: Number.isFinite(timeout) ? timeout : 1500
+      timeout: Number.isFinite(timeout) ? timeout : 1500,
+      source: req.$source || null
     })
     if (!status) {
       res.status(404).json({ error: 'App not found', app_id: appId })
       return
     }
     status.preference = await preferences.getPreference(appId)
-    res.json(status)
+    res.json(decorateStatusResult(status, buildSource(currentPeerHost(), true)))
   }))
 
   router.get('/apps/logs/:app_id', asyncHandler(async (req, res) => {
@@ -142,7 +394,9 @@ module.exports = function registerAppRoutes(app, { registry, preferences, appSea
       res.status(400).json({ error: 'Invalid app_id' })
       return
     }
-    const status = await registry.buildAppStatus(appId)
+    const status = await registry.buildAppStatus(appId, {
+      source: req.$source || null
+    })
     if (!status) {
       res.status(404).json({ error: 'App not found', app_id: appId })
       return

package/server/socket.js

@@ -73,6 +73,46 @@ class Socket {
     }
     return ""
   }
+  sourceFromBoundUrl(boundUrl = "") {
+    if (typeof boundUrl !== "string") {
+      return null
+    }
+    const trimmed = boundUrl.trim()
+    if (!trimmed) {
+      return null
+    }
+    try {
+      const parsed = new URL(trimmed)
+      return {
+        protocol: parsed.protocol === "https:" || parsed.protocol === "wss:" ? "https" : "http",
+        host: parsed.host
+      }
+    } catch (error) {
+      return null
+    }
+  }
+  projectLaunchTargetUri(uri, ws) {
+    if (typeof uri !== "string" || !/^https?:\/\//i.test(uri)) {
+      return uri
+    }
+    const registry = this.parent && this.parent.appRegistry
+    if (!registry || typeof registry.buildExternalReadyUrl !== "function") {
+      return uri
+    }
+    const source = this.sourceFromBoundUrl(ws && ws._boundUrl ? ws._boundUrl : "")
+    if (!source || typeof registry.normalizeSource !== "function") {
+      return uri
+    }
+    const sourceInfo = registry.normalizeSource(source)
+    if (!sourceInfo || !sourceInfo.hostname || (
+      typeof registry.isLoopbackHostname === "function" &&
+      registry.isLoopbackHostname(sourceInfo.hostname)
+    )) {
+      return uri
+    }
+    const projected = registry.buildExternalReadyUrl(uri, source)
+    return projected || uri
+  }
   trackLaunchTelemetry(scriptPath = "", source = "unknown") {
     const appPreferences = this.parent && this.parent.appPreferences
     if (!appPreferences || typeof appPreferences.recordLaunchByPath !== "function") {
@@ -198,9 +238,12 @@ class Socket {
               let id = this.parent.kernel.api.filePath(req.uri)
               try {
                 let defaultTarget = await getLaunchTarget(this.parent.kernel.api, id, req.default)
+                const launchTargetUri = defaultTarget && defaultTarget.uri
+                  ? this.projectLaunchTargetUri(defaultTarget.uri, ws)
+                  : undefined
                 ws.send(JSON.stringify({
                   data: {
-                    uri: defaultTarget ? defaultTarget.uri : undefined,
+                    uri: launchTargetUri,
                     input: defaultTarget ? defaultTarget.input : undefined
                   }
                 }))

package/server/views/app.ejs

@@ -4384,12 +4384,14 @@ header.navheader .mode-selector .community-mode-toggle {
     box-sizing: border-box;
   }
   .mobile-bottom-nav {
-    position: relative;
+    position: sticky;
+    bottom: 0;
     display: flex;
     flex: 0 0 auto;
     align-items: center;
     gap: 3px;
     width: 100%;
+    margin-top: auto;
     min-height: 32px;
     padding: 0 4px env(safe-area-inset-bottom) 4px;
     border-top: 1px solid rgba(0,0,0,0.08);