@zerwiz/ymir 0.1.33 → 0.1.35

package/apps/sessrumnir/src/main/tray-manager.ts

@@ -0,0 +1,220 @@
+import { app, Tray, Menu, Notification, nativeImage, type BrowserWindow } from 'electron'
+import { execFile } from 'child_process'
+import { trayIsSupported, parseDbusBoolean } from './tray-decision'
+import { i18n, t } from '../shared/i18n'
+
+// System-tray lifecycle for "minimize to tray on close" (Windows/Linux; macOS
+// is excluded — see tray-decision.ts). Owns the single Tray instance, the
+// one-time "still running" hint, and — critically for cross-platform
+// robustness — a check of whether a usable tray actually exists this session.
+// Deps are injected once via setupTray so this module imports neither index.ts
+// nor ipc-handlers.ts (no cycles).
+
+// D-Bus well-known name a StatusNotifierItem host claims when a system tray is
+// available (KDE, GNOME's AppIndicator extension, sni-qt, snixembed, etc.).
+const SNI_WATCHER_NAME = 'org.kde.StatusNotifierWatcher'
+const SNI_WATCHER_PATH = '/StatusNotifierWatcher'
+// Bound the D-Bus probe so a missing/slow session bus can't hang enabling.
+const DBUS_PROBE_TIMEOUT_MS = 2_000
+
+interface TrayDeps {
+  getWindow: () => BrowserWindow | null
+  quit: () => void
+  iconPath: string
+  // Whether the one-time hint has already been shown in a previous run.
+  hasSeenHint: boolean
+  // Persist that the hint has now been shown (fire-and-forget).
+  onHintShown: () => void
+}
+
+let deps: TrayDeps | null = null
+let tray: Tray | null = null
+let enabled = false
+// Whether a usable tray icon actually exists this session. Defaults false and
+// is only set true once confirmed, so the close handler never hides the window
+// to a tray that isn't really there.
+let trayAvailable = false
+let hintSeen = false
+let warnedNoTray = false
+
+export function setupTray(injected: TrayDeps): void {
+  deps = injected
+  hintSeen = injected.hasSeenHint
+  i18n.on('languageChanged', () => {
+    if (tray) applyTrayText(tray)
+  })
+}
+
+function showWindow(): void {
+  const win = deps?.getWindow()
+  if (!win) return
+  if (win.isMinimized()) win.restore()
+  win.show()
+  win.focus()
+}
+
+// Tooltip is the product name (not translated); the menu follows the language.
+function applyTrayText(target: Tray): void {
+  target.setToolTip(app.getName())
+  target.setContextMenu(
+    Menu.buildFromTemplate([
+      { label: t('tray.show'), click: () => showWindow() },
+      { type: 'separator' },
+      { label: t('app.quit'), click: () => deps?.quit() },
+    ]),
+  )
+}
+
+/** Create the tray icon. Returns whether it was created (false on failure). */
+function createTray(): boolean {
+  if (tray) return true // idempotent
+  if (!deps || !trayIsSupported(process.platform)) return false
+
+  try {
+    const image = nativeImage.createFromPath(deps.iconPath)
+    tray = new Tray(image)
+
+    // setContextMenu (inside applyTrayText) is the primary interface on Linux,
+    // where left-click activation is unreliable across desktop environments.
+    applyTrayText(tray)
+    // Windows: a left-click restores the window directly.
+    tray.on('click', () => showWindow())
+    return true
+  } catch (err) {
+    console.error('[tray] Failed to create tray icon:', err)
+    tray = null
+    return false
+  }
+}
+
+/** Run a `dbus-send --print-reply` and resolve its stdout, or null on error. */
+function dbusSend(args: string[]): Promise<string | null> {
+  return new Promise((resolve) => {
+    execFile('dbus-send', args, { timeout: DBUS_PROBE_TIMEOUT_MS }, (err, stdout) => {
+      resolve(err ? null : stdout)
+    })
+  })
+}
+
+/**
+ * Probe the session bus for a StatusNotifierItem host. Resolves false when no
+ * host is present (GNOME without the AppIndicator extension, a minimal WM), when
+ * there is no session bus, or when `dbus-send` is unavailable — all cases where
+ * an Electron tray icon would silently not appear.
+ *
+ * Two-step check: the watcher name must be owned, AND — when the watcher exposes
+ * it — `IsStatusNotifierHostRegistered` must not be false. That property is the
+ * definitive "a host is actually attached to render icons" signal, catching the
+ * rare case where the watcher name is owned but no host registered. If the
+ * property can't be read (null), we trust the owned name rather than risk a
+ * false negative that needlessly disables a working tray.
+ */
+async function detectLinuxTrayHost(): Promise<boolean> {
+  const ownerReply = await dbusSend([
+    '--session',
+    '--print-reply',
+    '--dest=org.freedesktop.DBus',
+    '/org/freedesktop/DBus',
+    'org.freedesktop.DBus.NameHasOwner',
+    `string:${SNI_WATCHER_NAME}`,
+  ])
+  if (parseDbusBoolean(ownerReply ?? '') !== true) return false
+
+  const hostReply = await dbusSend([
+    '--session',
+    '--print-reply',
+    `--dest=${SNI_WATCHER_NAME}`,
+    SNI_WATCHER_PATH,
+    'org.freedesktop.DBus.Properties.Get',
+    `string:${SNI_WATCHER_NAME}`,
+    'string:IsStatusNotifierHostRegistered',
+  ])
+  // Only a definitive `false` disqualifies; true or unknown (null) → available.
+  return parseDbusBoolean(hostReply ?? '') !== false
+}
+
+/** Warn once (best-effort) when the feature is on but no tray is available. */
+function warnNoTrayOnce(): void {
+  if (warnedNoTray) return
+  warnedNoTray = true
+  console.warn(
+    '[tray] No system-tray host detected; "Minimize to tray on close" will fall back to closing normally.',
+  )
+  if (Notification.isSupported()) {
+    new Notification({
+      title: t('tray.unavailableTitle'),
+      body: t('tray.unavailableBody'),
+      ...(deps?.iconPath ? { icon: deps.iconPath } : {}),
+    }).show()
+  }
+}
+
+/** Fully release the tray icon (on quit, or when the feature is turned off). */
+export function destroyTray(): void {
+  if (tray) {
+    tray.destroy()
+    tray = null
+  }
+}
+
+/**
+ * Turn the feature on/off. Creates/destroys the icon, determines whether the
+ * tray is actually usable, and records the flags read by the window `close`
+ * handler. Turning it off while the window is hidden re-shows the window so the
+ * user is never stranded with no window and no icon.
+ */
+export function setTrayEnabled(next: boolean): void {
+  enabled = next
+  if (!next) {
+    const hadTray = tray !== null
+    destroyTray()
+    trayAvailable = false
+    if (hadTray) showWindow()
+    return
+  }
+
+  const created = createTray()
+  if (!created) {
+    trayAvailable = false
+    warnNoTrayOnce()
+    return
+  }
+
+  if (process.platform !== 'linux') {
+    // Windows: the notification area is always present.
+    trayAvailable = true
+    return
+  }
+
+  // Linux: the icon only truly appears if a StatusNotifierItem host exists.
+  // Stay false until confirmed so a close during the probe won't strand us.
+  trayAvailable = false
+  void detectLinuxTrayHost().then((ok) => {
+    trayAvailable = ok
+    if (!ok) warnNoTrayOnce()
+  })
+}
+
+/** Current setting value, for the close-decision helper. */
+export function isTrayEnabled(): boolean {
+  return enabled
+}
+
+/** Whether a usable tray icon actually exists this session. */
+export function isTrayAvailable(): boolean {
+  return trayAvailable
+}
+
+/** Show the one-time "still running in the tray" hint, at most once ever. */
+export function notifyFirstHide(): void {
+  if (hintSeen) return
+  hintSeen = true
+  deps?.onHintShown()
+  if (Notification.isSupported()) {
+    new Notification({
+      title: t('tray.stillRunningTitle'),
+      body: t('tray.stillRunningBody'),
+      ...(deps?.iconPath ? { icon: deps.iconPath } : {}),
+    }).show()
+  }
+}

package/apps/sessrumnir/src/main/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out/main",
+    "rootDir": "../..",
+    "lib": ["ES2022"],
+    "types": ["node"],
+    "composite": true,
+    "declaration": true
+  },
+  "include": [
+    "./**/*.ts",
+    "../shared/**/*.ts",
+    "../../resources/permission-rules.ts",
+    "../../resources/permission-rules.test.ts",
+    "../../resources/permission-prompt-text.ts",
+    "../../resources/permission-prompt-text.test.ts",
+    "../../resources/locales/*/translation.json"
+  ]
+}

package/apps/sessrumnir/src/main/window-background.test.ts

@@ -0,0 +1,29 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { toWindowBackgroundColor } from './window-background'
+
+test('accepts a computed rgb() color', () => {
+  assert.equal(toWindowBackgroundColor('rgb(40, 40, 40)'), 'rgb(40, 40, 40)')
+})
+
+test('accepts a computed rgba() color', () => {
+  assert.equal(toWindowBackgroundColor('rgba(0, 0, 0, 0)'), 'rgba(0, 0, 0, 0)')
+  assert.equal(toWindowBackgroundColor('rgba(250, 244, 237, 0.5)'), 'rgba(250, 244, 237, 0.5)')
+})
+
+test('rejects hex, because Electron reads 8-digit hex as ARGB, not CSS RGBA', () => {
+  assert.equal(toWindowBackgroundColor('#28282880'), null)
+  assert.equal(toWindowBackgroundColor('#282828'), null)
+})
+
+test('rejects channels outside 0-255 and alpha outside 0-1', () => {
+  assert.equal(toWindowBackgroundColor('rgb(300, 0, 0)'), null)
+  assert.equal(toWindowBackgroundColor('rgba(0, 0, 0, 1.5)'), null)
+})
+
+test('rejects anything that is not a color string', () => {
+  assert.equal(toWindowBackgroundColor(undefined), null)
+  assert.equal(toWindowBackgroundColor(42), null)
+  assert.equal(toWindowBackgroundColor('url(https://example.com/x.png)'), null)
+  assert.equal(toWindowBackgroundColor('rgb(1, 2, 3); color: red'), null)
+})

package/apps/sessrumnir/src/main/window-background.ts

@@ -0,0 +1,16 @@
+// The renderer sends its computed body background (always `rgb()`/`rgba()`
+// from getComputedStyle) so the native window background matches the theme
+// in areas the page has not painted yet, such as live-resize edges on Windows
+// and macOS. Only that form is accepted: Electron reads 8-digit hex as ARGB,
+// not CSS RGBA, so hex would flip alpha and red.
+const RGB_COLOR = /^rgba?\((\d{1,3}), (\d{1,3}), (\d{1,3})(?:, (0|1|0?\.\d+))?\)$/
+const MAX_CHANNEL = 255
+
+export function toWindowBackgroundColor(value: unknown): string | null {
+  if (typeof value !== 'string') return null
+  const match = RGB_COLOR.exec(value)
+  if (!match) return null
+  const channels = match.slice(1, 4).map(Number)
+  if (channels.some((channel) => channel > MAX_CHANNEL)) return null
+  return value
+}

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

@@ -0,0 +1,252 @@
+import assert from 'node:assert/strict'
+import { createHash } from 'node:crypto'
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { basename, join, resolve } from 'node:path'
+import { test } from 'node:test'
+import {
+  clearWorkflowProjectDiscoveryCache,
+  discoverWorkflowProjects,
+  getWorkflowRun,
+  listWorkflowRuns,
+  resolveWorkflowWorkspaces,
+} from './workflow-monitor'
+import { desanitizeSessionDir, sanitizePath } from './session-paths'
+import { pathGroupKey, pathsEqual } from '../shared/path-compare'
+import type { Workspace } from '../shared/ipc-contracts'
+
+function projectKey(cwd: string): string {
+  const projectPath = resolve(cwd)
+  const name = (basename(projectPath) || 'project')
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 48) || 'project'
+  return `${name}-${createHash('sha256').update(projectPath).digest('hex').slice(0, 12)}`
+}
+
+const SESSION_UUID = '01a01a28-f010-7b29-8312-21ba523d9edf'
+const RUN_ID = 'run-hyphenated-abc123'
+
+interface Fixture {
+  realCwd: string
+  phantomPath: string
+  projectDir: string
+  runsDir: string
+  sessionDir: string
+  cleanup: () => Promise<void>
+}
+
+/**
+ * Create a real project with a HYPHEN in its folder name (the lossy-decode
+ * case: `pi-desktop-abc123` desanitizes to `pi\desktop\abc123`), a persisted
+ * workflow run keyed under the REAL path, and a session JSONL whose header
+ * carries the authoritative real cwd.
+ */
+async function makeFixture(): Promise<Fixture> {
+  const realCwd = await mkdtemp(join(homedir(), 'pi-discovery-'))
+  const phantomPath = desanitizeSessionDir(sanitizePath(realCwd))
+  const key = projectKey(realCwd)
+  const projectDir = join(homedir(), '.pi', 'workflows', 'projects', key)
+  const runsDir = join(projectDir, 'runs')
+  const agentDir = process.env.PI_CODING_AGENT_DIR || join(homedir(), '.pi', 'agent')
+  const sessionDir = join(agentDir, 'sessions', sanitizePath(realCwd))
+
+  await mkdir(runsDir, { recursive: true })
+  await writeFile(join(runsDir, `${RUN_ID}.json`), JSON.stringify({
+    runId: RUN_ID,
+    workflowName: 'audit',
+    sessionId: SESSION_UUID,
+    status: 'completed',
+    phases: ['scan'],
+    startedAt: '2026-01-01T00:00:00.000Z',
+    updatedAt: '2026-01-01T00:00:01.000Z',
+    agents: [{ id: 0, label: 'scan files', status: 'done', history: [{ role: 'assistant', kind: 'text', text: 'captured' }] }],
+  }))
+
+  await mkdir(sessionDir, { recursive: true })
+  await writeFile(join(sessionDir, `2026-01-01T00-00-00-000Z_${SESSION_UUID}.jsonl`), [
+    { type: 'session', id: SESSION_UUID, cwd: realCwd },
+    { type: 'session_info', name: `workflow:${RUN_ID} scan files` },
+    { type: 'message', timestamp: '2026-01-01T00:00:02.000Z', message: { role: 'user', content: [{ type: 'text', text: 'inspect the repo' }] } },
+    { type: 'message', timestamp: '2026-01-01T00:00:03.000Z', message: { role: 'assistant', content: [{ type: 'text', text: 'done' }] } },
+  ].map((line) => JSON.stringify(line)).join('\n'))
+
+  return {
+    realCwd,
+    phantomPath,
+    projectDir,
+    runsDir,
+    sessionDir,
+    cleanup: async () => {
+      await rm(projectDir, { recursive: true, force: true })
+      await rm(sessionDir, { recursive: true, force: true })
+      await rm(realCwd, { recursive: true, force: true })
+    },
+  }
+}
+
+const phantomWorkspace = (path: string): Workspace => ({
+  id: 'ws-phantom',
+  name: 'desktop',
+  path,
+  createdAt: 0,
+  lastActiveAt: 0,
+  color: '#fff',
+})
+
+test('discovery resolves a hyphenated project from the session header cwd', async () => {
+  const fixture = await makeFixture()
+  try {
+    clearWorkflowProjectDiscoveryCache()
+    const discovery = await discoverWorkflowProjects()
+    const key = projectKey(fixture.realCwd)
+    // The project key is the real cwd's key, never the phantom's.
+    assert.equal(discovery.projects.get(key), resolve(fixture.realCwd))
+    assert.ok(fixture.phantomPath !== fixture.realCwd)
+    // The session-dir map anchors the phantom (lossy) dir name to the real cwd.
+    // Keyed case-folded like every other path key on Windows.
+    assert.equal(
+      discovery.sessionDirCwds.get(pathGroupKey(sanitizePath(fixture.realCwd))),
+      resolve(fixture.realCwd)
+    )
+  } finally {
+    await fixture.cleanup()
+    clearWorkflowProjectDiscoveryCache()
+  }
+})
+
+test('a registered workspace holding the phantom path is healed in memory (id preserved)', async () => {
+  const fixture = await makeFixture()
+  try {
+    clearWorkflowProjectDiscoveryCache()
+    // The workspace is registered at the LOSSY path — exactly the live bug
+    // (workspaces.json had E:\Projects\AI\pi\desktop).
+    const registered = [phantomWorkspace(fixture.phantomPath)]
+    const resolved = await resolveWorkflowWorkspaces(registered)
+
+    const healed = resolved.find((ws) => ws.id === 'ws-phantom')
+    assert.ok(healed, 'registered workspace id is preserved')
+    assert.ok(pathsEqual(healed.path, fixture.realCwd), `healed to real cwd, got ${healed.path}`)
+    assert.equal(healed.name, basename(fixture.realCwd))
+
+    // The same projection serves list, detail and control routing. Filter to
+    // the fixture's workspace — the resolution also includes every other
+    // project discovered in the real store.
+    const runs = (await listWorkflowRuns(resolved)).filter((run) => run.workspaceId === 'ws-phantom')
+    assert.equal(runs.length, 1)
+    assert.equal(runs[0].workspaceId, 'ws-phantom')
+    assert.equal(runs[0].cwd, resolve(fixture.realCwd))
+
+    const detail = await getWorkflowRun(healed, RUN_ID)
+    assert.equal(detail?.workflowName, 'audit')
+    // Transcript attaches through the healed cwd (persisted-session, not the
+    // degraded run-history fallback).
+    assert.equal(detail?.agents[0].transcriptSource, 'persisted-session')
+    assert.equal(detail?.agents[0].transcriptComplete, true)
+  } finally {
+    await fixture.cleanup()
+    clearWorkflowProjectDiscoveryCache()
+  }
+})
+
+test('an unregistered project gets a read-only workflow-<key> projection with the real cwd', async () => {
+  const fixture = await makeFixture()
+  try {
+    clearWorkflowProjectDiscoveryCache()
+    const key = projectKey(fixture.realCwd)
+    const resolved = await resolveWorkflowWorkspaces([])
+
+    const projection = resolved.find((ws) => ws.id === `workflow-${key}`)
+    assert.ok(projection, 'workflow-<key> projection exists')
+    assert.ok(pathsEqual(projection.path, fixture.realCwd))
+    assert.equal(projection.name, basename(fixture.realCwd))
+
+    const runs = await listWorkflowRuns([projection])
+    assert.equal(runs.length, 1)
+    assert.equal(runs[0].workspaceId, `workflow-${key}`)
+    const detail = await getWorkflowRun(projection, RUN_ID)
+    assert.equal(detail?.agents[0].transcriptSource, 'persisted-session')
+  } finally {
+    await fixture.cleanup()
+    clearWorkflowProjectDiscoveryCache()
+  }
+})
+
+test('an unresolved project is still listable/detail-openable via its display path', async () => {
+  const fixture = await makeFixture()
+  // Remove the session trace: only the run JSONs remain, so the cwd cannot be
+  // recovered — the projection must fall back to a display-only path while the
+  // run stays readable (run-history transcript).
+  await rm(fixture.sessionDir, { recursive: true, force: true })
+  try {
+    clearWorkflowProjectDiscoveryCache()
+    const key = projectKey(fixture.realCwd)
+    const resolved = await resolveWorkflowWorkspaces([])
+
+    const projection = resolved.find((ws) => ws.id === `workflow-${key}`)
+    assert.ok(projection, 'unresolved project still gets a projection')
+    // Display-only path under the projects dir; the id still pins the key.
+    assert.equal(projection.path, join(homedir(), '.pi', 'workflows', 'projects', key))
+
+    const runs = await listWorkflowRuns([projection])
+    assert.equal(runs.length, 1)
+    assert.equal(runs[0].cwd, projection.path)
+    const detail = await getWorkflowRun(projection, RUN_ID)
+    assert.equal(detail?.workflowName, 'audit')
+    assert.equal(detail?.agents[0].transcriptSource, 'run-history')
+  } finally {
+    await fixture.cleanup()
+    clearWorkflowProjectDiscoveryCache()
+  }
+})
+
+test('a missing session store never erases the projections built from the run files', async () => {
+  const fixture = await makeFixture()
+  const previousAgentDir = process.env.PI_CODING_AGENT_DIR
+  try {
+    clearWorkflowProjectDiscoveryCache()
+    // Point Pi's session store at a path that does not exist. Only the cwd
+    // evidence is lost; the run files are untouched, so every projection built
+    // from them must survive.
+    process.env.PI_CODING_AGENT_DIR = join(fixture.realCwd, 'no-such-agent-dir')
+    const key = projectKey(fixture.realCwd)
+
+    const discovery = await discoverWorkflowProjects()
+    assert.ok(discovery.projects.has(key), 'the project dir is still discovered')
+    assert.equal(discovery.projects.get(key), null, 'its cwd cannot be recovered')
+    assert.equal(discovery.sessionDirCwds.size, 0)
+
+    const resolved = await resolveWorkflowWorkspaces([])
+    const projection = resolved.find((ws) => ws.id === `workflow-${key}`)
+    assert.ok(projection, 'the unregistered project still gets a projection')
+    assert.equal(projection.path, join(homedir(), '.pi', 'workflows', 'projects', key))
+
+    const runs = await listWorkflowRuns([projection])
+    assert.equal(runs.length, 1)
+    assert.equal(runs[0].runId, RUN_ID)
+  } finally {
+    if (previousAgentDir === undefined) delete process.env.PI_CODING_AGENT_DIR
+    else process.env.PI_CODING_AGENT_DIR = previousAgentDir
+    await fixture.cleanup()
+    clearWorkflowProjectDiscoveryCache()
+  }
+})
+
+test('discovery results are cached and reused between polls', async () => {
+  const fixture = await makeFixture()
+  try {
+    clearWorkflowProjectDiscoveryCache()
+    const first = await discoverWorkflowProjects()
+    const second = await discoverWorkflowProjects()
+    // Same cache hit → same Map instances; no re-walk on the next poll.
+    assert.equal(second.projects, first.projects)
+    assert.equal(second.sessionDirCwds, first.sessionDirCwds)
+    clearWorkflowProjectDiscoveryCache()
+    const third = await discoverWorkflowProjects()
+    assert.notEqual(third.projects, first.projects)
+  } finally {
+    await fixture.cleanup()
+    clearWorkflowProjectDiscoveryCache()
+  }
+})