pinokiod 3.270.0 → 3.272.0

package/kernel/app_launcher/platform/macos.js

@@ -0,0 +1,163 @@
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+const { execFile } = require('child_process')
+const { promisify } = require('util')
+const BaseAdapter = require('./base')
+
+const execFileAsync = promisify(execFile)
+const OPEN_BINARY = '/usr/bin/open'
+const DEFAULT_DIRECTORIES = [
+  '/Applications',
+  '/System/Applications',
+  '/System/Applications/Utilities',
+  '/System/Library/CoreServices/Applications',
+  path.join(os.homedir(), 'Applications')
+]
+
+class MacOSAdapter extends BaseAdapter {
+  constructor(kernel) {
+    super(kernel)
+    this.directories = DEFAULT_DIRECTORIES
+    this.walkSeen = new Set()
+  }
+
+  async buildIndex() {
+    this.entries.clear()
+    this.walkSeen.clear()
+    for (const dir of this.directories) {
+      await this.walkApplications(dir)
+    }
+  }
+
+  async walkApplications(root) {
+    if (!root) {
+      return
+    }
+    const normalized = path.resolve(root)
+    if (this.walkSeen.has(normalized)) {
+      return
+    }
+    this.walkSeen.add(normalized)
+    let entries
+    try {
+      entries = await fs.promises.readdir(normalized, { withFileTypes: true })
+    } catch (_) {
+      return
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith('.')) {
+        continue
+      }
+      const fullPath = path.join(normalized, entry.name)
+      if (entry.name.toLowerCase().endsWith('.app')) {
+        await this.addBundle(fullPath)
+        continue
+      }
+      if (entry.isDirectory()) {
+        await this.walkApplications(fullPath)
+      }
+    }
+  }
+
+  async addBundle(bundlePath) {
+    const infoPath = path.join(bundlePath, 'Contents', 'Info.plist')
+    let info = null
+    try {
+      info = await this.readPlist(infoPath)
+    } catch (_) {
+    }
+    const baseName = path.basename(bundlePath, '.app')
+    const displayName = (info && (info.CFBundleDisplayName || info.CFBundleName)) || baseName
+    const bundleId = info && info.CFBundleIdentifier ? info.CFBundleIdentifier : null
+    const execName = info && info.CFBundleExecutable ? info.CFBundleExecutable : null
+    const execPath = execName ? path.join(bundlePath, 'Contents', 'MacOS', execName) : null
+    let id = bundleId || `bundle-path:${bundlePath}`
+    if (this.entries.has(id)) {
+      let suffix = 1
+      while (this.entries.has(`${id}#${suffix}`)) {
+        suffix += 1
+      }
+      id = `${id}#${suffix}`
+    }
+    const aliases = [baseName]
+    if (bundleId) {
+      aliases.push(bundleId)
+    }
+    if (execName) {
+      aliases.push(execName)
+    }
+    this.addEntry({
+      id,
+      name: displayName,
+      aliases,
+      kind: 'macos-bundle',
+      bundleId,
+      path: bundlePath,
+      execPath,
+      detail: bundleId || bundlePath
+    })
+  }
+
+  async readPlist(plistPath) {
+    try {
+      const { stdout } = await execFileAsync('plutil', ['-convert', 'json', '-o', '-', plistPath], {
+        maxBuffer: 2 * 1024 * 1024
+      })
+      if (!stdout) {
+        return null
+      }
+      return JSON.parse(stdout)
+    } catch (_) {
+      return null
+    }
+  }
+
+  async launch(entry, params = {}) {
+    const args = this.sanitizeArgs(params.args)
+    const openArgs = []
+    if (entry.bundleId) {
+      openArgs.push('-b', entry.bundleId)
+    } else if (entry.path) {
+      openArgs.push('-a', entry.path)
+    } else if (entry.name) {
+      openArgs.push('-a', entry.name)
+    }
+    if (args.length > 0) {
+      openArgs.push('--args', ...args)
+    }
+    const result = await this.spawnDetached(OPEN_BINARY, openArgs)
+    return {
+      success: true,
+      id: entry.id,
+      name: entry.name,
+      kind: entry.kind,
+      launcher: 'macos-open',
+      pid: result.pid || null,
+      detail: entry.bundleId || entry.path || entry.name
+    }
+  }
+
+  async launchUnknown(params = {}) {
+    if (!params.app) {
+      return super.launchUnknown(params)
+    }
+    const args = this.sanitizeArgs(params.args)
+    const openArgs = ['-a', params.app]
+    if (args.length > 0) {
+      openArgs.push('--args', ...args)
+    }
+    const result = await this.spawnDetached(OPEN_BINARY, openArgs)
+    return {
+      success: true,
+      id: null,
+      name: params.app,
+      kind: 'macos-bundle',
+      launcher: 'macos-open',
+      pid: result.pid || null,
+      detail: params.app
+    }
+  }
+}
+
+module.exports = MacOSAdapter

package/kernel/app_launcher/platform/unsupported.js

@@ -0,0 +1,34 @@
+const BaseAdapter = require('./base')
+
+class UnsupportedAdapter extends BaseAdapter {
+  constructor(kernel) {
+    super(kernel)
+    this.reason = `App launching is not supported on platform ${this.platform}`
+  }
+
+  async buildIndex() {
+    this.entries.clear()
+  }
+
+  async search() {
+    throw new Error(this.reason)
+  }
+
+  async info() {
+    throw new Error(this.reason)
+  }
+
+  async refresh() {
+    throw new Error(this.reason)
+  }
+
+  async launch() {
+    throw new Error(this.reason)
+  }
+
+  async launchUnknown() {
+    throw new Error(this.reason)
+  }
+}
+
+module.exports = UnsupportedAdapter

package/kernel/app_launcher/platform/windows.js

@@ -0,0 +1,247 @@
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+const { execFile } = require('child_process')
+const { promisify } = require('util')
+const BaseAdapter = require('./base')
+
+const execFileAsync = promisify(execFile)
+
+class WindowsAdapter extends BaseAdapter {
+  constructor(kernel) {
+    super(kernel)
+    this.systemRoot = process.env.SystemRoot || 'C:\\Windows'
+    this.powershellBinary = this.resolvePowerShell()
+  }
+
+  resolvePowerShell() {
+    const explicit = process.env.POWERSHELL || process.env.POWERSHELL_EXE
+    if (explicit) {
+      return explicit
+    }
+    const candidate = path.join(this.systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe')
+    try {
+      if (fs.existsSync(candidate)) {
+        return candidate
+      }
+    } catch (_) {
+    }
+    return 'powershell.exe'
+  }
+
+  startMenuDirs() {
+    const dirs = []
+    const programData = process.env.ProgramData
+    if (programData) {
+      dirs.push(path.join(programData, 'Microsoft', 'Windows', 'Start Menu', 'Programs'))
+    }
+    const appData = process.env.APPDATA
+    if (appData) {
+      dirs.push(path.join(appData, 'Microsoft', 'Windows', 'Start Menu', 'Programs'))
+    }
+    return dirs
+  }
+
+  async buildIndex() {
+    this.entries.clear()
+    await this.collectShortcuts()
+    await this.collectStartApps()
+  }
+
+  async collectShortcuts() {
+    const dirs = this.startMenuDirs()
+    for (const dir of dirs) {
+      await this.walkShortcuts(dir)
+    }
+  }
+
+  async walkShortcuts(root) {
+    if (!root) {
+      return
+    }
+    const stack = [root]
+    const visited = new Set()
+    while (stack.length > 0) {
+      const current = stack.pop()
+      if (!current) {
+        continue
+      }
+      const normalized = path.resolve(current)
+      if (visited.has(normalized)) {
+        continue
+      }
+      visited.add(normalized)
+      let entries
+      try {
+        entries = await fs.promises.readdir(normalized, { withFileTypes: true })
+      } catch (_) {
+        continue
+      }
+      for (const entry of entries) {
+        if (entry.name.startsWith('.')) {
+          continue
+        }
+        const fullPath = path.join(normalized, entry.name)
+        if (entry.isDirectory()) {
+          stack.push(fullPath)
+          continue
+        }
+        if (entry.isFile() && entry.name.toLowerCase().endsWith('.lnk')) {
+          const id = `shortcut:${fullPath.replace(/\\/g, '/')}`
+          const name = path.basename(entry.name, '.lnk')
+          this.addEntry({
+            id,
+            name,
+            aliases: [name.replace(/ shortcut$/i, ''), fullPath],
+            kind: 'windows-shortcut',
+            path: fullPath,
+            detail: path.relative(root, fullPath).replace(/\\/g, '/')
+          })
+        }
+      }
+    }
+  }
+
+  async collectStartApps() {
+    let apps = []
+    try {
+      apps = await this.readStartApps()
+    } catch (_) {
+      apps = []
+    }
+    for (const app of apps) {
+      if (!app || !app.Name || !app.AppId) {
+        continue
+      }
+      const id = `appx:${app.AppId}`
+      this.addEntry({
+        id,
+        name: app.Name,
+        aliases: [app.AppId],
+        kind: 'windows-appx',
+        appId: app.AppId,
+        detail: app.AppId
+      })
+    }
+  }
+
+  async readStartApps() {
+    const script = `
+$ErrorActionPreference = 'SilentlyContinue'
+$apps = Get-StartApps | Select-Object -Property Name, AppId
+$apps | ConvertTo-Json -Depth 4 -Compress
+`
+    const { stdout } = await this.runPowerShell(script)
+    if (!stdout) {
+      return []
+    }
+    try {
+      const parsed = JSON.parse(stdout)
+      if (Array.isArray(parsed)) {
+        return parsed
+      }
+      if (parsed) {
+        return [parsed]
+      }
+      return []
+    } catch (_) {
+      return []
+    }
+  }
+
+  quotePowerShell(value) {
+    const str = String(value === undefined || value === null ? '' : value)
+    return `'${str.replace(/'/g, "''")}'`
+  }
+
+  buildPowerShellArray(items) {
+    if (!items || items.length === 0) {
+      return '@()'
+    }
+    const encoded = items.map((item) => this.quotePowerShell(item))
+    return `@(${encoded.join(',')})`
+  }
+
+  async runPowerShell(script) {
+    const wrapped = `& {\n${script}\n}`
+    try {
+      return await execFileAsync(this.powershellBinary, [
+        '-NoProfile',
+        '-NoLogo',
+        '-NonInteractive',
+        '-ExecutionPolicy',
+        'Bypass',
+        '-Command',
+        wrapped
+      ], {
+        windowsHide: true,
+        maxBuffer: 8 * 1024 * 1024
+      })
+    } catch (error) {
+      error.script = script
+      throw error
+    }
+  }
+
+  async launch(entry, params = {}) {
+    const args = this.sanitizeArgs(params.args)
+    if (entry.kind === 'windows-shortcut') {
+      return this.launchShortcut(entry, args)
+    }
+    if (entry.kind === 'windows-appx') {
+      if (args.length > 0) {
+        throw new Error('Passing args to Windows Store applications is not supported')
+      }
+      return this.launchAppx(entry)
+    }
+    throw new Error(`Unsupported Windows app kind: ${entry.kind}`)
+  }
+
+  async launchShortcut(entry, args) {
+    const argLiteral = this.buildPowerShellArray(args)
+    const script = `
+$path = ${this.quotePowerShell(entry.path)}
+$extra = ${argLiteral}
+$ErrorActionPreference = 'Stop'
+$ws = New-Object -ComObject WScript.Shell
+$shortcut = $ws.CreateShortcut($path)
+$target = $shortcut.TargetPath
+if (-not $target) { throw 'Shortcut is missing a target' }
+$argumentList = @()
+if ($shortcut.Arguments) { $argumentList += $shortcut.Arguments }
+if ($extra.Count -gt 0) { $argumentList += $extra }
+$startInfo = @{ FilePath = $target }
+if ($argumentList.Count -gt 0) { $startInfo.ArgumentList = $argumentList }
+if ($shortcut.WorkingDirectory) { $startInfo.WorkingDirectory = $shortcut.WorkingDirectory }
+Start-Process @startInfo | Out-Null
+`
+    await this.runPowerShell(script)
+    return {
+      success: true,
+      id: entry.id,
+      name: entry.name,
+      kind: entry.kind,
+      launcher: 'powershell-shortcut',
+      detail: entry.path
+    }
+  }
+
+  async launchAppx(entry) {
+    const literal = this.quotePowerShell(`shell:AppsFolder\\${entry.appId}`)
+    const script = `
+$ErrorActionPreference = 'Stop'
+Start-Process -FilePath ${literal} | Out-Null
+`
+    await this.runPowerShell(script)
+    return {
+      success: true,
+      id: entry.id,
+      name: entry.name,
+      kind: entry.kind,
+      launcher: 'powershell-appx',
+      detail: entry.appId
+    }
+  }
+}
+
+module.exports = WindowsAdapter

package/kernel/bin/conda-meta.js

@@ -0,0 +1,93 @@
+const fs = require('fs')
+const path = require('path')
+const { execFile } = require('child_process')
+
+async function buildCondaListFromMeta(minicondaPath, useCondaList) {
+  if (!useCondaList) {
+    const metaOutput = await readFromMeta(minicondaPath)
+    if (metaOutput) {
+      return { response: metaOutput, source: 'conda-meta' }
+    }
+  }
+  return await runCondaList(minicondaPath)
+}
+
+async function readFromMeta(minicondaPath) {
+  if (!minicondaPath) {
+    return null
+  }
+  const metaDir = path.join(minicondaPath, 'conda-meta')
+  let entries
+  try {
+    entries = await fs.promises.readdir(metaDir, { withFileTypes: true })
+  } catch (err) {
+    return null
+  }
+  const lines = [
+    '# packages in environment (generated from conda-meta)',
+    '#',
+    '# name version build channel'
+  ]
+  let count = 0
+  for (const entry of entries) {
+    if (!entry || !entry.isFile() || !entry.name.endsWith('.json')) {
+      continue
+    }
+    const fullpath = path.join(metaDir, entry.name)
+    try {
+      const content = await fs.promises.readFile(fullpath, 'utf8')
+      const json = JSON.parse(content)
+      if (json && json.name && json.version) {
+        const build = json.build_string || json.build || 'meta'
+        const channel = json.channel || ''
+        lines.push(`${json.name} ${json.version} ${build} ${channel}`)
+        count++
+      }
+    } catch (err) {
+      // ignore malformed entries
+    }
+  }
+  if (count === 0) {
+    return null
+  }
+  return lines.join('\n')
+}
+
+async function runCondaList(minicondaPath) {
+  const condaBinary = resolveCondaBinary(minicondaPath)
+  if (!condaBinary) {
+    return { response: '', source: 'conda-list' }
+  }
+  return await new Promise((resolve) => {
+    execFile(condaBinary, ['list'], { windowsHide: true }, (err, stdout) => {
+      if (err) {
+        resolve({ response: '', source: 'conda-list' })
+      } else {
+        resolve({ response: stdout || '', source: 'conda-list' })
+      }
+    })
+  })
+}
+
+function resolveCondaBinary(minicondaPath) {
+  if (process.platform === 'win32') {
+    if (minicondaPath) {
+      const scriptPath = path.join(minicondaPath, 'Scripts', 'conda.exe')
+      if (fs.existsSync(scriptPath)) {
+        return scriptPath
+      }
+    }
+    return 'conda'
+  }
+  if (minicondaPath) {
+    const binPath = path.join(minicondaPath, 'bin', 'conda')
+    if (fs.existsSync(binPath)) {
+      return binPath
+    }
+  }
+  return 'conda'
+}
+
+module.exports = {
+  buildCondaListFromMeta
+}

package/kernel/bin/conda.js

@@ -3,6 +3,7 @@ const path = require('path')
 const fetch = require('cross-fetch')
 const { glob } = require('glob')
 const semver = require('semver')
+const { buildCondaListFromMeta } = require('./conda-meta')
 class Conda {
   description = "Pinokio uses Conda to install various useful programs in an isolated manner."
   urls = {
@@ -122,10 +123,7 @@ report_errors: false`)
 //    }
 //  }
   async check() {
-    let res = await this.kernel.bin.exec({ message: `conda list` }, (stream) => {
-//      process.stdout.write(stream.raw)
-//        console.log("conda list check", { stream })
-    })
+    let res = await buildCondaListFromMeta(this.kernel.bin.path("miniconda"))
 
     let lines = res.response.split(/[\r\n]+/)
     let conda_check = {}

package/kernel/bin/index.js

@@ -22,6 +22,7 @@ const VS = require("./vs")
 const Cuda = require("./cuda")
 const Torch = require("./torch")
 const { detectCommandLineTools } = require('./xcode-tools')
+const { buildCondaListFromMeta } = require('./conda-meta')
 const { glob } = require('glob')
 const fakeUa = require('fake-useragent');
 const fse = require('fs-extra')
@@ -349,10 +350,7 @@ class Bin {
     if (to_reset_exists) {
       this.correct_conda = false
     } else {
-      res = await this.exec({ message: `conda list` }, (stream) => {
-  //        console.log("conda list check", { stream })
-      })
-
+      let res = await buildCondaListFromMeta(this.kernel.bin.path("miniconda"))
       let lines = res.response.split(/[\r\n]+/)
       for(let line of lines) {
         if (start) {

package/kernel/index.js

@@ -39,6 +39,7 @@ const Peer = require('./peer')
 const Git = require('./git')
 const Connect = require('./connect')
 const Favicon = require('./favicon')
+const AppLauncher = require('./app_launcher')
 const { DownloaderHelper } = require('node-downloader-helper');
 const { ProxyAgent } = require('proxy-agent');
 const fakeUa = require('fake-useragent');
@@ -803,6 +804,7 @@ class Kernel {
   async init(options) {
 
     let home = this.store.get("home") || process.env.PINOKIO_HOME
+    this.homedir = home
 
     // reset shells if they exist
     if (this.shell) {
@@ -820,10 +822,9 @@ class Kernel {
     this.kv = new KV(this)
     this.cloudflare = new Cloudflare()
     this.peer = new Peer(this)
+    await this.peer.initialize(this)
     this.git = new Git(this)
 
-    this.homedir = home
-
 //    if (home) {
 //      this.homedir = home
 //    } else {
@@ -867,6 +868,12 @@ class Kernel {
     this.api = new Api(this)
     this.python = new Python(this)
     this.shell = new Shells(this)
+    this.appLauncher = new AppLauncher(this)
+    if (typeof this.appLauncher.init === 'function') {
+      this.appLauncher.init().catch((error) => {
+        console.warn('[Kernel] AppLauncher init failed:', error && error.message ? error.message : error)
+      })
+    }
     this.pinokio_domain_value = (process.env.PINOKIO_DOMAIN || '').trim()
     if (this.pinokio_domain_value) {
       this.router = new PinokioDomainRouter(this)