pinokiod 3.270.0 → 3.272.0

package/kernel/app_launcher/index.js

@@ -0,0 +1,115 @@
+const os = require('os')
+
+const PLATFORM_MODULE = {
+  darwin: './platform/macos',
+  win32: './platform/windows',
+  linux: './platform/linux'
+}
+
+class AppLauncher {
+  constructor(kernel) {
+    this.kernel = kernel
+    this.platform = os.platform()
+    this.adapter = null
+  }
+
+  async init() {
+    try {
+      const adapter = await this.ensureAdapter()
+      if (adapter && adapter.ensureIndex) {
+        await adapter.ensureIndex({ force: false })
+      }
+    } catch (error) {
+      console.warn('[AppLauncher] init failed:', error.message)
+    }
+  }
+
+  resolveAdapterModule() {
+    return PLATFORM_MODULE[this.platform] || './platform/unsupported'
+  }
+
+  async ensureAdapter() {
+    if (this.adapter) {
+      return this.adapter
+    }
+    const modulePath = this.resolveAdapterModule()
+    const Adapter = require(modulePath)
+    this.adapter = new Adapter(this.kernel)
+    return this.adapter
+  }
+
+  async search(params = {}) {
+    const adapter = await this.ensureAdapter()
+    return adapter.search(params)
+  }
+
+  async info(params = {}) {
+    if (!params || !params.id) {
+      throw new Error('app.info requires params.id')
+    }
+    const adapter = await this.ensureAdapter()
+    return adapter.info(params.id, { force: params.refresh })
+  }
+
+  async findMatch(query, options = {}) {
+    if (!query) {
+      return null
+    }
+    const adapter = await this.ensureAdapter()
+    return adapter.findMatch(query, options)
+  }
+
+  async refresh(params = {}) {
+    const adapter = await this.ensureAdapter()
+    return adapter.refresh(params)
+  }
+
+  async launch(params = {}) {
+    if (!params || (!params.id && !params.app)) {
+      throw new Error('app.launch requires params.app or params.id')
+    }
+    const adapter = await this.ensureAdapter()
+    if (params.refresh) {
+      await adapter.ensureIndex({ force: true })
+    } else {
+      await adapter.ensureIndex({ force: false })
+    }
+    let entry = null
+    let confidence = null
+    if (params.id) {
+      entry = adapter.getEntry(params.id)
+    }
+    if (!entry && params.app) {
+      const match = await adapter.findMatch(params.app, { force: false })
+      if (match) {
+        entry = match.entry
+        confidence = match.score
+      }
+    }
+    if (!entry) {
+      if (!params.install && adapter && typeof adapter.launchUnknown === 'function') {
+        return adapter.launchUnknown(params)
+      }
+      const error = new Error(params.app ? `Application "${params.app}" was not found` : 'Application not found')
+      error.code = 'APP_NOT_FOUND'
+      error.app = params.app || params.id
+      throw error
+    }
+    const result = await adapter.launch(entry, params)
+    if (result && typeof result === 'object') {
+      const response = Object.assign({}, result)
+      response.id = response.id || entry.id
+      response.name = response.name || entry.name
+      response.platform = response.platform || entry.platform || this.platform
+      response.kind = response.kind || entry.kind
+      response.detail = response.detail || entry.detail
+      if (confidence !== null && typeof confidence !== 'undefined') {
+        response.confidence = confidence
+      }
+      return response
+    }
+    return result
+  }
+}
+
+module.exports = AppLauncher

package/kernel/app_launcher/platform/base.js

@@ -0,0 +1,276 @@
+const { spawn } = require('child_process')
+const os = require('os')
+
+class BasePlatformAdapter {
+  constructor(kernel) {
+    this.kernel = kernel
+    this.platform = os.platform()
+    this.entries = new Map()
+    this.indexTimestamp = 0
+    this.indexTTL = 1000 * 60 * 5
+    this.indexPromise = null
+  }
+
+  async ensureIndex(options = {}) {
+    const force = Boolean(options.force)
+    const now = Date.now()
+    const expired = !this.indexTimestamp || (now - this.indexTimestamp > this.indexTTL)
+    if (!force && this.entries.size > 0 && !expired) {
+      return
+    }
+    if (this.indexPromise) {
+      return this.indexPromise
+    }
+    this.indexPromise = (async () => {
+      try {
+        await this.buildIndex()
+        this.indexTimestamp = Date.now()
+      } finally {
+        this.indexPromise = null
+      }
+    })()
+    return this.indexPromise
+  }
+
+  // subclasses must override
+  async buildIndex() {
+    throw new Error('buildIndex() not implemented')
+  }
+
+  listEntries() {
+    return Array.from(this.entries.values())
+  }
+
+  getEntry(id) {
+    if (!id) {
+      return null
+    }
+    return this.entries.get(id)
+  }
+
+  addEntry(entry) {
+    if (!entry || !entry.id) {
+      return
+    }
+    const aliases = Array.isArray(entry.aliases) ? entry.aliases.filter(Boolean) : []
+    const uniqueAliases = Array.from(new Set([entry.name, ...aliases].filter(Boolean)))
+    entry.aliases = uniqueAliases
+    entry.platform = entry.platform || this.platform
+    this.entries.set(entry.id, entry)
+  }
+
+  normalize(text) {
+    return (text || '').trim().toLowerCase()
+  }
+
+  scoreEntry(query, entry) {
+    if (!query) {
+      return 0
+    }
+    const candidates = new Set()
+    if (entry.name) {
+      candidates.add(entry.name)
+    }
+    if (entry.aliases) {
+      for (const alias of entry.aliases) {
+        candidates.add(alias)
+      }
+    }
+    if (entry.id) {
+      candidates.add(entry.id)
+    }
+    if (entry.detail) {
+      candidates.add(entry.detail)
+    }
+    if (entry.bundleId) {
+      candidates.add(entry.bundleId)
+    }
+    if (entry.desktopId) {
+      candidates.add(entry.desktopId)
+    }
+    let best = Number.POSITIVE_INFINITY
+    for (const candidate of candidates) {
+      const normalized = this.normalize(candidate)
+      if (!normalized) {
+        continue
+      }
+      if (normalized === query) {
+        return 0
+      }
+      if (normalized.startsWith(query)) {
+        best = Math.min(best, 1)
+      } else if (normalized.includes(query)) {
+        best = Math.min(best, 2)
+      }
+    }
+    if (best < Number.POSITIVE_INFINITY) {
+      return best
+    }
+    return best
+  }
+
+  formatEntry(entry) {
+    if (!entry) {
+      return null
+    }
+    const payload = {
+      id: entry.id,
+      name: entry.name,
+      platform: entry.platform || this.platform,
+      kind: entry.kind || 'app'
+    }
+    if (entry.aliases && entry.aliases.length > 0) {
+      payload.aliases = entry.aliases
+    }
+    if (entry.detail) {
+      payload.detail = entry.detail
+    }
+    const meta = {}
+    if (entry.bundleId) {
+      meta.bundleId = entry.bundleId
+    }
+    if (entry.desktopId) {
+      meta.desktopId = entry.desktopId
+    }
+    if (entry.appId) {
+      meta.appId = entry.appId
+    }
+    if (entry.path) {
+      meta.path = entry.path
+    }
+    if (entry.execPath) {
+      meta.execPath = entry.execPath
+    }
+    if (Object.keys(meta).length > 0) {
+      payload.meta = meta
+    }
+    return payload
+  }
+
+  sanitizeArgs(args) {
+    if (!args) {
+      return []
+    }
+    if (!Array.isArray(args)) {
+      return [String(args)]
+    }
+    return args
+      .filter((arg) => typeof arg !== 'undefined' && arg !== null)
+      .map((arg) => String(arg))
+  }
+
+  async search(options = {}) {
+    const { query = '', limit = 20, refresh = false } = options
+    await this.ensureIndex({ force: refresh })
+    const normalized = this.normalize(query)
+    let entries = this.listEntries()
+    if (!normalized) {
+      entries = entries.sort((a, b) => a.name.localeCompare(b.name))
+      return entries.slice(0, limit).map((entry) => this.formatEntry(entry))
+    }
+    const scored = []
+    for (const entry of entries) {
+      const score = this.scoreEntry(normalized, entry)
+      if (!Number.isFinite(score)) {
+        continue
+      }
+      if (score === Number.POSITIVE_INFINITY) {
+        continue
+      }
+      scored.push({ entry, score })
+    }
+    scored.sort((a, b) => {
+      if (a.score !== b.score) {
+        return a.score - b.score
+      }
+      return a.entry.name.localeCompare(b.entry.name)
+    })
+    return scored.slice(0, limit).map((item) => this.formatEntry(item.entry))
+  }
+
+  async findMatch(name, options = {}) {
+    const normalized = this.normalize(name)
+    if (!normalized) {
+      return null
+    }
+    await this.ensureIndex({ force: options.force })
+    let best = null
+    let bestScore = Number.POSITIVE_INFINITY
+    for (const entry of this.entries.values()) {
+      const score = this.scoreEntry(normalized, entry)
+      if (score < bestScore) {
+        best = entry
+        bestScore = score
+        if (score === 0) {
+          break
+        }
+      }
+    }
+    if (!best) {
+      return null
+    }
+    return { entry: best, score: bestScore }
+  }
+
+  async info(id, options = {}) {
+    await this.ensureIndex({ force: options.force })
+    const entry = this.getEntry(id)
+    return this.formatEntry(entry)
+  }
+
+  async refresh() {
+    await this.ensureIndex({ force: true })
+    return {
+      entries: this.entries.size,
+      platform: this.platform,
+      updatedAt: this.indexTimestamp
+    }
+  }
+
+  async launch() {
+    throw new Error('launch() not implemented')
+  }
+
+  async launchUnknown(params = {}) {
+    if (!params.app) {
+      throw new Error('Application not found')
+    }
+    throw new Error(`Application "${params.app}" was not found in the app index`)
+  }
+
+  spawnDetached(command, args, options = {}) {
+    const spawnOptions = Object.assign({
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true
+    }, options || {})
+    return new Promise((resolve, reject) => {
+      let child
+      try {
+        child = spawn(command, args, spawnOptions)
+      } catch (error) {
+        error.command = command
+        error.args = args
+        return reject(error)
+      }
+      let resolved = false
+      child.once('error', (err) => {
+        if (!resolved) {
+          err.command = command
+          err.args = args
+          reject(err)
+        }
+      })
+      child.once('spawn', () => {
+        resolved = true
+        try {
+          child.unref()
+        } catch (_) {
+        }
+        resolve({ pid: child.pid, command, args })
+      })
+    })
+  }
+}
+
+module.exports = BasePlatformAdapter

package/kernel/app_launcher/platform/linux.js

@@ -0,0 +1,229 @@
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+const BaseAdapter = require('./base')
+
+const DESKTOP_DIRS = [
+  '/usr/share/applications',
+  '/usr/local/share/applications',
+  '/var/lib/snapd/desktop/applications',
+  path.join(os.homedir(), '.local/share/applications')
+]
+
+class LinuxAdapter extends BaseAdapter {
+  constructor(kernel) {
+    super(kernel)
+    this.desktopDirs = DESKTOP_DIRS
+  }
+
+  async buildIndex() {
+    this.entries.clear()
+    for (const dir of this.desktopDirs) {
+      await this.collectDesktopFiles(dir)
+    }
+  }
+
+  async collectDesktopFiles(root) {
+    if (!root) {
+      return
+    }
+    let entries
+    try {
+      entries = await fs.promises.readdir(root, { withFileTypes: true })
+    } catch (_) {
+      return
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(root, entry.name)
+      if (entry.isDirectory()) {
+        await this.collectDesktopFiles(fullPath)
+        continue
+      }
+      if (!entry.isFile() || !entry.name.endsWith('.desktop')) {
+        continue
+      }
+      await this.addDesktopEntry(fullPath)
+    }
+  }
+
+  async addDesktopEntry(filePath) {
+    let content
+    try {
+      content = await fs.promises.readFile(filePath, 'utf8')
+    } catch (_) {
+      return
+    }
+    const data = this.parseDesktopFile(content)
+    const name = this.resolveLocalizedValue(data, 'Name')
+    const execLine = data.Exec
+    if (!name || !execLine) {
+      return
+    }
+    if (String(data.NoDisplay || '').toLowerCase() === 'true') {
+      return
+    }
+    const desktopId = path.basename(filePath, '.desktop')
+    let id = `desktop:${desktopId}`
+    if (this.entries.has(id)) {
+      let suffix = 1
+      while (this.entries.has(`${id}#${suffix}`)) {
+        suffix += 1
+      }
+      id = `${id}#${suffix}`
+    }
+    const aliases = [desktopId]
+    const generic = this.resolveLocalizedValue(data, 'GenericName')
+    if (generic) {
+      aliases.push(generic)
+    }
+    this.addEntry({
+      id,
+      name,
+      aliases,
+      kind: 'linux-desktop',
+      desktopId,
+      execLine,
+      path: filePath,
+      detail: filePath,
+      terminal: String(data.Terminal || '').toLowerCase() === 'true',
+      workingDirectory: data.Path || null
+    })
+  }
+
+  parseDesktopFile(content) {
+    const data = {}
+    const lines = content.split(/\r?\n/)
+    let inEntry = false
+    for (const rawLine of lines) {
+      const line = rawLine.trim()
+      if (!line || line.startsWith('#')) {
+        continue
+      }
+      if (line.startsWith('[')) {
+        inEntry = line === '[Desktop Entry]'
+        continue
+      }
+      if (!inEntry) {
+        continue
+      }
+      const idx = line.indexOf('=')
+      if (idx === -1) {
+        continue
+      }
+      const key = line.slice(0, idx).trim()
+      const value = line.slice(idx + 1).trim()
+      if (!(key in data)) {
+        data[key] = value
+      }
+    }
+    return data
+  }
+
+  resolveLocalizedValue(data, key) {
+    if (!data) {
+      return null
+    }
+    if (data[key]) {
+      return data[key]
+    }
+    const lang = process.env.LANG ? process.env.LANG.split('.')[0] : ''
+    if (lang) {
+      if (data[`${key}[${lang}]`]) {
+        return data[`${key}[${lang}]`]
+      }
+      const short = lang.split('_')[0]
+      if (short && data[`${key}[${short}]`]) {
+        return data[`${key}[${short}]`]
+      }
+    }
+    const localizedKey = Object.keys(data).find((k) => k.startsWith(`${key}[`))
+    if (localizedKey) {
+      return data[localizedKey]
+    }
+    return null
+  }
+
+  tokenizeExec(execLine) {
+    const tokens = []
+    let current = ''
+    let quote = null
+    let escape = false
+    for (const ch of execLine) {
+      if (escape) {
+        current += ch
+        escape = false
+        continue
+      }
+      if (ch === '\\') {
+        escape = true
+        continue
+      }
+      if (ch === '"' || ch === '\'') {
+        if (quote === ch) {
+          quote = null
+        } else if (!quote) {
+          quote = ch
+        } else {
+          current += ch
+        }
+        continue
+      }
+      if (!quote && /\s/.test(ch)) {
+        if (current) {
+          tokens.push(current)
+          current = ''
+        }
+        continue
+      }
+      current += ch
+    }
+    if (current) {
+      tokens.push(current)
+    }
+    return tokens
+  }
+
+  buildExecCommand(execLine, extraArgs) {
+    const tokens = this.tokenizeExec(execLine)
+    const cleaned = []
+    for (const token of tokens) {
+      if (!token) {
+        continue
+      }
+      let replaced = token.replace(/%%/g, '%')
+      replaced = replaced.replace(/%[fFuUdDnNickvm]/g, '')
+      if (!replaced) {
+        continue
+      }
+      cleaned.push(replaced)
+    }
+    const args = Array.isArray(extraArgs) ? extraArgs : []
+    return cleaned.concat(args)
+  }
+
+  async launch(entry, params = {}) {
+    const args = this.sanitizeArgs(params.args)
+    const commandParts = this.buildExecCommand(entry.execLine, args)
+    if (!commandParts.length) {
+      throw new Error(`Unable to determine launch command for ${entry.name}`)
+    }
+    let command = commandParts[0]
+    let finalArgs = commandParts.slice(1)
+    const options = {}
+    if (entry.workingDirectory) {
+      options.cwd = entry.workingDirectory
+    }
+    const result = await this.spawnDetached(command, finalArgs, options)
+    return {
+      success: true,
+      id: entry.id,
+      name: entry.name,
+      kind: entry.kind,
+      launcher: 'exec',
+      pid: result.pid || null,
+      detail: entry.execLine
+    }
+  }
+}
+
+module.exports = LinuxAdapter