pinokiod 5.0.0 → 5.0.2

package/kernel/api/app/index.js

@@ -221,6 +221,26 @@ AppAPI.prototype.manualLaunchHtml = function manualLaunchHtml(appName) {
   `
 }
 
+AppAPI.prototype.buildManualConfirmActions = function buildManualConfirmActions(appName) {
+  return [
+    {
+      id: 'reveal',
+      label: 'Open in Finder',
+      type: 'submit',
+      variant: 'secondary',
+      close: false
+    },
+    {
+      id: 'confirm-open',
+      label: `I've opened ${appName}`,
+      type: 'submit',
+      variant: 'primary',
+      primary: true,
+      close: false
+    }
+  ]
+}
+
 AppAPI.prototype.handleInstallFlow = async function handleInstallFlow({ req, ondata, kernel, launcher, params }) {
   const installUrl = params.install
   if (!installUrl) {
@@ -380,6 +400,153 @@ AppAPI.prototype.waitForInstall = async function waitForInstall({ req, ondata, k
   return null
 }
 
+AppAPI.prototype.waitForManualConfirmation = async function waitForManualConfirmation({ req, ondata, kernel, entry, appName, modalId }) {
+  const safeName = escapeHtml(entry.name || appName)
+  const readyId = modalId || `app-ready:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`
+  const payload = {
+    title: entry.name || appName,
+    html: this.manualLaunchHtml(entry.name || appName),
+    status: { text: `Open ${safeName} once from Finder, then confirm below.` },
+    actions: this.buildManualConfirmActions(entry.name || appName),
+    actionsAlign: 'end',
+    await: true,
+    dismissible: false
+  }
+
+  while (true) {
+    const response = modalId
+      ? await this.htmlModal.update(this.modalRequest(req, readyId, payload), ondata, kernel)
+      : await this.htmlModal.open(this.modalRequest(req, readyId, payload), ondata, kernel)
+    if (!response) {
+      continue
+    }
+    if (response.action === 'reveal') {
+      await this.openInExplorer(entry.path, kernel)
+      payload.status = {
+        text: `Opened Finder at ${safeName}. After approving it, click "I've opened it".`
+      }
+      continue
+    }
+    if (['cancel', 'close', 'dismissed'].includes(response.action)) {
+      await this.htmlModal.close(this.modalRequest(req, readyId, {}), ondata, kernel)
+      throw new Error('Wait cancelled by user')
+    }
+    if (response.action === 'confirm-open') {
+      await this.htmlModal.update(
+        this.modalRequest(req, readyId, {
+          status: { text: `${safeName} is ready.`, variant: 'success' },
+          actions: [],
+          dismissible: true
+        }),
+        ondata,
+        kernel
+      )
+      await this.htmlModal.close(this.modalRequest(req, readyId, {}), ondata, kernel)
+      return entry
+    }
+  }
+}
+
+AppAPI.prototype.waitForAppPresence = async function waitForAppPresence(req, ondata, kernel) {
+  const params = req.params || {}
+  const appName = params.app || params.name || params.id
+  if (!appName) {
+    throw new Error('process.wait requires params.app or params.id when using app presence mode')
+  }
+  const launcher = this.ensureService(kernel)
+  const pollInterval = Number(params.installPollIntervalMs || params.installPollInterval) > 0
+    ? Number(params.installPollIntervalMs || params.installPollInterval)
+    : DEFAULT_INSTALL_INTERVAL
+  const timeout = Number(params.installTimeoutMs || params.installTimeout) > 0
+    ? Number(params.installTimeoutMs || params.installTimeout)
+    : DEFAULT_INSTALL_TIMEOUT
+
+  let entry = null
+  if (params.id) {
+    try {
+      entry = await launcher.info({ id: params.id, refresh: params.refresh })
+    } catch (_) {
+    }
+  }
+  if (!entry) {
+    const match = await launcher.findMatch(appName, { force: false })
+    if (match && match.entry) {
+      entry = match.entry
+    }
+  }
+
+  if (entry) {
+    return entry
+  }
+
+  const installUrl = params.install
+  if (!installUrl) {
+    const error = new Error(`Application "${appName}" was not found and no install URL was provided`)
+    error.code = 'APP_NOT_FOUND'
+    throw error
+  }
+
+  const modalId = `app-install:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`
+  const actions = this.buildInstallActions(appName, installUrl)
+
+  await this.htmlModal.open(
+    this.modalRequest(req, modalId, {
+      title: `Install ${appName}`,
+      html: this.installIntroHtml(appName, installUrl),
+      status: { text: `Waiting for ${escapeHtml(appName)} to be installed...`, waiting: true },
+      actions,
+      dismissible: false
+    }),
+    ondata,
+    kernel
+  )
+
+  entry = await this.waitForInstall({
+    req,
+    ondata,
+    kernel,
+    launcher,
+    appName,
+    modalId,
+    pollInterval,
+    timeout,
+    actions
+  })
+
+  if (!entry) {
+    await this.htmlModal.update(
+      this.modalRequest(req, modalId, {
+        status: { text: `Still cannot find ${escapeHtml(appName)}. Please complete the installation and try again.`, variant: 'error' },
+        actions: this.buildInstallActions(appName, installUrl, [{
+          id: 'close',
+          label: 'Close',
+          type: 'submit',
+          variant: 'secondary',
+          close: true
+        }]),
+        await: true
+      }),
+      ondata,
+      kernel
+    )
+    await this.htmlModal.close(this.modalRequest(req, modalId, {}), ondata, kernel)
+    throw new Error(`Timed out waiting for ${appName} to be installed`)
+  }
+
+  const needsManualLaunch = await this.requiresManualLaunch(entry, kernel)
+  await this.htmlModal.update(
+    this.modalRequest(req, modalId, {
+      status: { text: `${escapeHtml(entry.name || appName)} detected.`, variant: 'success' },
+      actions: [],
+      dismissible: true
+    }),
+    ondata,
+    kernel
+  )
+  await this.htmlModal.close(this.modalRequest(req, modalId, {}), ondata, kernel)
+  return entry
+}
+
 AppAPI.prototype.requiresManualLaunch = async function requiresManualLaunch(entry, kernel) {
   if (!entry || kernel.platform !== 'darwin') {
     return false

package/kernel/api/index.js

@@ -1498,6 +1498,10 @@ class Api {
 //    let keypath = path.resolve(this.kernel.homedir, "key.json")
 //    this.kernel.keys = (await this.loader.load(keypath)).resolved
 
+    // ensure gitconfig carries required defaults before any shell commands run
+    if (this.kernel.git && typeof this.kernel.git.ensureDefaults === "function") {
+      await this.kernel.git.ensureDefaults()
+    }
     // init shell before running just to make sure the environment variables are fresh
     await this.kernel.shell.init()
 

package/kernel/api/process/index.js

@@ -1,5 +1,6 @@
 const waitOn = require('wait-on');
 const axios = require('axios');
+const AppAPI = require('../app');
 async function checkUrlStatus(url, message, interval, ondata) {
   try {
     console.log({ check: url, interval })
@@ -30,6 +31,9 @@ async function waitForUrl(url, message, interval, ondata) {
   }
 }
 class Process {
+  constructor() {
+    this.appApi = new AppAPI()
+  }
 //  async start(req, ondata, kernel) {
 //    /*
 //      req := {
@@ -181,6 +185,19 @@ class Process {
 
     or
 
+    params := {
+      app: <APP NAME OR ID>,
+      install: <INSTALL URL>,
+      installTimeoutMs: (optional) how long to wait for detection,
+      installPollIntervalMs: (optional) how often to poll for detection
+    }
+
+    If the app is already present, return immediately. If missing and install is
+    provided, show the install modal and poll until the app is detected, then
+    return (no launch). If missing and no install, throw.
+
+    or
+
 
     params := {
       on: <wait-on condition https://github.com/jeffbski/wait-on>,
@@ -197,6 +214,10 @@ class Process {
     */
     let ms 
     if (req.params) {
+      if (req.params.app || req.params.id || req.params.name) {
+        await this.appApi.waitForAppPresence(req, ondata, kernel)
+        return
+      }
       // Display modal
       if (req.params.sec || req.params.min) {
         // Wait

package/kernel/bin/browserless.js

@@ -1,3 +1,6 @@
+const fs = require('fs')
+const path = require('path')
+
 class Browserless {
   description = "The headless Chrome/Chromium driver"
   async uninstall(req, ondata) {
@@ -11,12 +14,19 @@ class Browserless {
     }, ondata)
   }
   async installed() {
-    let browserless = this.kernel.which('browserless')
-    if (browserless) {
-      return true
-    } else {
-      return false
+    const base = this.kernel.path("bin/npm")
+    const candidates = this.kernel.platform === "win32"
+      ? ["browserless.cmd", "browserless.ps1"]
+      : ["browserless"]
+    for (const name of candidates) {
+      try {
+        await fs.promises.access(path.join(base, name), fs.constants.F_OK)
+        return true
+      } catch (_) {
+        // keep checking other candidates
+      }
     }
+    return false
   }
 }
 module.exports = Browserless

package/kernel/bin/cli.js

@@ -16,27 +16,20 @@ class CLI {
       exists = await Util.exists(this.kernel.path("bin/npm/bin/pterm"))
     }
     if (exists) {
-//      let p = this.kernel.which("pterm")
-//      console.log({ exists, p})
-//      if (p) {
-        let res = await this.kernel.exec({
-          message: "pterm version terminal"
-        }, ondata)
-        let e = /pterm@([0-9.]+)/.exec(res.stdout)
-        if (e && e.length > 0) {
-          let v = e[1]
-          let coerced = semver.coerce(v)
-          if (semver.satisfies(coerced, this.version)) {
-            return true
-          } else {
-            return false
-          }
-        } else {
-          return false
+      try {
+        const moduleRoot = this.kernel.platform === "win32"
+          ? this.kernel.path("bin/npm/node_modules")
+          : this.kernel.path("bin/npm/lib/node_modules")
+        const pkgPath = require.resolve("pterm/package.json", { paths: [moduleRoot] })
+        const { version } = require(pkgPath)
+        const coerced = semver.coerce(version)
+        if (coerced && semver.satisfies(coerced, this.version)) {
+          return true
         }
-//      } else {
-//        return false
-//      }
+        return false
+      } catch (err) {
+        return false
+      }
     } else {
       return false
     }

package/kernel/bin/cuda.js

@@ -106,8 +106,14 @@ class Cuda {
     }
   }
   env() {
-    return {
-      CUDA_HOME: this.kernel.bin.path("miniconda")
+    if (this.kernel.platform === 'win32') {
+      return {
+        CUDA_HOME: this.kernel.bin.path("miniconda/Library")
+      }
+    } else {
+      return {
+        CUDA_HOME: this.kernel.bin.path("miniconda")
+      }
     }
   }
 //  env() {

package/kernel/bin/index.js

@@ -433,25 +433,27 @@ class Bin {
 
       let brew = []
       if (brew_exists) {
-        start = false
-        res = await this.exec({ message: `brew list -1`, conda: { skip: true } }, (stream) => {
-        })
-        lines = res.response.split(/[\r\n]+/).slice(0, -1)  // ignore last line since it's the prompt
-        let end = false
-        for(let line of lines) {
-          if (start) {
-            if (/^\s*$/.test(line)) {
-              end = true
-            } else {
-              if (!end) {
-                let chunks = line.split(/\s+/).filter(x => x)
-                brew = brew.concat(chunks)
-              }
-            }
-          } else {
-            if (/==>/.test(line)) {
-              start = true
-            }
+        const cellarPath = path.resolve(brew_path, "Cellar")
+        let usedCellar = false
+        try {
+          const entries = await fs.promises.readdir(cellarPath, { withFileTypes: true })
+          brew = entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+          usedCellar = true
+        } catch (err) {
+          console.log("[brew] cellar scan failed, falling back to brew list -1", err)
+        }
+
+        if (!usedCellar) {
+          start = false
+          res = await this.exec({ message: `brew list -1`, conda: { skip: true } }, () => { })
+          lines = res.response.split(/[\r\n]+/).slice(0, -1)  // ignore last line since it's the prompt
+          const parsed = lines
+            .map((raw) => raw.trim())
+            .filter((line) => line.length > 0 && !/^==>/.test(line))
+          for (const line of parsed) {
+            brew = brew.concat(line.split(/\s+/).filter(Boolean))
           }
         }
       }
@@ -463,9 +465,11 @@ class Bin {
       const cltStatus = await detectCommandLineTools({
         exec: (params) => this.exec(params, () => {})
       })
-      console.log("BREW CHECK", { homebrew: e, cltStatus })
+      console.log({ cltStatus })
       this.brew_installed = e && cltStatus.valid
 
+      console.log("brew_installed", this.brew_installed)
+
     }
 
     if (this.platform === "win32") {

package/kernel/bin/xcode-tools.js

@@ -2,6 +2,11 @@ const fs = require('fs')
 const semver = require('semver')
 
 const MIN_CLT_VERSION = '13.0'
+const PREFERRED_PKG_IDS = [
+  'com.apple.pkg.CLTools_Executables',
+  'com.apple.pkg.DeveloperToolsCLI',
+  'com.apple.pkg.Xcode'
+]
 const PACKAGE_MATCHERS = [
   /^com\.apple\.pkg\.CLTools_/, 
   /^com\.apple\.pkg\.DeveloperToolsCLI$/, 
@@ -104,7 +109,28 @@ async function detectCommandLineTools({ exec }) {
   return status
 }
 
+async function pkgInfoFor(run, pkgId) {
+  try {
+    const result = await run(`pkgutil --pkg-info=${pkgId}`)
+    const stdout = result && result.stdout ? result.stdout : ''
+    const match = /version:\s*([^\n]+)/i.exec(stdout)
+    if (match) {
+      return { pkgId, version: match[1].trim() }
+    }
+  } catch (err) {
+    console.log(`[CLT] pkgutil --pkg-info ${pkgId} failed`, err)
+  }
+  return null
+}
+
 async function readPkgInfo(run) {
+  for (const pkgId of PREFERRED_PKG_IDS) {
+    const info = await pkgInfoFor(run, pkgId)
+    if (info) {
+      return info
+    }
+  }
+
   let candidates = []
   try {
     const listResult = await run('pkgutil --pkgs')
@@ -123,15 +149,9 @@ async function readPkgInfo(run) {
   console.log('[CLT] pkg candidates:', candidates)
 
   for (const pkgId of candidates) {
-    try {
-      const result = await run(`pkgutil --pkg-info=${pkgId}`)
-      const stdout = result && result.stdout ? result.stdout : ''
-      const match = /version:\s*([^\n]+)/i.exec(stdout)
-      if (match) {
-        return { pkgId, version: match[1].trim() }
-      }
-    } catch (err) {
-      console.log(`[CLT] pkgutil --pkg-info ${pkgId} failed`, err)
+    const info = await pkgInfoFor(run, pkgId)
+    if (info) {
+      return info
     }
   }
   return null

package/kernel/environment.js

@@ -628,7 +628,10 @@ const init = async (options, kernel) => {
       "/CLAUDE.md",
       "/GEMINI.md",
       "/QWEN.md",
-      "/.geminiignore"
+      "/.geminiignore",
+      ".clinerules",
+      ".cursorrules",
+      ".windsurfrules"
     ]
 
     const missingEntries = entriesToEnsure.filter(entry => !existingEntries.has(entry))

package/kernel/git.js

@@ -29,9 +29,11 @@ class Git {
       "push",
       "create",
       "commit",
+      "commit_files",
       "checkout",
       "reset_commit",
-      "reset_file"
+      "reset_file",
+      "reset_files"
     ]
     await Promise.all(scripts.map((name) => {
       const src = path.resolve(__dirname, `scripts/git/${name}`)
@@ -39,6 +41,70 @@ class Git {
       return fs.promises.copyFile(src, dest)
     }))
   }
+  async ensureDefaults(homeOverride) {
+    const home = homeOverride || this.kernel.homedir
+    if (!home) return
+
+    const gitconfigPath = path.resolve(home, "gitconfig")
+    const templatePath = path.resolve(__dirname, "gitconfig_template")
+    const templateConfig = ini.parse(await fs.promises.readFile(templatePath, "utf8"))
+    const required = [
+      { section: "init", key: "defaultBranch", value: "main" },
+      { section: "push", key: "autoSetupRemote", value: true },
+    ]
+
+    try {
+      await fs.promises.access(gitconfigPath, fs.constants.F_OK)
+    } catch (_) {
+      await fs.promises.copyFile(templatePath, gitconfigPath)
+      return
+    }
+
+    let config
+    let dirty = false
+    try {
+      const content = await fs.promises.readFile(gitconfigPath, "utf8")
+      config = ini.parse(content)
+    } catch (_) {
+      config = {}
+      dirty = true
+    }
+
+    for (const [section, tplSection] of Object.entries(templateConfig)) {
+      if (typeof tplSection !== "object" || tplSection === null) continue
+      if (!config[section]) {
+        config[section] = { ...tplSection }
+        dirty = true
+        continue
+      }
+      for (const [key, value] of Object.entries(tplSection)) {
+        if (!Object.prototype.hasOwnProperty.call(config[section], key)) {
+          config[section][key] = value
+          dirty = true
+        }
+      }
+    }
+
+    for (const { section, key, value } of required) {
+      if (!config[section]) {
+        config[section] = {}
+      }
+      const current = config[section][key]
+      if (String(current) !== String(value)) {
+        config[section][key] = value
+        dirty = true
+      }
+    }
+
+    if (config['credential "helperselector"']) {
+      delete config['credential "helperselector"']
+      dirty = true
+    }
+
+    if (dirty) {
+      await fs.promises.writeFile(gitconfigPath, ini.stringify(config))
+    }
+  }
   async findGitDirs(dir, results = []) {
     const entries = await fs.promises.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {

package/kernel/scripts/git/commit_files

@@ -0,0 +1,31 @@
+{
+  "run": [{
+    "when": "{{args.paths && args.paths.length > 0}}",
+    "method": "shell.run",
+    "params": {
+      "path": "{{args.cwd}}",
+      "message": [
+        "git add -- {{args.paths}}"
+      ]
+    }
+  }, {
+    "when": "{{args.untracked_paths && args.untracked_paths.length > 0}}",
+    "method": "shell.run",
+    "params": {
+      "path": "{{args.cwd}}",
+      "message": [
+        "git add -- {{args.untracked_paths}}"
+      ]
+    }
+  }, {
+    "when": "{{(args.paths && args.paths.length > 0) || (args.untracked_paths && args.untracked_paths.length > 0)}}",
+    "method": "shell.run",
+    "params": {
+      "chain": true,
+      "path": "{{args.cwd}}",
+      "message": [
+        "git commit -m \"{{args.message}}\""
+      ]
+    }
+  }]
+}

package/kernel/scripts/git/reset_files

@@ -0,0 +1,21 @@
+{
+  "run": [{
+    "when": "{{args.untracked_paths && args.untracked_paths.length > 0}}",
+    "method": "shell.run",
+    "params": {
+      "path": "{{args.cwd}}",
+      "message": [
+        "git clean -f -- {{args.untracked_paths}}"
+      ]
+    }
+  }, {
+    "when": "{{args.tracked_paths && args.tracked_paths.length > 0}}",
+    "method": "shell.run",
+    "params": {
+      "path": "{{args.cwd}}",
+      "message": [
+        "git restore -- {{args.tracked_paths}}"
+      ]
+    }
+  }]
+}

package/package.json

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