@zerwiz/ymir 0.1.34 → 0.1.35

package/apps/sessrumnir/src/main/package-updates.test.ts

@@ -0,0 +1,149 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import {
+  explainOmpFailure,
+  fetchRegistryVersion,
+  OmpPluginListError,
+  ompNpmTargets,
+  findPackageUpdates,
+  ompRegistryQuery,
+  ompUpdateInstallSpec,
+  piRegistryQuery,
+  registryVersionUrl,
+  type OmpRegistryQuery,
+  type RegistryQuery,
+} from './package-updates'
+import type { OmpNpmPlugin } from './omp-plugin-list'
+import { t } from '../shared/i18n'
+
+const HTTP_NOT_FOUND = 404
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), { status, headers: { 'Content-Type': 'application/json' } })
+}
+
+function plugin(overrides: Partial<OmpNpmPlugin> = {}): OmpNpmPlugin {
+  return { name: 'pi-ask-user', version: '0.14.0', enabled: true, enabledFeatures: null, ...overrides }
+}
+
+test('piRegistryQuery follows latest for an unversioned npm source', () => {
+  assert.deepEqual(piRegistryQuery('npm:pi-subagents'), { name: 'pi-subagents', tag: 'latest' })
+  assert.deepEqual(piRegistryQuery('npm:@juicesharp/rpiv-todo'), { name: '@juicesharp/rpiv-todo', tag: 'latest' })
+})
+
+test('piRegistryQuery follows an explicit dist-tag', () => {
+  assert.deepEqual(piRegistryQuery('npm:pi-ollama-cloud@latest'), { name: 'pi-ollama-cloud', tag: 'latest' })
+  assert.deepEqual(piRegistryQuery('npm:@scope/name@next'), { name: '@scope/name', tag: 'next' })
+})
+
+test('piRegistryQuery skips pins, ranges, git and local sources', () => {
+  assert.equal(piRegistryQuery('npm:pi-subagents@1.2.3'), null)
+  assert.equal(piRegistryQuery('npm:@scope/name@1.2.3'), null)
+  assert.equal(piRegistryQuery('npm:pi-subagents@^1.2.0'), null)
+  assert.equal(piRegistryQuery('git:github.com/user/repo'), null)
+  assert.equal(piRegistryQuery('./local/extension'), null)
+})
+
+test('ompRegistryQuery follows latest for the ranges bun writes, keeping the entry prefix', () => {
+  assert.deepEqual(
+    ompRegistryQuery('pi-ask-user', 'npm:pi-ask-user@^0.14.0'),
+    { name: 'pi-ask-user', tag: 'latest', specPrefix: 'npm:' }
+  )
+  assert.deepEqual(ompRegistryQuery('pi-ask-user', '^0.15.0'), { name: 'pi-ask-user', tag: 'latest', specPrefix: '' })
+  assert.deepEqual(ompRegistryQuery('pi-ask-user', '~0.15.0'), { name: 'pi-ask-user', tag: 'latest', specPrefix: '' })
+  assert.deepEqual(ompRegistryQuery('pi-ask-user', '*'), { name: 'pi-ask-user', tag: 'latest', specPrefix: '' })
+})
+
+test('ompRegistryQuery keeps a dist-tag and resolves an npm alias', () => {
+  assert.deepEqual(ompRegistryQuery('x', 'npm:@scope/real@next'), { name: '@scope/real', tag: 'next', specPrefix: 'npm:' })
+  assert.deepEqual(ompRegistryQuery('pi-ask-user', 'latest'), { name: 'pi-ask-user', tag: 'latest', specPrefix: '' })
+})
+
+test('ompRegistryQuery skips pins and non-registry installs', () => {
+  assert.equal(ompRegistryQuery('pi-ask-user', 'npm:pi-ask-user@0.14.0'), null)
+  assert.equal(ompRegistryQuery('pi-ask-user', '0.14.0'), null)
+  assert.equal(ompRegistryQuery('local', 'file:../local'), null)
+  assert.equal(ompRegistryQuery('linked', 'link:../linked'), null)
+  assert.equal(ompRegistryQuery('repo', 'github:user/repo'), null)
+  assert.equal(ompRegistryQuery('repo', 'git+https://github.com/user/repo.git'), null)
+  assert.equal(ompRegistryQuery('repo', 'user/repo'), null)
+})
+
+test('registryVersionUrl encodes the scope slash and the tag', () => {
+  assert.equal(registryVersionUrl({ name: 'pi-subagents', tag: 'latest' }), 'https://registry.npmjs.org/pi-subagents/latest')
+  assert.equal(
+    registryVersionUrl({ name: '@juicesharp/rpiv-todo', tag: 'latest' }),
+    'https://registry.npmjs.org/@juicesharp%2frpiv-todo/latest'
+  )
+})
+
+test('fetchRegistryVersion reads the manifest version', async () => {
+  let requested = ''
+  const version = await fetchRegistryVersion({ name: 'pi-ask-user', tag: 'latest' }, async (url) => {
+    requested = String(url)
+    return jsonResponse({ name: 'pi-ask-user', version: '0.15.0' })
+  })
+  assert.equal(version, '0.15.0')
+  assert.equal(requested, 'https://registry.npmjs.org/pi-ask-user/latest')
+})
+
+test('fetchRegistryVersion returns null on HTTP errors, bad bodies, and network failures', async () => {
+  const query: RegistryQuery = { name: 'missing', tag: 'latest' }
+  assert.equal(await fetchRegistryVersion(query, async () => jsonResponse('not found', HTTP_NOT_FOUND)), null)
+  assert.equal(await fetchRegistryVersion(query, async () => jsonResponse({ version: 7 })), null)
+  assert.equal(await fetchRegistryVersion(query, async () => new Response('<html>')), null)
+  assert.equal(await fetchRegistryVersion(query, async () => { throw new Error('offline') }), null)
+})
+
+test('findPackageUpdates reports only candidates behind the registry', async () => {
+  const latest: Record<string, string | null> = { a: '1.1.0', b: '2.0.0', c: null }
+  const updates = await findPackageUpdates(
+    [
+      { source: 'npm:a', query: { name: 'a', tag: 'latest' }, installedVersion: '1.0.0' },
+      { source: 'npm:b', query: { name: 'b', tag: 'latest' }, installedVersion: '2.0.0' },
+      { source: 'npm:c', query: { name: 'c', tag: 'latest' }, installedVersion: '1.0.0' },
+    ],
+    async (query) => latest[query.name]
+  )
+  assert.deepEqual(updates, [{ source: 'npm:a', installedVersion: '1.0.0', latestVersion: '1.1.0' }])
+})
+
+test('ompUpdateInstallSpec carries the feature selection in bracket syntax', () => {
+  const query: OmpRegistryQuery = { name: 'pi-ask-user', tag: 'latest', specPrefix: 'npm:' }
+  assert.equal(ompUpdateInstallSpec(query, plugin()), 'npm:pi-ask-user@latest')
+  assert.equal(ompUpdateInstallSpec(query, plugin({ enabledFeatures: [] })), 'npm:pi-ask-user@latest[]')
+  assert.equal(ompUpdateInstallSpec(query, plugin({ enabledFeatures: ['a', 'b'] })), 'npm:pi-ask-user@latest[a,b]')
+})
+
+test('ompUpdateInstallSpec keeps the store entry prefix', () => {
+  assert.equal(
+    ompUpdateInstallSpec({ name: 'pi-ask-user', tag: 'latest', specPrefix: '' }, plugin()),
+    'pi-ask-user@latest'
+  )
+  assert.equal(
+    ompUpdateInstallSpec({ name: '@scope/x', tag: 'next', specPrefix: 'npm:' }, plugin({ name: '@scope/x' })),
+    'npm:@scope/x@next'
+  )
+})
+
+test('explainOmpFailure replaces the missing-bun error and keeps others', () => {
+  const missingBun = '✘ Failed to install npm:pi-ask-user@latest: Error: Executable not found in $PATH: "bun"'
+  assert.equal(explainOmpFailure(missingBun), t('errors.packages.missingBun'))
+  assert.equal(explainOmpFailure('Plugin "x" is not installed'), 'Plugin "x" is not installed')
+})
+
+const OMP_LIST_JSON = JSON.stringify({ npm: [{ name: 'pi-ask-user', version: '0.14.0', enabled: true }] })
+
+test('ompNpmTargets pairs each npm plugin with its store lookup', () => {
+  const targets = ompNpmTargets({ success: true, output: OMP_LIST_JSON }, { 'pi-ask-user': 'npm:pi-ask-user@^0.14.0' })
+  assert.equal(targets.length, 1)
+  assert.equal(targets[0].plugin.name, 'pi-ask-user')
+  assert.deepEqual(targets[0].query, { name: 'pi-ask-user', tag: 'latest', specPrefix: 'npm:' })
+})
+
+test('ompNpmTargets reports a failed plugin list instead of an empty one', () => {
+  assert.throws(
+    () => ompNpmTargets({ success: false, output: 'omp: timed out' }, {}),
+    (error: unknown) => error instanceof OmpPluginListError && error.detail === 'omp: timed out'
+  )
+})

package/apps/sessrumnir/src/main/package-updates.ts

@@ -0,0 +1,185 @@
+import type { PackageUpdate } from '../shared/ipc-contracts'
+import { isNewerVersion } from '../shared/version-compare'
+import { parseOmpNpmPlugins, type OmpNpmPlugin } from './omp-plugin-list'
+import { t } from '../shared/i18n'
+
+/**
+ * Update detection for installed packages.
+ *
+ * Neither engine's CLI reports available updates, so the GUI compares each
+ * installed npm package with the version its dist-tag resolves to on the npm
+ * registry. Only packages whose update target is knowable are checked: git and
+ * local sources have no registry version, and exact-version pins never move on
+ * update. Everything here is pure except `fetchRegistryVersion`, which takes an
+ * injectable fetch.
+ */
+
+const NPM_REGISTRY_URL = 'https://registry.npmjs.org'
+const REGISTRY_TIMEOUT_MS = 8000
+const LATEST_TAG = 'latest'
+const NPM_SOURCE_PREFIX = 'npm:'
+const ANY_VERSION_RANGE = '*'
+// A dist-tag starts with a letter (latest, next, beta); exact versions and
+// ranges start with a digit or an operator, and the registry answers neither
+// as a moving target.
+const DIST_TAG_PATTERN = /^[A-Za-z][\w.-]*$/
+// Caret and tilde ranges — what bun writes for an unpinned install.
+const FLOATING_RANGE_PATTERN = /^[\^~]\d/
+const OMP_MISSING_BUN_MARKER = 'Executable not found in $PATH: "bun"'
+
+/** A registry lookup: the package name and the dist-tag its update follows. */
+export interface RegistryQuery {
+  name: string
+  tag: string
+}
+
+/**
+ * An OMP plugin's registry lookup plus the prefix its store entry uses
+ * (`npm:` or none). The update spec must keep that prefix: bun treats the two
+ * forms as different dependencies, and mixing them can hang the install.
+ */
+export interface OmpRegistryQuery extends RegistryQuery {
+  specPrefix: string
+}
+
+/** One installed package to check against the registry. */
+export interface UpdateCandidate {
+  source: string
+  query: RegistryQuery
+  installedVersion: string
+}
+
+export type RegistryVersionLookup = (query: RegistryQuery) => Promise<string | null>
+
+/** An installed OMP npm plugin and its registry lookup (null when pinned). */
+export interface OmpNpmTarget {
+  plugin: OmpNpmPlugin
+  query: OmpRegistryQuery | null
+}
+
+/** `omp plugin list --json` did not run, so the npm plugins are unknown. */
+export class OmpPluginListError extends Error {
+  constructor(readonly detail: string) {
+    super(`omp plugin list failed: ${detail}`)
+    this.name = 'OmpPluginListError'
+  }
+}
+
+/**
+ * OMP's npm plugins with their registry lookups. The lookup comes from the
+ * plugin store's `dependencies`, which record how each plugin was installed.
+ * A failed list is an error, never an empty list: callers would otherwise
+ * treat every npm plugin as a marketplace one or report no updates.
+ */
+export function ompNpmTargets(
+  list: { success: boolean; output: string },
+  dependencies: Record<string, unknown>
+): OmpNpmTarget[] {
+  if (!list.success) throw new OmpPluginListError(list.output.trim())
+  return parseOmpNpmPlugins(list.output).map((plugin) => {
+    const dependencySpec = dependencies[plugin.name]
+    return {
+      plugin,
+      query: typeof dependencySpec === 'string' ? ompRegistryQuery(plugin.name, dependencySpec) : null,
+    }
+  })
+}
+
+/** Split `name@version` (scoped or not) into its name and version parts. */
+function splitNameAndVersion(spec: string): { name: string; version: string } {
+  // Start past index 0 so a scope's leading `@` is not read as the separator.
+  const separator = spec.indexOf('@', 1)
+  return separator === -1
+    ? { name: spec, version: '' }
+    : { name: spec.slice(0, separator), version: spec.slice(separator + 1) }
+}
+
+function distTagFor(version: string): string | null {
+  if (version === '') return LATEST_TAG
+  return DIST_TAG_PATTERN.test(version) ? version : null
+}
+
+/**
+ * The registry lookup for a Pi settings source such as `npm:name` or
+ * `npm:@scope/name@next`. Pi updates unpinned npm sources to the version their
+ * tag resolves to, so that version is the update target. Returns null for git
+ * and local sources, exact pins, and ranges.
+ */
+export function piRegistryQuery(source: string): RegistryQuery | null {
+  if (!source.startsWith(NPM_SOURCE_PREFIX)) return null
+  const { name, version } = splitNameAndVersion(source.slice(NPM_SOURCE_PREFIX.length))
+  const tag = distTagFor(version)
+  return name && tag ? { name, tag } : null
+}
+
+/**
+ * The registry lookup for an OMP npm plugin, from its entry in the plugin
+ * store's package.json (`"name": "npm:name@^1.2.0"` or `"name": "^1.2.0"`).
+ * A floating range is updated by reinstalling from `latest`; a dist-tag keeps
+ * its tag. Returns null for exact pins and for git, file and link installs,
+ * which a registry reinstall would replace with a different source.
+ */
+export function ompRegistryQuery(pluginName: string, dependencySpec: string): OmpRegistryQuery | null {
+  const specPrefix = dependencySpec.startsWith(NPM_SOURCE_PREFIX) ? NPM_SOURCE_PREFIX : ''
+  const { name, version } = specPrefix
+    ? splitNameAndVersion(dependencySpec.slice(specPrefix.length))
+    : { name: pluginName, version: dependencySpec }
+  const tag = version === ANY_VERSION_RANGE || FLOATING_RANGE_PATTERN.test(version)
+    ? LATEST_TAG
+    : distTagFor(version)
+  return name && tag ? { name, tag, specPrefix } : null
+}
+
+/** The registry URL that resolves `query.tag` to a version manifest. */
+export function registryVersionUrl(query: RegistryQuery): string {
+  // The registry expects a scoped name's slash encoded: `@scope%2fname`.
+  return `${NPM_REGISTRY_URL}/${query.name.replace('/', '%2f')}/${encodeURIComponent(query.tag)}`
+}
+
+/** The version `query.tag` resolves to, or null when the registry can't say. */
+export async function fetchRegistryVersion(
+  query: RegistryQuery,
+  fetchImpl: typeof fetch = fetch
+): Promise<string | null> {
+  try {
+    const response = await fetchImpl(registryVersionUrl(query), {
+      headers: { Accept: 'application/json' },
+      signal: AbortSignal.timeout(REGISTRY_TIMEOUT_MS),
+    })
+    if (!response.ok) return null
+    const manifest = (await response.json()) as { version?: unknown }
+    return typeof manifest.version === 'string' ? manifest.version : null
+  } catch {
+    return null
+  }
+}
+
+/** The candidates whose registry version is newer than the installed one. */
+export async function findPackageUpdates(
+  candidates: UpdateCandidate[],
+  lookup: RegistryVersionLookup = fetchRegistryVersion
+): Promise<PackageUpdate[]> {
+  const results = await Promise.all(
+    candidates.map(async (candidate): Promise<PackageUpdate | null> => {
+      const latestVersion = await lookup(candidate.query)
+      if (!latestVersion || !isNewerVersion(latestVersion, candidate.installedVersion)) return null
+      return { source: candidate.source, installedVersion: candidate.installedVersion, latestVersion }
+    })
+  )
+  return results.filter((update): update is PackageUpdate => update !== null)
+}
+
+/**
+ * The `omp install` spec that updates `plugin` in place. `omp install` resets
+ * the plugin's feature selection, so the current one is carried in OMP's
+ * bracket syntax: none for defaults, `[]` for no features, `[a,b]` otherwise.
+ */
+export function ompUpdateInstallSpec(query: OmpRegistryQuery, plugin: OmpNpmPlugin): string {
+  const features = plugin.enabledFeatures === null ? '' : `[${plugin.enabledFeatures.join(',')}]`
+  return `${query.specPrefix}${query.name}@${query.tag}${features}`
+}
+
+/** Replace OMP's missing-bun failure with an actionable message. */
+export function explainOmpFailure(output: string): string {
+  return output.includes(OMP_MISSING_BUN_MARKER) ? t('errors.packages.missingBun') : output
+}

package/apps/sessrumnir/src/main/path-authorization.test.ts

@@ -0,0 +1,64 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { join, resolve } from 'node:path'
+import { isPathWithin, isAuthorizedAttachmentPath } from './path-authorization'
+
+const ROOT = join('/home', 'alice', 'project')
+
+test('accepts a file directly inside the root', () => {
+  assert.equal(isPathWithin(ROOT, join(ROOT, 'notes.md')), true)
+})
+
+test('accepts a deeply nested file inside the root', () => {
+  assert.equal(isPathWithin(ROOT, join(ROOT, 'src', 'a', 'b.ts')), true)
+})
+
+test('accepts the root itself', () => {
+  assert.equal(isPathWithin(ROOT, ROOT), true)
+})
+
+test('rejects a path outside the root', () => {
+  assert.equal(isPathWithin(ROOT, join('/etc', 'passwd')), false)
+})
+
+test('rejects a parent-traversal escape', () => {
+  assert.equal(isPathWithin(ROOT, join(ROOT, '..', '..', 'secret.txt')), false)
+})
+
+test('rejects a sibling directory that shares the root prefix', () => {
+  // /home/alice/project-secrets must NOT count as inside /home/alice/project.
+  assert.equal(isPathWithin(ROOT, `${ROOT}-secrets/leak.txt`), false)
+})
+
+test('authorizes an attachment inside the workspace', () => {
+  const ok = isAuthorizedAttachmentPath(join(ROOT, 'img.png'), {
+    workspaceRoot: ROOT,
+    approvedPaths: new Set(),
+  })
+  assert.equal(ok, true)
+})
+
+test('authorizes a dialog-approved attachment outside the workspace', () => {
+  const picked = resolve('/tmp', 'screenshot.png')
+  const ok = isAuthorizedAttachmentPath(picked, {
+    workspaceRoot: ROOT,
+    approvedPaths: new Set([picked]),
+  })
+  assert.equal(ok, true)
+})
+
+test('rejects an arbitrary path that is neither approved nor in the workspace', () => {
+  const ok = isAuthorizedAttachmentPath(join('/etc', 'passwd'), {
+    workspaceRoot: ROOT,
+    approvedPaths: new Set([resolve('/tmp', 'screenshot.png')]),
+  })
+  assert.equal(ok, false)
+})
+
+test('rejects everything outside approvals when there is no active workspace', () => {
+  const ok = isAuthorizedAttachmentPath(join('/etc', 'passwd'), {
+    workspaceRoot: null,
+    approvedPaths: new Set(),
+  })
+  assert.equal(ok, false)
+})

package/apps/sessrumnir/src/main/path-authorization.ts

@@ -0,0 +1,31 @@
+import { isAbsolute, relative, resolve } from 'path'
+
+/**
+ * True when `candidate` resolves to `root` itself or a path nested inside it.
+ * Uses a lexical `relative` comparison (resolving `..` first) so parent-traversal
+ * escapes and sibling directories that merely share the root's string prefix
+ * (e.g. `/a/project-secrets` vs `/a/project`) are rejected. Platform path rules
+ * (case-insensitivity, separators, cross-drive on Windows) come from `path`.
+ */
+export function isPathWithin(root: string, candidate: string): boolean {
+  const resolvedRoot = resolve(root)
+  const resolvedCandidate = resolve(candidate)
+  if (resolvedCandidate === resolvedRoot) return true
+  const rel = relative(resolvedRoot, resolvedCandidate)
+  return rel.length > 0 && !rel.startsWith('..') && !isAbsolute(rel)
+}
+
+/**
+ * Authorize a path for the attachment reader. A path is allowed only if the user
+ * picked it through the native open dialog (tracked in `approvedPaths`, stored
+ * pre-resolved) or it lives inside the active workspace. This keeps a compromised
+ * renderer from reading arbitrary files (e.g. `~/.ssh/id_rsa`) via the reader.
+ */
+export function isAuthorizedAttachmentPath(
+  candidate: string,
+  opts: { workspaceRoot: string | null; approvedPaths: ReadonlySet<string> }
+): boolean {
+  const resolved = resolve(candidate)
+  if (opts.approvedPaths.has(resolved)) return true
+  return opts.workspaceRoot ? isPathWithin(opts.workspaceRoot, resolved) : false
+}