@zerwiz/ymir 0.1.34 → 0.1.35

package/apps/sessrumnir/src/main/settings-logic.ts

@@ -0,0 +1,66 @@
+/**
+ * Pure-logic settings module — no Electron imports.
+ *
+ * Used by both the Electron main process (via ipc/settings.ts) and the
+ * web server (src/web-server.ts). The Electron version registers IPC
+ * handlers; the web server calls these functions directly.
+ */
+
+import { WorkspaceManager } from '../main/workspace-manager'
+import { getGuiDataPath } from '../main/app-data-paths'
+import type { AppSettings } from '../shared/ipc-contracts'
+import { DEFAULT_SETTINGS } from '../shared/default-settings'
+import { readFile, writeFile, mkdir } from 'fs/promises'
+import { join } from 'path'
+import { existsSync } from 'fs'
+
+const SETTINGS_FILE_NAME = 'settings.json'
+
+/** Also consumed by the diagnostics report. */
+export function getSettingsPath(): string {
+  return getGuiDataPath(SETTINGS_FILE_NAME)
+}
+
+export async function loadAppSettings(workspaceManager: WorkspaceManager): Promise<AppSettings> {
+  try {
+    const settingsPath = getSettingsPath()
+    if (existsSync(settingsPath)) {
+      const data = await readFile(settingsPath, 'utf-8')
+      const merged = { ...DEFAULT_SETTINGS, ...JSON.parse(data) }
+      if (merged.piEngine !== 'auto' && merged.piEngine !== 'pi' && merged.piEngine !== 'omp') {
+        merged.piEngine = 'auto'
+      }
+      return merged
+    }
+  } catch {
+    // Fall through to defaults
+  }
+
+  return {
+    ...DEFAULT_SETTINGS,
+    defaultCwd: workspaceManager.getActiveWorkspace()?.path ?? (process.env.HOME ?? process.env.USERPROFILE ?? process.cwd()),
+  }
+}
+
+export async function saveAppSettings(settings: Partial<AppSettings>): Promise<void> {
+  const settingsPath = getSettingsPath()
+  const dir = join(settingsPath, '..')
+
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true })
+  }
+
+  // Merge with existing
+  let existing: AppSettings = { ...DEFAULT_SETTINGS }
+  try {
+    if (existsSync(settingsPath)) {
+      const data = await readFile(settingsPath, 'utf-8')
+      existing = { ...DEFAULT_SETTINGS, ...JSON.parse(data) }
+    }
+  } catch {
+    // Use defaults
+  }
+
+  const merged = { ...existing, ...settings }
+  await writeFile(settingsPath, JSON.stringify(merged, null, 2), 'utf-8')
+}

package/apps/sessrumnir/src/main/skills-discovery.test.ts

@@ -0,0 +1,149 @@
+import assert from 'node:assert/strict'
+import { mkdtemp, rm, mkdir, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import { RPC_SKILL_PATH_PREFIX, type InstalledSkill } from '../shared/ipc-contracts'
+import { listSkills, mergeRpcSkills, parseSkillFrontmatter } from './skills-discovery'
+
+const skillMd = (name: string): string => `---\nname: ${name}\ndescription: ${name} does things\n---\n\nBody.\n`
+
+async function writeSkill(root: string, dirName: string, name = dirName): Promise<void> {
+  const dir = join(root, dirName)
+  await mkdir(dir, { recursive: true })
+  await writeFile(join(dir, 'SKILL.md'), skillMd(name), 'utf-8')
+}
+
+/**
+ * A fixture tree holding skills in every per-engine root:
+ *   home/.pi/agent/skills:  alpha, group/nested (recursive), note.md (bare)
+ *   home/.omp/agent/skills: omp-global, group/omp-nested (must stay hidden)
+ *   home/.claude/skills:    claude-global
+ *   home/.agents/skills:    shared
+ *   cwd/.pi/skills:         proj-pi
+ *   cwd/.omp/skills:        proj-omp, claude-global (name collision)
+ *   cwd/.claude/skills:     proj-claude
+ */
+async function withSkillTree<T>(fn: (home: string, cwd: string) => Promise<T>): Promise<T> {
+  const base = await mkdtemp(join(tmpdir(), 'skills-discovery-'))
+  try {
+    const home = join(base, 'home')
+    const cwd = join(base, 'proj')
+
+    const piGlobal = join(home, '.pi', 'agent', 'skills')
+    await writeSkill(piGlobal, 'alpha')
+    await writeSkill(join(piGlobal, 'group'), 'nested')
+    await mkdir(piGlobal, { recursive: true })
+    await writeFile(join(piGlobal, 'note.md'), skillMd('note'), 'utf-8')
+
+    const ompGlobal = join(home, '.omp', 'agent', 'skills')
+    await writeSkill(ompGlobal, 'omp-global')
+    await writeSkill(join(ompGlobal, 'group'), 'omp-nested')
+
+    await writeSkill(join(home, '.claude', 'skills'), 'claude-global')
+    await writeSkill(join(home, '.agents', 'skills'), 'shared')
+
+    await writeSkill(join(cwd, '.pi', 'skills'), 'proj-pi')
+    await writeSkill(join(cwd, '.omp', 'skills'), 'proj-omp')
+    await writeSkill(join(cwd, '.omp', 'skills'), 'claude-global-dir', 'claude-global')
+    await writeSkill(join(cwd, '.claude', 'skills'), 'proj-claude')
+
+    return await fn(home, cwd)
+  } finally {
+    await rm(base, { recursive: true, force: true })
+  }
+}
+
+const names = (skills: InstalledSkill[]): string[] => skills.map((s) => s.name).sort()
+
+test('listSkills for Pi sees only Pi and .agents roots, recursively', async () => {
+  await withSkillTree(async (home, cwd) => {
+    const skills = await listSkills(cwd, 'pi', home)
+    assert.deepEqual(names(skills), ['alpha', 'nested', 'note', 'proj-pi', 'shared'])
+  })
+})
+
+test('listSkills for OMP sees .omp, .claude and .agents roots, one level deep', async () => {
+  await withSkillTree(async (home, cwd) => {
+    const skills = await listSkills(cwd, 'omp', home)
+    assert.deepEqual(names(skills), [
+      'claude-global',
+      'omp-global',
+      'proj-claude',
+      'proj-omp',
+      'shared',
+    ])
+    // Nested groups are not discovered by OMP.
+    assert.equal(skills.some((s) => s.name === 'omp-nested'), false)
+    // The project copy wins the claude-global name collision.
+    const collision = skills.find((s) => s.name === 'claude-global')
+    assert.equal(collision?.source, 'project')
+  })
+})
+
+test('listSkills returns [] when no roots exist', async () => {
+  const base = await mkdtemp(join(tmpdir(), 'skills-discovery-empty-'))
+  try {
+    assert.deepEqual(await listSkills(join(base, 'proj'), 'pi', join(base, 'home')), [])
+  } finally {
+    await rm(base, { recursive: true, force: true })
+  }
+})
+
+// ─── parseSkillFrontmatter ───────────────────────────────────────────────────
+
+test('parseSkillFrontmatter extracts name and description', () => {
+  assert.deepEqual(parseSkillFrontmatter(skillMd('demo')), {
+    name: 'demo',
+    description: 'demo does things',
+  })
+})
+
+test('parseSkillFrontmatter rejects files without both fields', () => {
+  assert.equal(parseSkillFrontmatter('no frontmatter'), null)
+  assert.equal(parseSkillFrontmatter('---\nname: only-name\n---\n'), null)
+})
+
+// ─── mergeRpcSkills ──────────────────────────────────────────────────────────
+
+const diskSkill: InstalledSkill = {
+  name: 'on-disk',
+  description: 'found by scan',
+  path: '/tmp/on-disk/SKILL.md',
+  source: 'global',
+  enabled: true,
+}
+
+test('mergeRpcSkills adds catalog-only skills with an rpc pseudo-path', () => {
+  const skills = [diskSkill]
+  mergeRpcSkills(skills, [
+    { name: 'skill:plugin-only', description: 'from a plugin', source: 'skill' },
+    { name: 'pi-style-name', description: 'pi catalog entry', source: 'skill', path: '/pkg/SKILL.md' },
+    { name: 'skill:on-disk', description: 'already scanned', source: 'skill' },
+    { name: 'not-a-skill', description: 'extension command', source: 'extension' },
+    'garbage',
+    null,
+  ])
+  assert.deepEqual(skills.map((s) => ({ name: s.name, path: s.path, source: s.source })), [
+    { name: 'on-disk', path: '/tmp/on-disk/SKILL.md', source: 'global' },
+    { name: 'plugin-only', path: `${RPC_SKILL_PATH_PREFIX}plugin-only`, source: 'package' },
+    { name: 'pi-style-name', path: '/pkg/SKILL.md', source: 'package' },
+  ])
+})
+
+test('mergeRpcSkills leaves the list unchanged for an empty catalog', () => {
+  const skills = [diskSkill]
+  mergeRpcSkills(skills, [])
+  assert.deepEqual(skills, [diskSkill])
+})
+
+test('parseSkillFrontmatter accepts CRLF endings and a UTF-8 BOM', () => {
+  assert.deepEqual(parseSkillFrontmatter('---\r\nname: win\r\ndescription: crlf file\r\n---\r\n\r\nBody\r\n'), {
+    name: 'win',
+    description: 'crlf file',
+  })
+  assert.deepEqual(parseSkillFrontmatter('---\nname: bom\ndescription: bom file\n---\n'), {
+    name: 'bom',
+    description: 'bom file',
+  })
+})

package/apps/sessrumnir/src/main/skills-discovery.ts

@@ -0,0 +1,179 @@
+import { readdir, readFile } from 'fs/promises'
+import { join } from 'path'
+import { existsSync } from 'fs'
+import { RPC_SKILL_PATH_PREFIX, type InstalledSkill } from '../shared/ipc-contracts'
+import { skillDisplayName } from '../shared/pi-command'
+
+/**
+ * Per-engine skill discovery for the Skills panel.
+ *
+ * Each engine only lists skills it actually loads, so a skill visible under
+ * OMP (e.g. from `~/.claude/skills`) is not offered while Pi runs, and
+ * Pi-only skills stay hidden under OMP:
+ *
+ *  - Pi reads `~/.pi/agent/skills`, `~/.agents/skills` and the project's
+ *    `.pi/skills` / `.agents/skills`, recursively, including bare root
+ *    `<name>.md` files.
+ *  - OMP reads its native `.omp` roots plus Claude Code and `.agents` roots,
+ *    one directory level deep (`<root>/<skill>/SKILL.md` only — OMP does not
+ *    discover nested skill groups or bare root markdown files).
+ */
+
+interface SkillScanPlan {
+  dirs: { dir: string; source: 'global' | 'project' }[]
+  recursive: boolean
+  rootMdFiles: boolean
+}
+
+function skillScanPlan(cwd: string, homeDir: string, engine: 'pi' | 'omp'): SkillScanPlan {
+  if (engine === 'omp') {
+    return {
+      dirs: [
+        { dir: join(cwd, '.omp', 'skills'), source: 'project' },
+        { dir: join(homeDir, '.omp', 'agent', 'skills'), source: 'global' },
+        { dir: join(cwd, '.claude', 'skills'), source: 'project' },
+        { dir: join(homeDir, '.claude', 'skills'), source: 'global' },
+        { dir: join(cwd, '.agents', 'skills'), source: 'project' },
+        { dir: join(homeDir, '.agents', 'skills'), source: 'global' },
+      ],
+      recursive: false,
+      rootMdFiles: false,
+    }
+  }
+  return {
+    dirs: [
+      { dir: join(cwd, '.pi', 'skills'), source: 'project' },
+      { dir: join(homeDir, '.pi', 'agent', 'skills'), source: 'global' },
+      { dir: join(cwd, '.agents', 'skills'), source: 'project' },
+      { dir: join(homeDir, '.agents', 'skills'), source: 'global' },
+    ],
+    recursive: true,
+    rootMdFiles: true,
+  }
+}
+
+export async function listSkills(
+  cwd: string,
+  engine: 'pi' | 'omp',
+  homeDir: string = process.env.HOME ?? process.env.USERPROFILE ?? ''
+): Promise<InstalledSkill[]> {
+  const { dirs, recursive, rootMdFiles } = skillScanPlan(cwd, homeDir, engine)
+
+  const skills: InstalledSkill[] = []
+  for (const { dir, source } of dirs) {
+    await collectSkills(dir, skills, source, { recursive, rootMdFiles })
+  }
+
+  // Both engines resolve name collisions across roots first-wins, in the same
+  // precedence order the scan above uses.
+  const seen = new Set<string>()
+  return skills.filter((skill) => {
+    if (seen.has(skill.name)) return false
+    seen.add(skill.name)
+    return true
+  })
+}
+
+interface CollectOptions {
+  recursive: boolean
+  rootMdFiles: boolean
+}
+
+async function collectSkills(
+  dir: string,
+  skills: InstalledSkill[],
+  source: 'global' | 'project',
+  options: CollectOptions
+): Promise<void> {
+  try {
+    if (!existsSync(dir)) return
+
+    const items = await readdir(dir, { withFileTypes: true })
+
+    for (const item of items) {
+      const fullPath = join(dir, item.name)
+
+      if (item.isFile() && item.name.endsWith('.md') && item.name !== 'SKILL.md') {
+        if (!options.rootMdFiles) continue
+        // Root .md file as individual skill
+        await pushSkillFile(fullPath, skills, source)
+      } else if (item.isDirectory()) {
+        // Directory with SKILL.md
+        const skillFile = join(fullPath, 'SKILL.md')
+        if (existsSync(skillFile)) {
+          await pushSkillFile(skillFile, skills, source)
+        }
+
+        if (options.recursive) {
+          await collectSkills(fullPath, skills, source, options)
+        }
+      }
+    }
+  } catch {
+    // Directory doesn't exist or isn't readable
+  }
+}
+
+async function pushSkillFile(
+  filePath: string,
+  skills: InstalledSkill[],
+  source: 'global' | 'project'
+): Promise<void> {
+  try {
+    const content = await readFile(filePath, 'utf-8')
+    const parsed = parseSkillFrontmatter(content)
+    if (parsed) {
+      skills.push({
+        name: parsed.name,
+        description: parsed.description,
+        path: filePath,
+        source,
+        enabled: true,
+      })
+    }
+  } catch {
+    // Skip unreadable files
+  }
+}
+
+export function parseSkillFrontmatter(content: string): { name: string; description: string } | null {
+  // Windows-authored files carry CRLF endings and sometimes a UTF-8 BOM; both
+  // engines still load them, so the panel must too.
+  const frontmatterMatch = content.match(/^\uFEFF?---\r?\n([\s\S]*?)\r?\n---/)
+  if (!frontmatterMatch) return null
+
+  const frontmatter = frontmatterMatch[1]
+  const nameMatch = frontmatter.match(/^name:\s*(.+)$/m)
+  const descMatch = frontmatter.match(/^description:\s*(.+)$/m)
+
+  if (!nameMatch || !descMatch) return null
+
+  return {
+    name: nameMatch[1].trim(),
+    description: descMatch[1].trim(),
+  }
+}
+
+/**
+ * Merge catalog skills the disk scan missed (plugin and marketplace skills).
+ * Entries carrying a real SKILL.md path stay readable; the rest get an
+ * `rpc:`-prefixed pseudo-path the panel renders from the description.
+ */
+export function mergeRpcSkills(skills: InstalledSkill[], commands: unknown[]): void {
+  const seen = new Set(skills.map((skill) => skill.name))
+  for (const entry of commands) {
+    if (typeof entry !== 'object' || entry === null) continue
+    const cmd = entry as { name?: unknown; description?: unknown; source?: unknown; path?: unknown }
+    if (cmd.source !== 'skill' || typeof cmd.name !== 'string') continue
+    const name = skillDisplayName(cmd.name)
+    if (!name || seen.has(name)) continue
+    seen.add(name)
+    skills.push({
+      name,
+      description: typeof cmd.description === 'string' ? cmd.description : '',
+      path: typeof cmd.path === 'string' && cmd.path.length > 0 ? cmd.path : `${RPC_SKILL_PATH_PREFIX}${name}`,
+      source: 'package',
+      enabled: true,
+    })
+  }
+}

package/apps/sessrumnir/src/main/startup-launch.ts

@@ -0,0 +1,63 @@
+import { app } from 'electron'
+import { mkdir, writeFile, unlink } from 'fs/promises'
+import { join } from 'path'
+import {
+  buildLinuxDesktopEntry,
+  linuxAutostartPath,
+  linuxLaunchExec,
+} from './autostart-linux'
+
+// Cross-platform "Run on startup": launch Sessrúmnir automatically at login.
+//   - macOS / Windows: Electron's native login-item support.
+//   - Linux: a per-user freedesktop autostart entry (Electron has no Linux
+//     support for setLoginItemSettings).
+//
+// Only effective in packaged builds. In development the executable is the
+// Electron binary inside node_modules; registering that as a login item is
+// meaningless and points at a path the user's real install won't have.
+
+/** Absolute path to the app icon, mirroring index.ts's getAppIconPath logic. */
+function appIconPath(): string {
+  const base = app.isPackaged
+    ? join(process.resourcesPath, 'resources')
+    : join(app.getAppPath(), 'resources')
+  return join(base, 'icons', 'icon.png')
+}
+
+async function writeLinuxAutostart(): Promise<void> {
+  const target = linuxAutostartPath()
+  await mkdir(join(target, '..'), { recursive: true })
+  const content = buildLinuxDesktopEntry({ exec: linuxLaunchExec(), icon: appIconPath() })
+  await writeFile(target, content, 'utf-8')
+}
+
+async function removeLinuxAutostart(): Promise<void> {
+  try {
+    await unlink(linuxAutostartPath())
+  } catch (err) {
+    // Already absent → nothing to do. Surface anything else.
+    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err
+  }
+}
+
+/**
+ * Apply the "run on startup" preference to the operating system. Idempotent:
+ * safe to call on every change and on startup to reconcile drift (e.g. a stale
+ * Linux Exec path after the AppImage is moved or updated).
+ */
+export async function applyRunOnStartup(enabled: boolean): Promise<void> {
+  if (!app.isPackaged) return
+
+  if (process.platform === 'linux') {
+    if (enabled) {
+      await writeLinuxAutostart()
+    } else {
+      await removeLinuxAutostart()
+    }
+    return
+  }
+
+  // macOS and Windows: defaults for path (process.execPath) and args ([]) are
+  // correct for our dmg/NSIS builds.
+  app.setLoginItemSettings({ openAtLogin: enabled })
+}

package/apps/sessrumnir/src/main/terminal-service.ts

@@ -0,0 +1,96 @@
+import { existsSync } from 'fs'
+import os from 'os'
+import pty, { type IPty } from 'node-pty'
+import type { TerminalStartOptions, TerminalStartResult } from '../shared/ipc-contracts'
+
+type TerminalDataHandler = (data: string) => void
+type TerminalExitHandler = (event: { exitCode: number; signal?: number }) => void
+
+export class TerminalService {
+  private terminal: IPty | null = null
+  private disposables: { dispose(): void }[] = []
+  private cwd = os.homedir()
+
+  start(
+    options: TerminalStartOptions,
+    onData: TerminalDataHandler,
+    onExit: TerminalExitHandler
+  ): TerminalStartResult {
+    this.stop()
+
+    const shell = getShell()
+    const cwd = getCwd(options.cwd)
+    const env = {
+      ...process.env,
+      TERM: 'xterm-256color',
+    } as Record<string, string>
+
+    this.cwd = cwd
+    // node-pty's `encoding` option calls setEncoding() under the hood,
+    // which Windows (conpty/winpty) does not support and logs a warning
+    // for. Only pass it on POSIX platforms.
+    const terminal = pty.spawn(shell, [], {
+      name: 'xterm-256color',
+      cols: options.cols ?? 80,
+      rows: options.rows ?? 24,
+      cwd,
+      env,
+      ...(process.platform === 'win32' ? {} : { encoding: 'utf8' }),
+    })
+    this.terminal = terminal
+
+    this.disposables.push(terminal.onData(onData))
+    this.disposables.push(
+      terminal.onExit(({ exitCode, signal }) => {
+        // Guard against a stale exit from a killed pty clobbering a terminal
+        // that has since been recreated (e.g. after a view round-trip).
+        if (this.terminal === terminal) this.terminal = null
+        onExit({ exitCode, signal })
+      })
+    )
+
+    return {
+      pid: terminal.pid,
+      shell,
+      cwd,
+    }
+  }
+
+  write(data: string): void {
+    this.terminal?.write(data)
+  }
+
+  resize(cols: number, rows: number): void {
+    if (cols > 0 && rows > 0) {
+      this.terminal?.resize(cols, rows)
+    }
+  }
+
+  stop(): void {
+    if (!this.terminal) return
+    // Detach handlers before killing so the resulting exit event neither
+    // broadcasts a spurious "process exited" into a freshly-created terminal
+    // nor nulls it out. See the identity guard in start().
+    for (const d of this.disposables) d.dispose()
+    this.disposables = []
+    const terminal = this.terminal
+    this.terminal = null
+    terminal.kill()
+  }
+
+  getCwd(): string {
+    return this.cwd
+  }
+}
+
+function getShell(): string {
+  if (process.platform === 'win32') {
+    return process.env.COMSPEC ?? 'powershell.exe'
+  }
+  return process.env.SHELL ?? '/bin/bash'
+}
+
+function getCwd(cwd?: string): string {
+  if (cwd && existsSync(cwd)) return cwd
+  return os.homedir()
+}