pinokiod 6.0.104 → 6.0.107

package/kernel/api/app/index.js

@@ -123,6 +123,141 @@ class AppAPI {
     const launcher = this.ensureService(kernel)
     return launcher.refresh(req && req.params ? req.params : {})
   }
+
+  async download(req, ondata, kernel) {
+    /*
+      {
+        "method": "app.download",
+        "params": {
+          "uri": <required git uri>,
+          "name": <optional target folder name>,
+          "branch": <optional git branch>
+        }
+      }
+    */
+    const params = req && req.params ? req.params : {}
+    const uri = typeof params.uri === 'string' ? params.uri.trim() : ''
+    const providedName = typeof params.name === 'string' ? params.name.trim() : ''
+    const branch = typeof params.branch === 'string' ? params.branch.trim() : ''
+    if (!uri) {
+      throw new Error('app.download requires params.uri')
+    }
+
+    const name = providedName || this.deriveDownloadName(uri)
+    if (!name) {
+      return {
+        ok: false,
+        code: 'INVALID_URI',
+        error: 'invalid uri',
+        uri
+      }
+    }
+    if (!this.isValidDownloadName(name)) {
+      return {
+        ok: false,
+        code: 'INVALID_NAME',
+        error: 'invalid name',
+        name,
+        uri
+      }
+    }
+
+    const targetPath = kernel.path('api', name)
+    if (await this.pathExists(targetPath)) {
+      return {
+        ok: false,
+        code: 'APP_EXISTS',
+        error: 'already exists',
+        name,
+        path: targetPath,
+        uri
+      }
+    }
+
+    await kernel.bin.install2({ params: {} }, ondata)
+
+    await kernel.bin.sh({
+      message: this.buildGitCloneCommand({
+        uri,
+        name: providedName ? name : null,
+        branch
+      }),
+      path: kernel.api.userdir
+    }, ondata)
+
+    await kernel.api.init()
+    if (kernel.appLauncher && typeof kernel.appLauncher.refresh === 'function') {
+      try {
+        await kernel.appLauncher.refresh({ force: true })
+      } catch (_) {
+      }
+    }
+
+    const result = {
+      ok: true,
+      name,
+      path: targetPath,
+      uri
+    }
+    if (branch) {
+      result.branch = branch
+    }
+    return result
+  }
+}
+
+AppAPI.prototype.pathExists = async function pathExists(targetPath) {
+  try {
+    await fs.promises.access(targetPath)
+    return true
+  } catch (_) {
+    return false
+  }
+}
+
+AppAPI.prototype.isValidDownloadName = function isValidDownloadName(name) {
+  return typeof name === 'string'
+    && name.length > 0
+    && name !== '.'
+    && name !== '..'
+    && !/[\\/]/.test(name)
+}
+
+AppAPI.prototype.deriveDownloadName = function deriveDownloadName(uri) {
+  const trimmed = String(uri || '').trim().replace(/[\\/]+$/, '')
+  if (!trimmed) {
+    return ''
+  }
+  let lastSegment = ''
+  try {
+    const parsed = new URL(trimmed)
+    const pathname = parsed.pathname.replace(/\/+$/, '')
+    lastSegment = pathname.split('/').filter(Boolean).pop() || ''
+  } catch (_) {
+  }
+  if (!lastSegment) {
+    lastSegment = trimmed.split(/[/:]/).filter(Boolean).pop() || ''
+  }
+  if (lastSegment.toLowerCase().endsWith('.git')) {
+    lastSegment = lastSegment.slice(0, -4)
+  }
+  return lastSegment
+}
+
+AppAPI.prototype.shellQuote = function shellQuote(value) {
+  return JSON.stringify(String(value))
+}
+
+AppAPI.prototype.buildGitCloneCommand = function buildGitCloneCommand({ uri, name, branch }) {
+  const parts = ['git', 'clone']
+  if (branch) {
+    parts.push('--branch', this.shellQuote(branch))
+  }
+  parts.push(this.shellQuote(uri))
+  if (name) {
+    parts.push(this.shellQuote(name))
+  }
+  return parts.join(' ')
 }
 
 AppAPI.prototype.sleep = function sleep(ms) {

package/kernel/bin/cli.js

@@ -2,7 +2,7 @@ const path = require('path')
 const semver = require('semver')
 const Util = require('../util')
 class CLI {
-  version = ">=0.0.22"
+  version = ">=0.0.24"
   async install(req, ondata) {
     await this.kernel.exec({
       message: "npm install -g pterm@latest --force",

package/kernel/bin/node.js

@@ -4,7 +4,8 @@ const { rimraf } = require('rimraf')
 const decompress = require('decompress');
 class Node {
   cmd() {
-    return "nodejs=22.21.1 pnpm"
+    //return "nodejs=22.21.1 pnpm"
+    return "nodejs=25.8.1 pnpm"
   }
   async install(req, ondata) {
     await this.kernel.bin.exec({
@@ -18,7 +19,8 @@ class Node {
   async installed() {
     if (this.kernel.bin.installed.conda && this.kernel.bin.installed.conda_versions) {
       let version = this.kernel.bin.installed.conda_versions.nodejs
-      if (version !== "22.21.1") {
+      //if (version !== "22.21.1") {
+      if (version !== "25.8.1") {
         return false
       }
     }

package/kernel/environment.js

@@ -544,7 +544,8 @@ const init = async (options, kernel) => {
     const home = os.homedir()
     const targetDirs = [
       path.resolve(home, ".agents", "skills", skillName),
-      path.resolve(home, ".claude", "skills", skillName)
+      path.resolve(home, ".claude", "skills", skillName),
+      path.resolve(home, ".hermes", "skills", skillName)
     ]
     for (let i = 0; i < targetDirs.length; i++) {
       const skillDir = targetDirs[i]

package/package.json

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

package/prototype/system/SKILL_PINOKIO.md

@@ -1,6 +1,6 @@
 ---
 name: pinokio
-description: Discover, launch, and use locally installed apps for the current task.
+description: Discover, launch, and use apps and tools for the current task.
 ---
 
 # Pinokio Runtime Skill (pterm-first)
@@ -45,158 +45,159 @@ Use direct `pterm` commands for control-plane operations:
 2. `pterm status <app_id>`
 3. `pterm run <app_path> [--default <selector>]...`
 4. `pterm logs <app_id> --tail 200`
-5. `pterm stars` (optional: inspect user-pinned favorites)
-6. `pterm star <app_id>` / `pterm unstar <app_id>` (only when user explicitly asks to change preference)
-
-Do not run install/update commands from this skill.
-Do not execute bundled app binaries or internal app CLIs from the app repo unless the user explicitly asks for CLI mode.
-Once a Pinokio-managed app is selected, treat the launcher and its exposed interfaces as the source of truth for lifecycle and execution.
-Do not switch to alternate repo-local execution paths unless the user explicitly requests that mode.
-
-Permission handling:
-- If a probe or `pterm` command fails with loopback permission errors (`EPERM`/`EACCES` to `127.0.0.1:42000`), ask for permission first when the client supports permission prompts or escalation.
-- After permission is granted, rerun the same command.
-- Continue normal flow if rerun succeeds.
-- Fail only if permission/escalation is denied, unavailable, or rerun still cannot reach Pinokio.
-- When failing after those retries, say "Pinokio may be running, but this client cannot reach the local control plane" rather than "Pinokio is not installed/running" unless you have confirmed both conditions.
-
-## Workflow
-
-1. Resolve app target.
-   - Resolve by `pterm search`.
-   - Build one primary query from user intent:
-     - explicit app name/vendor if user provided one
-     - otherwise 2-4 high-signal capability tokens (example: `tts speech synthesis`)
-   - Query hygiene:
-     - remove duplicate/filler words (`to`, `for`, `use`, `app`, `tool`, `service`)
-     - do not send full sentences
-   - Run primary lookup:
-     - if query has 3+ terms: `pterm search "<query>" --mode balanced --min-match 2 --limit 8`
-     - if query has 1-2 terms: `pterm search "<query>" --mode balanced --min-match 1 --limit 8`
-   - If user provided a git URL, extract owner/repo tokens and run `pterm search` with those tokens first.
-   - Useful-hit threshold:
-     - for 3+ term queries: candidate has `matched_terms_count >= 2` (if available)
-     - for 1-2 term queries: candidate has `matched_terms_count >= 1` or clear top score
-   - If no useful hits, run one fallback:
-     - `pterm search "<query>" --mode broad --limit 8`
-   - Deterministic ranking:
-     - First, rank by runtime tier:
-       - relevant apps with `ready=true`
-       - otherwise relevant apps with `running=true`
-       - otherwise relevant offline apps
-     - Within the selected runtime tier, rank by user preference:
-       - exact `app_id`/title match (for explicit app requests)
-       - `starred=true`
-     - Within that same tier, use the remaining tiebreakers:
-       - higher `matched_terms_count` (if available)
-       - 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.
-
-2. Check runtime state with `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`: base URL for API calls when available
-     - `state`: `offline | starting | online`
-   - 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.
-
-3. 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`.
-   - 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.
-   - Do not keep searching indefinitely once an app is selected; start it.
-
-4. 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.
-
-5. Failure criteria.
-   - Timeout before success.
-   - App drops back to `offline` during startup after a run attempt.
-   - `pterm run` terminates and status never reaches ready.
-   - On failure, fetch `pterm logs <app_id> --tail 200` and return:
-     - raw log tail
-     - short diagnosis
-
-6. API call strategy (generated once, reused).
-   - Resolve path roots before writing agent-owned files:
-     - prefer the current working directory when it is the active writable task/workspace folder
-     - resolve `PINOKIO_HOME` with `pterm home` when fallback global storage is needed
-   - Generated client location:
-     - local default: `<current_working_directory>/pinokio_agent/clients/<app_id>/<operation>.<ext>`
-     - fallback: `<PINOKIO_HOME>/agents/clients/<app_id>/<operation>.<ext>`
-   - Output location:
-     - local default: `<current_working_directory>/pinokio_agent/output/<app_id>/...`
-     - fallback: `<PINOKIO_HOME>/agents/output/<app_id>/...`
-   - First run for `<app_id>/<operation>`:
-     - inspect docs/code to infer endpoint + payload
-     - generate minimal HTTP client file (`js`/`py`/`sh`)
-   - Later runs:
-     - reuse existing generated client file directly
-   - Regenerate only if request indicates contract mismatch:
-     - 404/405 endpoint mismatch
-     - 400/422 payload/schema mismatch
-     - auth/header mismatch
-   - Prefer documented/public app APIs exposed by the running launcher.
-   - 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. `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)
+
+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
+
+Follow these sections in order:
+1. Use Search App first.
+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.
+
+### 1. Search App
+
+- Resolve by `pterm search`.
+- Build one primary query from user intent:
+  - explicit app name/vendor if user provided one
+  - otherwise 2-4 high-signal capability tokens (example: `tts speech synthesis`)
+- Query hygiene:
+  - remove duplicate/filler words (`to`, `for`, `use`, `app`, `tool`, `service`)
+  - do not send full sentences
+- Run primary lookup:
+  - if query has 3+ terms: `pterm search "<query>" --mode balanced --min-match 2 --limit 8`
+  - if query has 1-2 terms: `pterm search "<query>" --mode balanced --min-match 1 --limit 8`
+- If user provided a git URL, extract owner/repo tokens and run `pterm search` with those tokens first.
+- Useful-hit threshold:
+  - for 3+ term queries: candidate has `matched_terms_count >= 2` (if available)
+  - for 1-2 term queries: candidate has `matched_terms_count >= 1` or clear top score
+- If no useful hits, run one fallback:
+  - `pterm search "<query>" --mode broad --limit 8`
+- Deterministic ranking:
+  - First, rank by runtime tier:
+    - relevant apps with `ready=true`
+    - otherwise relevant apps with `running=true`
+    - otherwise relevant offline apps
+  - Within the selected runtime tier, rank by user preference:
+    - exact `app_id`/title match (for explicit app requests)
+    - `starred=true`
+  - Within that same tier, use the remaining tiebreakers:
+    - higher `matched_terms_count` (if available)
+    - 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.
+
+### 2. Registry Fallback
+
+- Only use this section if Search App found no suitable installed app.
+- Ask the user once whether to search the Pinokio registry for installable apps.
+- Only after the user says yes:
+  - run `pterm registry search "<query>"`
+  - present the best candidates
+  - after the user selects one, run `pterm download <uri>`
+  - 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
+
+- Once you have a selected local 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`: base URL for API calls when available
+  - `state`: `offline | starting | online`
+- 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 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`.
+  - 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`
+  - 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
+- Failure criteria:
+  - timeout before success
+  - app drops back to `offline` during startup after a run attempt
+  - `pterm run` terminates and status never reaches ready
+  - on failure, fetch `pterm logs <app_id> --tail 200` and return:
+    - raw log tail
+    - short diagnosis
+
+### 4. API Call Strategy (generated once, reused)
+- Resolve path roots before writing agent-owned files:
+  - prefer the current working directory when it is the active writable task/workspace folder
+  - resolve `PINOKIO_HOME` with `pterm home` when fallback global storage is needed
+- Generated client location:
+  - local default: `<current_working_directory>/pinokio_agent/clients/<app_id>/<operation>.<ext>`
+  - fallback: `<PINOKIO_HOME>/agents/clients/<app_id>/<operation>.<ext>`
+- Output location:
+  - local default: `<current_working_directory>/pinokio_agent/output/<app_id>/...`
+  - fallback: `<PINOKIO_HOME>/agents/output/<app_id>/...`
+- First run for `<app_id>/<operation>`:
+  - inspect docs/code to infer endpoint + payload
+  - generate minimal HTTP client file (`js`/`py`/`sh`)
+- Later runs:
+  - reuse existing generated client file directly
+- Regenerate only if request indicates contract mismatch:
+  - 404/405 endpoint mismatch
+  - 400/422 payload/schema mismatch
+  - auth/header mismatch
+- Prefer documented/public app APIs exposed by the running launcher.
+- 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.
 
 ## Behavior Rules
 
 - Do not add app-specific hardcoding when user gave only capability (for example "tts").
 - Do not guess hidden endpoints when docs/code are unclear; ask one targeted question.
 - Do not rewrite launcher files unless user explicitly asked.
+- When a task needs a local executable such as `python`, prefer resolving it with `pterm which <command>` before falling back to generic shell discovery.
 - 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 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.
-- After app selection, do not execute `python`, `node`, shell entrypoints, or repo-local binaries inside the selected app unless the user explicitly asks for CLI mode.
-- Do not inspect bundled CLI help or probe repo-local executables as an alternative execution path when the task is to operate the Pinokio-managed app.
-- "Launch the app server and run it" means `pterm status` -> `pterm run` -> wait for `ready=true` -> use `ready_url` with a generated/reused client.
-- If `ready_url` is absent, use `pterm` only for lifecycle control and ask one targeted question or report that the app lacks a clear automatable API. Do not silently fall back to internal CLI execution.
 
 ## Example A (Capability Only)
 
 User: "Generate TTS from this text: hello world"
 
-1. `pterm search "tts speech synthesis" --mode balanced --min-match 2 --limit 8`
-2. Pick best match using deterministic ranking (or ask once if ambiguous).
-3. `pterm status <app_id>`
-4. If not ready: `pterm run <app_path>`, keep polling status.
-5. Before first API call: `pterm status <app_id> --probe`
-6. When ready: generate/reuse `text_to_speech` client and execute.
-7. Return output (audio path/bytes) or failure with `pterm logs`.
+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.
 
-## Example B (Explicit App)
-
-User: "Use Qwen-TTS to generate speech from this text: hello world"
-
-1. `pterm search "qwen tts" --mode balanced --min-match 1 --limit 8`.
-2. If exact app_id/title match exists, pick it.
-3. `pterm status <app_id>`
-4. Before first API call: `pterm status <app_id> --probe`
-5. If not ready: `pterm run <app_path>`, keep polling.
-6. When ready: generate/reuse `text_to_speech` client and execute.
-7. Return output or failure with `pterm logs`.
-
-## Example C (No Launcher Default)
+## Example B (No Launcher Default)
 
 User: "Launch FaceFusion"
 
-1. Resolve app target and status as usual.
+1. Use Search App and then Run App as usual.
 2. If launcher menu has no explicit default item, infer ordered selectors from the current launcher menu.
 3. Run:
    `pterm run <app_path> --default 'run.js?mode=Default' --default run.js --default install.js`