@zerwiz/ymir 0.1.34 → 0.1.35

package/apps/sessrumnir/src/main/archived-sessions.ts

@@ -0,0 +1,95 @@
+import { readFile, writeFile, mkdir } from 'fs/promises'
+import { join } from 'path'
+import { existsSync } from 'fs'
+import { getGuiDataPath } from './app-data-paths'
+
+/**
+ * Archived-session registry.
+ *
+ * Pi itself has no archive concept (see MEMORY.md → "Pi does not expose
+ * session deletion via RPC. Pi does not have session archiving at all").
+ * Archive is therefore a GUI-only annotation stored alongside session-tags.
+ *
+ * Shape on disk: { "<sessionId>": <archivedAtEpochMs> }
+ * Path: archived-sessions.json in the Electron userData directory.
+ *
+ * The session ID is the file basename without `.jsonl` — matches the keys
+ * used by SessionTagManager.
+ */
+
+const ARCHIVED_FILE_NAME = 'archived-sessions.json'
+
+type ArchiveStore = Record<string, number>
+
+export class ArchivedSessionsManager {
+  private path: string
+  private cache: ArchiveStore = {}
+  private loaded = false
+
+  constructor() {
+    this.path = getGuiDataPath(ARCHIVED_FILE_NAME)
+  }
+
+  async isArchived(sessionId: string): Promise<boolean> {
+    await this.ensureLoaded()
+    return sessionId in this.cache
+  }
+
+  async getAll(): Promise<ArchiveStore> {
+    await this.ensureLoaded()
+    return { ...this.cache }
+  }
+
+  async archive(sessionId: string): Promise<void> {
+    await this.ensureLoaded()
+    if (sessionId in this.cache) return
+    this.cache[sessionId] = Date.now()
+    await this.save()
+  }
+
+  async unarchive(sessionId: string): Promise<void> {
+    await this.ensureLoaded()
+    if (!(sessionId in this.cache)) return
+    delete this.cache[sessionId]
+    await this.save()
+  }
+
+  /**
+   * Drop the entry for a session that no longer exists (called after delete
+   * so the registry doesn't accumulate stale IDs).
+   */
+  async forget(sessionId: string): Promise<void> {
+    await this.ensureLoaded()
+    if (!(sessionId in this.cache)) return
+    delete this.cache[sessionId]
+    await this.save()
+  }
+
+  private async ensureLoaded(): Promise<void> {
+    if (this.loaded) return
+    try {
+      if (existsSync(this.path)) {
+        const data = await readFile(this.path, 'utf-8')
+        const parsed = JSON.parse(data) as unknown
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+          this.cache = parsed as ArchiveStore
+        }
+      }
+    } catch {
+      this.cache = {}
+    }
+    this.loaded = true
+  }
+
+  private async save(): Promise<void> {
+    try {
+      const dir = join(this.path, '..')
+      if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true })
+      }
+      await writeFile(this.path, JSON.stringify(this.cache, null, 2), 'utf-8')
+    } catch (err) {
+      console.error('Failed to save archived sessions:', err)
+    }
+  }
+}

package/apps/sessrumnir/src/main/attachment-reader.test.ts

@@ -0,0 +1,56 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { mkdtemp, writeFile } from 'fs/promises'
+import { join } from 'path'
+import { tmpdir } from 'os'
+import { imageMimeTypeForPath, readAttachment } from './attachment-reader'
+
+// ─── Extension -> MIME mapping ──────────────────────────────────────────────
+
+test('imageMimeTypeForPath maps supported image extensions case-insensitively', () => {
+  assert.equal(imageMimeTypeForPath('/a/b/shot.png'), 'image/png')
+  assert.equal(imageMimeTypeForPath('/a/b/shot.JPG'), 'image/jpeg')
+  assert.equal(imageMimeTypeForPath('photo.jpeg'), 'image/jpeg')
+  assert.equal(imageMimeTypeForPath('anim.GIF'), 'image/gif')
+  assert.equal(imageMimeTypeForPath('pic.webp'), 'image/webp')
+})
+
+test('imageMimeTypeForPath returns null for non-image and extensionless paths', () => {
+  assert.equal(imageMimeTypeForPath('notes.txt'), null)
+  assert.equal(imageMimeTypeForPath('archive.tar.gz'), null)
+  assert.equal(imageMimeTypeForPath('Makefile'), null)
+  assert.equal(imageMimeTypeForPath('image.svg'), null) // not in Pi's supported set
+})
+
+// ─── readAttachment ─────────────────────────────────────────────────────────
+
+test('readAttachment returns base64 image payload for an image file', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'pi-attach-img-'))
+  const file = join(dir, 'pixel.png')
+  const bytes = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])
+  await writeFile(file, bytes)
+
+  const result = await readAttachment(file)
+  assert.equal(result.kind, 'image')
+  if (result.kind !== 'image') return
+  assert.equal(result.name, 'pixel.png')
+  assert.equal(result.image.type, 'image')
+  assert.equal(result.image.mimeType, 'image/png')
+  assert.equal(result.image.data, bytes.toString('base64'))
+})
+
+test('readAttachment returns UTF-8 text for a non-image file', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'pi-attach-txt-'))
+  const file = join(dir, 'notes.md')
+  await writeFile(file, '# Hello\nworld')
+
+  const result = await readAttachment(file)
+  assert.equal(result.kind, 'text')
+  if (result.kind !== 'text') return
+  assert.equal(result.name, 'notes.md')
+  assert.equal(result.content, '# Hello\nworld')
+})
+
+test('readAttachment rejects a missing path', async () => {
+  await assert.rejects(() => readAttachment('/no/such/file-xyz.png'))
+})

package/apps/sessrumnir/src/main/attachment-reader.ts

@@ -0,0 +1,52 @@
+import { readFile, stat } from 'fs/promises'
+import { basename, extname } from 'path'
+import type { AttachmentReadResult } from '../shared/ipc-contracts'
+import { t } from '../shared/i18n'
+
+// Lowercase file extension -> MIME type for images we decode to base64 (for the
+// preview pane's image viewer, and as Pi inline-image blocks). Note: the chat
+// attachment picker is separately limited to SUPPORTED_IMAGE_EXTENSIONS, so the
+// extra preview-only formats here (avif/bmp/ico) are never sent to Pi.
+const IMAGE_MIME_BY_EXTENSION: Record<string, string> = {
+  png: 'image/png',
+  jpg: 'image/jpeg',
+  jpeg: 'image/jpeg',
+  gif: 'image/gif',
+  webp: 'image/webp',
+  avif: 'image/avif',
+  bmp: 'image/bmp',
+  ico: 'image/x-icon',
+}
+
+// Guard against accidentally base64-inlining a huge file into a prompt.
+const MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024
+
+/** MIME type for a path's extension if it is a supported image, else null. */
+export function imageMimeTypeForPath(filePath: string): string | null {
+  const ext = extname(filePath).slice(1).toLowerCase()
+  return IMAGE_MIME_BY_EXTENSION[ext] ?? null
+}
+
+/**
+ * Reads a user-selected attachment by absolute path (chosen via the native
+ * open dialog, so it may live outside the workspace). Images become a
+ * Pi-ready base64 payload; everything else is read as UTF-8 text to inline.
+ */
+export async function readAttachment(filePath: string): Promise<AttachmentReadResult> {
+  const fileStat = await stat(filePath)
+  if (fileStat.size > MAX_ATTACHMENT_BYTES) {
+    throw new Error(t('errors.attachments.tooLarge', { limit: MAX_ATTACHMENT_BYTES / (1024 * 1024) }))
+  }
+  const name = basename(filePath)
+  const mimeType = imageMimeTypeForPath(filePath)
+  if (mimeType) {
+    const bytes = await readFile(filePath)
+    return {
+      kind: 'image',
+      name,
+      image: { type: 'image', mimeType, data: bytes.toString('base64') },
+    }
+  }
+  const content = await readFile(filePath, 'utf-8')
+  return { kind: 'text', name, content }
+}

package/apps/sessrumnir/src/main/auto-tag.test.ts

@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { mkdtemp, writeFile } from 'fs/promises'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { deriveAutoTag } from './auto-tag'
+
+async function sessionFile(userText: string): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), 'pi-autotag-'))
+  const path = join(dir, 'session.jsonl')
+  const record = {
+    type: 'message',
+    message: { role: 'user', content: [{ type: 'text', text: userText }] },
+  }
+  await writeFile(path, JSON.stringify(record) + '\n')
+  return path
+}
+
+test('intent words win frequency ties', async () => {
+  const path = await sessionFile('Please help me refactor the authentication module')
+  assert.equal(await deriveAutoTag(path), 'refactor')
+})
+
+test('stopwords and short tokens are ignored', async () => {
+  const path = await sessionFile('the and for you can use deployment pipeline')
+  assert.equal(await deriveAutoTag(path), 'deployment')
+})
+
+test('missing file yields null', async () => {
+  assert.equal(await deriveAutoTag('/no/such/session.jsonl'), null)
+})
+
+test('a session with no user text yields null', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'pi-autotag-'))
+  const path = join(dir, 'session.jsonl')
+  await writeFile(path, JSON.stringify({ type: 'message', message: { role: 'assistant', content: [] } }) + '\n')
+  assert.equal(await deriveAutoTag(path), null)
+})

package/apps/sessrumnir/src/main/auto-tag.ts

@@ -0,0 +1,75 @@
+import { stripInjectedPreamble } from '../shared/session-preview'
+import { readFirstUserMessage } from './session-metadata'
+
+/**
+ * Derive a single-word topic tag from the context of a Pi session by reading
+ * the first user message out of the session .jsonl and extracting the most
+ * salient keyword. Runs locally — no network, no LLM, deterministic.
+ */
+
+const MIN_TOKEN_LENGTH = 3
+const MAX_TAG_LENGTH = 32
+// Action-oriented words win frequency ties so tags read as intent ("refactor").
+const INTENT_WEIGHT = 2
+
+const STOPWORDS = new Set([
+  'the', 'and', 'for', 'are', 'but', 'not', 'you', 'your', 'with', 'this', 'that',
+  'have', 'has', 'had', 'from', 'they', 'them', 'then', 'than', 'will', 'would',
+  'should', 'could', 'can', 'all', 'any', 'our', 'out', 'use', 'using', 'used',
+  'into', 'over', 'some', 'such', 'only', 'also', 'how', 'what', 'when', 'where',
+  'which', 'who', 'why', 'its', 'his', 'her', 'their', 'about', 'there', 'here',
+  'just', 'like', 'make', 'made', 'need', 'needs', 'want', 'please', 'help',
+  'let', 'lets', 'get', 'got', 'see', 'now', 'one', 'two', 'new', 'set', 'way',
+  'via', 'per', 'each', 'more', 'most', 'very', 'much', 'many', 'few', 'these',
+  'those', 'been', 'being', 'was', 'were', 'does', 'did', 'doing', 'done',
+  'task', 'code', 'file', 'files', 'project', 'app', 'application', 'user',
+  'expert', 'senior', 'follow', 'following', 'current', 'currently', 'must',
+])
+
+const INTENT_WORDS = new Set([
+  'fix', 'bug', 'refactor', 'implement', 'feature', 'test', 'tests', 'debug',
+  'docs', 'documentation', 'design', 'review', 'deploy', 'build', 'setup',
+  'config', 'migrate', 'migration', 'optimize', 'performance', 'security',
+  'add', 'create', 'remove', 'delete', 'update', 'upgrade', 'rename',
+  'integrate', 'integration', 'rewrite', 'cleanup',
+])
+
+export async function deriveAutoTag(sessionFilePath: string): Promise<string | null> {
+  const text = await readFirstUserMessage(sessionFilePath)
+  if (!text) return null
+  // Strip GUI-injected boilerplate so the tag reflects the user's intent rather
+  // than the words of a planning-mode preamble.
+  return extractKeyword(stripInjectedPreamble(text))
+}
+
+function extractKeyword(text: string): string | null {
+  const cleaned = text
+    .toLowerCase()
+    // Strip fenced code blocks and inline code so prose drives the tag.
+    .replace(/```[\s\S]*?```/g, ' ')
+    .replace(/`[^`]*`/g, ' ')
+    // Strip URLs and file paths.
+    .replace(/https?:\/\/\S+/g, ' ')
+    .replace(/\S*\/\S*/g, ' ')
+    .replace(/[^a-z0-9 ]+/g, ' ')
+
+  const scores = new Map<string, number>()
+  for (const token of cleaned.split(/\s+/)) {
+    if (token.length < MIN_TOKEN_LENGTH || token.length > MAX_TAG_LENGTH) continue
+    if (/^\d+$/.test(token)) continue
+    if (STOPWORDS.has(token)) continue
+    const weight = INTENT_WORDS.has(token) ? INTENT_WEIGHT : 1
+    scores.set(token, (scores.get(token) ?? 0) + weight)
+  }
+
+  let best: string | null = null
+  let bestScore = 0
+  for (const [token, score] of scores) {
+    // Tie-break toward the longer (more specific) token.
+    if (score > bestScore || (score === bestScore && best !== null && token.length > best.length)) {
+      best = token
+      bestScore = score
+    }
+  }
+  return best
+}

package/apps/sessrumnir/src/main/autostart-linux.test.ts

@@ -0,0 +1,56 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import {
+  LINUX_AUTOSTART_FILENAME,
+  buildLinuxDesktopEntry,
+  linuxAutostartPath,
+  linuxLaunchExec,
+  quoteDesktopExec,
+} from './autostart-linux'
+
+test('linuxAutostartPath falls back to ~/.config when XDG_CONFIG_HOME is unset', () => {
+  const path = linuxAutostartPath({}, '/home/alice')
+  assert.equal(path, `/home/alice/.config/autostart/${LINUX_AUTOSTART_FILENAME}`)
+})
+
+test('linuxAutostartPath honors XDG_CONFIG_HOME', () => {
+  const path = linuxAutostartPath({ XDG_CONFIG_HOME: '/custom/cfg' }, '/home/alice')
+  assert.equal(path, `/custom/cfg/autostart/${LINUX_AUTOSTART_FILENAME}`)
+})
+
+test('linuxAutostartPath ignores a blank XDG_CONFIG_HOME', () => {
+  const path = linuxAutostartPath({ XDG_CONFIG_HOME: '   ' }, '/home/alice')
+  assert.equal(path, `/home/alice/.config/autostart/${LINUX_AUTOSTART_FILENAME}`)
+})
+
+test('linuxLaunchExec prefers APPIMAGE over execPath', () => {
+  assert.equal(
+    linuxLaunchExec({ APPIMAGE: '/opt/Pi-Desktop.AppImage' }, '/tmp/.mount_x/pi-desktop'),
+    '/opt/Pi-Desktop.AppImage',
+  )
+})
+
+test('linuxLaunchExec falls back to execPath when APPIMAGE is absent', () => {
+  assert.equal(linuxLaunchExec({}, '/usr/bin/pi-desktop'), '/usr/bin/pi-desktop')
+})
+
+test('quoteDesktopExec wraps in double quotes and escapes special chars', () => {
+  assert.equal(quoteDesktopExec('/opt/Sessrúmnir/app'), '"/opt/Sessrúmnir/app"')
+  assert.equal(quoteDesktopExec('/a\\b'), '"/a\\\\b"')
+  assert.equal(quoteDesktopExec('/a"b'), '"/a\\"b"')
+})
+
+test('buildLinuxDesktopEntry produces a valid, complete desktop entry', () => {
+  const entry = buildLinuxDesktopEntry({ exec: '/opt/Sessrúmnir.AppImage', icon: '/opt/icon.png' })
+  const lines = entry.split('\n')
+
+  assert.equal(lines[0], '[Desktop Entry]')
+  assert.ok(lines.includes('Type=Application'))
+  assert.ok(lines.includes('Name=Sessrúmnir'))
+  assert.ok(lines.includes('Exec="/opt/Sessrúmnir.AppImage"'))
+  assert.ok(lines.includes('Icon=/opt/icon.png'))
+  assert.ok(lines.includes('Terminal=false'))
+  assert.ok(lines.includes('X-GNOME-Autostart-enabled=true'))
+  // Trailing newline so the file ends cleanly.
+  assert.ok(entry.endsWith('\n'))
+})

package/apps/sessrumnir/src/main/autostart-linux.ts

@@ -0,0 +1,58 @@
+import { homedir } from 'os'
+import { join } from 'path'
+
+// Pure helpers for the Linux freedesktop autostart entry that implements
+// "Run on startup" on Linux (Electron's setLoginItemSettings is macOS/Windows
+// only). Kept free of any `electron` import so they can be unit-tested under a
+// plain Node runtime. The electron-facing orchestration lives in
+// startup-launch.ts.
+
+// Basename of the per-user autostart entry we own. Stable across releases so an
+// old entry is reused (not duplicated) after an update.
+export const LINUX_AUTOSTART_FILENAME = 'pi-desktop.desktop'
+
+const APP_DISPLAY_NAME = 'Sessrúmnir'
+const APP_COMMENT = 'Automatically start Sessrúmnir at login'
+
+/**
+ * Absolute path to the per-user autostart entry, honoring `$XDG_CONFIG_HOME`
+ * per the freedesktop spec and falling back to `~/.config`.
+ */
+export function linuxAutostartPath(env: NodeJS.ProcessEnv = process.env, home: string = homedir()): string {
+  const configHome = env.XDG_CONFIG_HOME?.trim() || join(home, '.config')
+  return join(configHome, 'autostart', LINUX_AUTOSTART_FILENAME)
+}
+
+/**
+ * The command Linux should launch at login. Prefers `$APPIMAGE`: under an
+ * AppImage, `process.execPath` points into a temporary mount that changes every
+ * run, whereas `$APPIMAGE` is the real, persistent path to the AppImage file.
+ */
+export function linuxLaunchExec(env: NodeJS.ProcessEnv = process.env, execPath: string = process.execPath): string {
+  return env.APPIMAGE?.trim() || execPath
+}
+
+/**
+ * Quote a path for a `.desktop` `Exec=` value. Wraps in double quotes and
+ * escapes backslash and double-quote, so paths containing spaces are handled
+ * per the freedesktop Desktop Entry spec.
+ */
+export function quoteDesktopExec(path: string): string {
+  const escaped = path.replace(/\\/g, '\\\\').replace(/"/g, '\\"')
+  return `"${escaped}"`
+}
+
+/** Build the full contents of the autostart `.desktop` file. */
+export function buildLinuxDesktopEntry(opts: { exec: string; icon: string }): string {
+  return [
+    '[Desktop Entry]',
+    'Type=Application',
+    `Name=${APP_DISPLAY_NAME}`,
+    `Exec=${quoteDesktopExec(opts.exec)}`,
+    `Icon=${opts.icon}`,
+    'Terminal=false',
+    'X-GNOME-Autostart-enabled=true',
+    `Comment=${APP_COMMENT}`,
+    '',
+  ].join('\n')
+}