pinokiod 6.0.28 → 6.0.40

package/kernel/environment.js

@@ -525,7 +525,35 @@ const init = async (options, kernel) => {
   } else {
     root = kernel.homedir
   }
-  const syncHomeSkillFromAgents = async () => {
+  const writeSkillIfChanged = async (skillPath, content) => {
+    let shouldWrite = true
+    try {
+      const existingSkillContent = await fs.promises.readFile(skillPath, "utf8")
+      shouldWrite = existingSkillContent !== content
+    } catch (error) {
+      if (!(error && error.code === "ENOENT")) {
+        throw error
+      }
+    }
+
+    if (shouldWrite) {
+      await fs.promises.writeFile(skillPath, content, "utf8")
+    }
+  }
+  const syncSkillToAgentRoots = async (skillName, content) => {
+    const home = os.homedir()
+    const targetDirs = [
+      path.resolve(home, ".agents", "skills", skillName),
+      path.resolve(home, ".claude", "skills", skillName)
+    ]
+    for (let i = 0; i < targetDirs.length; i++) {
+      const skillDir = targetDirs[i]
+      const skillPath = path.resolve(skillDir, "SKILL.md")
+      await fs.promises.mkdir(skillDir, { recursive: true })
+      await writeSkillIfChanged(skillPath, content)
+    }
+  }
+  const syncGepetoSkillFromAgents = async () => {
     const homeRoot = path.resolve(kernel.homedir)
     if (path.resolve(root) !== homeRoot) {
       return
@@ -537,12 +565,7 @@ const init = async (options, kernel) => {
       return
     }
 
-    const skillDir = path.resolve(os.homedir(), ".agents", "skills", "pinokio")
-    const skillPath = path.resolve(skillDir, "SKILL.md")
-    await fs.promises.mkdir(skillDir, { recursive: true })
-
     let agentsContent = ""
-    let shouldWrite = true
     try {
       agentsContent = await fs.promises.readFile(agentsPath, "utf8")
     } catch (error) {
@@ -553,25 +576,33 @@ const init = async (options, kernel) => {
     }
     const skillFrontmatter = [
       "---",
-      "name: Pinokio",
-      "description: Guide for building 1-click launchers, building apps with 1-click launchers built-in, and controlling any localhost application via Pinokio",
+      "name: gepeto",
+      "description: Guide for building 1-click launchers and building apps with launchers built-in using Pinokio",
       "---"
     ].join("\n")
     const desiredSkillContent = `${skillFrontmatter}\n\n${agentsContent}`
+    await syncSkillToAgentRoots("gepeto", desiredSkillContent)
+  }
+  const syncPinokioSkillFromTemplate = async () => {
+    const homeRoot = path.resolve(kernel.homedir)
+    if (path.resolve(root) !== homeRoot) {
+      return
+    }
 
+    const templatePath = path.resolve(__dirname, "../prototype/system/SKILL_PINOKIO.md")
+    let templateContent
     try {
-      const existingSkillContent = await fs.promises.readFile(skillPath, "utf8")
-      shouldWrite = existingSkillContent !== desiredSkillContent
+      templateContent = await fs.promises.readFile(templatePath, "utf8")
     } catch (error) {
-      if (!(error && error.code === "ENOENT")) {
-        throw error
+      if (error && error.code === "ENOENT") {
+        return
       }
+      throw error
     }
 
-    if (shouldWrite) {
-      await fs.promises.writeFile(skillPath, desiredSkillContent, "utf8")
-    }
+    await syncSkillToAgentRoots("pinokio", templateContent)
   }
+
   let current = path.resolve(root, "ENVIRONMENT")
   let exists = await kernel.exists(current)
   if (exists) {
@@ -663,8 +694,9 @@ const init = async (options, kernel) => {
     }
   }
 
-  // Keep ~/.agents/skills/pinokio/SKILL.md in sync with ~/pinokio/AGENTS.md
-  await syncHomeSkillFromAgents()
+  // Keep agent skills in sync for the Pinokio home root
+  await syncGepetoSkillFromAgents()
+  await syncPinokioSkillFromTemplate()
 
   const gitDir = path.resolve(root, ".git")
   const gitDirExists = await kernel.exists(gitDir)

package/kernel/shell.js

@@ -152,7 +152,7 @@ class Shell {
 
     // if the shell is running from a script file, the params.$parent will include the path to the parent script
     // this means we need to apply app environment as well
-    if (params.$parent) {
+    if (params.$parent && params.$parent.id) {
       let api_path
       if (params.$parent.cwd) {
         api_path = Util.api_path(params.$parent.cwd, this.kernel)
@@ -309,8 +309,31 @@ class Shell {
     this.vts = new SerializeAddon()
     this.vt.loadAddon(this.vts)
 
+    const extractTerminalIdFromShellId = (shellId) => {
+      if (typeof shellId !== "string" || shellId.length === 0) {
+        return ""
+      }
+      const separatorIndex = shellId.indexOf("?")
+      if (separatorIndex < 0) {
+        return ""
+      }
+      const queryString = shellId.slice(separatorIndex + 1).replace(/&amp;/g, "&")
+      try {
+        const parsed = new URLSearchParams(queryString)
+        return typeof parsed.get("terminal_id") === "string" ? parsed.get("terminal_id").trim() : ""
+      } catch (error) {
+        return ""
+      }
+    }
+
     // 1. id
     this.id = (params.id ? params.id : uuidv4())
+    const explicitTerminalId = typeof params.terminal_id === "string" ? params.terminal_id.trim() : ""
+    const resolvedTerminalId = explicitTerminalId || extractTerminalIdFromShellId(this.id)
+    this.terminal_id = resolvedTerminalId || null
+    if (resolvedTerminalId) {
+      params.terminal_id = resolvedTerminalId
+    }
 
     // 2. group id
     this.group = params.group
@@ -323,6 +346,20 @@ class Shell {
     this.ondata({ raw: `\r\n████\r\n██ Starting Shell ${this.id}\r\n` })
 
     this.start_time = Date.now()
+    const cloneSourceMessage = (value) => {
+      if (Array.isArray(value)) {
+        return value.slice()
+      }
+      if (value && typeof value === "object") {
+        try {
+          return JSON.parse(JSON.stringify(value))
+        } catch (error) {
+          return value
+        }
+      }
+      return value
+    }
+    this.source_message = cloneSourceMessage(params.message)
     this.params = params
     this.EOL = os.EOL
     if (this.params.shell) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "6.0.28",
+  "version": "6.0.40",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -11,6 +11,7 @@
   "license": "MIT",
   "dependencies": {
     "@homebridge/node-pty-prebuilt-multiarch": "0.12.0-beta.5",
+    "@parcel/watcher": "2.5.1",
     "@xterm/headless": "^5.5.0",
     "7zip-min-win-asar-support": "^1.4.4",
     "accepts": "^1.3.8",
@@ -57,6 +58,7 @@
     "lodash": "^4.17.21",
     "marked": "^5.0.1",
     "mime-types": "^2.1.35",
+    "minisearch": "^7.2.0",
     "multer": "^1.4.5-lts.1",
     "node-downloader-helper": "^2.1.9",
     "node-gradio-client": "^0.14.6",
@@ -86,7 +88,10 @@
     "xterm-addon-serialize": "^0.9.0",
     "xterm-headless": "^5.1.0",
     "yaml": "^2.3.4",
-    "yargs-unparser-custom-flag": "^2.0.0",
-    "@parcel/watcher": "^2.4.1"
+    "yargs-unparser-custom-flag": "^2.0.0"
+  },
+  "optionalDependencies": {
+    "@parcel/watcher-linux-arm64-glibc": "2.5.1",
+    "@parcel/watcher-linux-arm64-musl": "2.5.1"
   }
 }

package/prototype/system/SKILL_PINOKIO.md

@@ -0,0 +1,134 @@
+---
+name: Pinokio
+description: Use pterm to discover apps, ensure they are running, and execute API requests with generated-once reusable clients.
+---
+
+# Pinokio Runtime Skill (pterm-first)
+
+Use this skill for runtime control of Pinokio apps.
+Do not ask users to manually install, launch, or call APIs when `pterm` can do it.
+
+## Control Plane
+
+Assume `pterm` is preinstalled and up to date.
+Use direct `pterm` commands for control-plane operations:
+
+1. `pterm search "<query>"`
+2. `pterm status <app_id>`
+3. `pterm run <app_path>`
+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.
+
+Permission handling:
+- If a `pterm` command fails with loopback permission errors (`EPERM`/`EACCES` to `127.0.0.1:42000`), rerun the same command with required escalation/approval.
+- Continue normal flow if rerun succeeds.
+- Fail only if escalation is denied or rerun still cannot reach Pinokio.
+
+## 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:
+     - exact `app_id`/title match (for explicit app requests)
+     - `starred=true` (user preference)
+     - `ready=true`
+     - higher `matched_terms_count` (if available)
+     - higher `launch_count_total` (if available)
+     - more recent `last_launch_at` (if available)
+     - higher `score`
+     - `running=true`
+   - 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>`.
+   - 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.
+
+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).
+   - Cache location:
+     - `~/pinokio/agents/clients/<app_id>/<operation>.<ext>`
+   - 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
+
+## 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.
+- 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.
+
+## 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`.
+
+## 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`.