@zerwiz/ymir 0.1.33 → 0.1.35

package/apps/sessrumnir/src/main/workspace-trust.test.ts

@@ -0,0 +1,78 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { WorkspaceTrustStore } from './workspace-trust'
+
+function tmpFile(): { path: string; cleanup: () => void } {
+  const dir = mkdtempSync(join(tmpdir(), 'pi-trust-'))
+  return { path: join(dir, 'trusted-workspaces.json'), cleanup: () => rmSync(dir, { recursive: true, force: true }) }
+}
+
+test('an unknown workspace is not trusted', () => {
+  const { path, cleanup } = tmpFile()
+  try {
+    const store = new WorkspaceTrustStore(path)
+    assert.equal(store.isTrusted('/home/alice/project'), false)
+  } finally {
+    cleanup()
+  }
+})
+
+test('trust() marks a workspace trusted and persists across instances', async () => {
+  const { path, cleanup } = tmpFile()
+  try {
+    const store = new WorkspaceTrustStore(path)
+    await store.trust('/home/alice/project')
+    assert.equal(store.isTrusted('/home/alice/project'), true)
+    // A fresh instance reading the same file sees the persisted trust.
+    assert.equal(new WorkspaceTrustStore(path).isTrusted('/home/alice/project'), true)
+  } finally {
+    cleanup()
+  }
+})
+
+test('revoke() removes trust and persists', async () => {
+  const { path, cleanup } = tmpFile()
+  try {
+    const store = new WorkspaceTrustStore(path)
+    await store.trust('/home/alice/project')
+    await store.revoke('/home/alice/project')
+    assert.equal(store.isTrusted('/home/alice/project'), false)
+    assert.equal(new WorkspaceTrustStore(path).isTrusted('/home/alice/project'), false)
+  } finally {
+    cleanup()
+  }
+})
+
+test('paths are normalized so trailing slashes and .. segments match', async () => {
+  const { path, cleanup } = tmpFile()
+  try {
+    const store = new WorkspaceTrustStore(path)
+    await store.trust('/home/alice/project/')
+    assert.equal(store.isTrusted('/home/alice/project'), true)
+    assert.equal(store.isTrusted('/home/alice/x/../project'), true)
+  } finally {
+    cleanup()
+  }
+})
+
+test('an empty path is never trusted', () => {
+  const { path, cleanup } = tmpFile()
+  try {
+    assert.equal(new WorkspaceTrustStore(path).isTrusted(''), false)
+  } finally {
+    cleanup()
+  }
+})
+
+test('a malformed trust file is treated as no trust, not a crash', () => {
+  const { path, cleanup } = tmpFile()
+  try {
+    writeFileSync(path, '{ not json', 'utf-8')
+    assert.equal(new WorkspaceTrustStore(path).isTrusted('/home/alice/project'), false)
+  } finally {
+    cleanup()
+  }
+})

package/apps/sessrumnir/src/main/workspace-trust.ts

@@ -0,0 +1,84 @@
+import { existsSync, mkdirSync, readFileSync } from 'fs'
+import { writeFile } from 'fs/promises'
+import { dirname, resolve } from 'path'
+import { getGuiDataPath } from './app-data-paths'
+
+/**
+ * Workspace trust registry.
+ *
+ * A workspace's `.pi-desktop/permission-rules.json` can come from an untrusted
+ * cloned repository. Its `allow` rules take effect only once the user trusts the
+ * workspace (see loadEffectiveRules), and the HTML file preview only runs scripts
+ * for a trusted workspace. Trust is keyed by resolved absolute path and persisted
+ * as a JSON array of paths in the Electron userData directory.
+ *
+ * `isTrusted` is synchronous so it can be consulted from the two hot, sync paths
+ * that gate on trust: building each Pi spawn's environment, and Electron's
+ * `will-attach-webview` handler for the preview guest.
+ */
+
+const TRUST_FILE_NAME = 'trusted-workspaces.json'
+
+export class WorkspaceTrustStore {
+  private path: string
+  private trusted = new Set<string>()
+  private loaded = false
+
+  constructor(filePath?: string) {
+    this.path = filePath ?? getGuiDataPath(TRUST_FILE_NAME)
+  }
+
+  isTrusted(workspacePath: string): boolean {
+    if (!workspacePath) return false
+    this.ensureLoaded()
+    return this.trusted.has(resolve(workspacePath))
+  }
+
+  async trust(workspacePath: string): Promise<void> {
+    if (!workspacePath) return
+    this.ensureLoaded()
+    const key = resolve(workspacePath)
+    if (this.trusted.has(key)) return
+    this.trusted.add(key)
+    await this.save()
+  }
+
+  async revoke(workspacePath: string): Promise<void> {
+    if (!workspacePath) return
+    this.ensureLoaded()
+    const key = resolve(workspacePath)
+    if (!this.trusted.has(key)) return
+    this.trusted.delete(key)
+    await this.save()
+  }
+
+  private ensureLoaded(): void {
+    if (this.loaded) return
+    try {
+      if (existsSync(this.path)) {
+        const parsed = JSON.parse(readFileSync(this.path, 'utf-8')) as unknown
+        if (Array.isArray(parsed)) {
+          for (const entry of parsed) {
+            if (typeof entry === 'string' && entry) this.trusted.add(resolve(entry))
+          }
+        }
+      }
+    } catch {
+      this.trusted = new Set()
+    }
+    this.loaded = true
+  }
+
+  private async save(): Promise<void> {
+    try {
+      const dir = dirname(this.path)
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+      await writeFile(this.path, JSON.stringify([...this.trusted], null, 2), 'utf-8')
+    } catch (err) {
+      console.error('Failed to save trusted workspaces:', err)
+    }
+  }
+}
+
+/** Singleton used across the main process. */
+export const workspaceTrustStore = new WorkspaceTrustStore()

package/apps/sessrumnir/src/preload/index.ts

@@ -0,0 +1,358 @@
+/**
+ * Preload bridge — exposes `window.piDesktop` to the renderer.
+ *
+ * Transport detection:
+ *   - Electron IPC when running inside Electron (contextBridge + ipcRenderer)
+ *   - HTTP/WS when served by the web shell (createHttpBridge)
+ *
+ * The renderer always calls `window.piDesktop.<method>()` — it never knows
+ * which transport is active.
+ */
+
+import { contextBridge, ipcRenderer, webUtils } from 'electron'
+import type { PiDesktopAPI } from '../shared/bridge'
+import { createHttpBridge } from '../shared/bridge-http'
+import type {
+  PiRpcEvent,
+  PiStartOptions,
+  FileChangeEvent,
+  TerminalExitEvent,
+  CouncilProgressEvent,
+  PendingPromptCounts,
+  WorkspaceActivityMap,
+  SessionRuntimeInfo,
+  WorkspaceActivationIntent,
+} from '../shared/ipc-contracts'
+import { IPC_CHANNELS } from '../shared/ipc-contracts'
+
+// ─── Transport detection ────────────────────────────────────────────────────
+
+/**
+ * Returns true when running inside Electron (contextBridge + ipcRenderer
+ * are available). Returns false when served by the web shell (Bun.serve).
+ */
+const IS_ELECTRON = typeof contextBridge !== 'undefined' && typeof ipcRenderer !== 'undefined'
+
+// ─── Bridge factory ─────────────────────────────────────────────────────────
+
+/**
+ * Create the bridge implementation based on the detected transport.
+ * The renderer always calls `window.piDesktop` — it never knows which
+ * transport is active.
+ */
+function createBridge(): PiDesktopAPI {
+  if (IS_ELECTRON) {
+    // ── Electron IPC bridge ──────────────────────────────────────────────
+    const api: PiDesktopAPI = {
+      pi: {
+        start: (options?: PiStartOptions) => ipcRenderer.invoke(IPC_CHANNELS.PI_START, options),
+        stop: () => ipcRenderer.invoke(IPC_CHANNELS.PI_STOP),
+        restart: (options?: PiStartOptions) => ipcRenderer.invoke(IPC_CHANNELS.PI_RESTART, options),
+        getStatus: () => ipcRenderer.invoke(IPC_CHANNELS.PI_STATUS),
+        detectInstallations: (options) => ipcRenderer.invoke(IPC_CHANNELS.PI_DETECT_INSTALLATIONS, options),
+      },
+
+      commands: {
+        prompt: (message, options) => ipcRenderer.invoke(IPC_CHANNELS.PI_PROMPT, message, options),
+        steer: (message, images) => ipcRenderer.invoke(IPC_CHANNELS.PI_STEER, message, images),
+        followUp: (message) => ipcRenderer.invoke(IPC_CHANNELS.PI_FOLLOW_UP, message),
+        abort: () => ipcRenderer.invoke(IPC_CHANNELS.PI_ABORT),
+        bash: (command) => ipcRenderer.invoke(IPC_CHANNELS.PI_BASH, command),
+        abortBash: () => ipcRenderer.invoke(IPC_CHANNELS.PI_ABORT_BASH),
+      },
+
+      session: {
+        createNew: () => ipcRenderer.invoke(IPC_CHANNELS.SESSION_NEW),
+        launchTask: (options) => ipcRenderer.invoke(IPC_CHANNELS.SESSION_LAUNCH_TASK, options),
+        closeRuntime: (runtimeId) => ipcRenderer.invoke(IPC_CHANNELS.SESSION_CLOSE_RUNTIME, runtimeId),
+        switch: (sessionPath, cwd) => ipcRenderer.invoke(IPC_CHANNELS.SESSION_SWITCH, sessionPath, cwd),
+        listRuntimes: () => ipcRenderer.invoke(IPC_CHANNELS.SESSION_LIST_RUNTIMES),
+        fork: (entryId) => ipcRenderer.invoke(IPC_CHANNELS.SESSION_FORK, entryId),
+        clone: () => ipcRenderer.invoke(IPC_CHANNELS.SESSION_CLONE),
+        list: (cwd) => ipcRenderer.invoke(IPC_CHANNELS.SESSION_LIST, cwd),
+        listAll: (cwd) => ipcRenderer.invoke(IPC_CHANNELS.SESSION_LIST_ALL, cwd),
+        getState: () => ipcRenderer.invoke(IPC_CHANNELS.SESSION_GET_STATE),
+        getMessages: () => ipcRenderer.invoke(IPC_CHANNELS.SESSION_GET_MESSAGES),
+        getStats: () => ipcRenderer.invoke(IPC_CHANNELS.SESSION_GET_STATS),
+        setName: (name) => ipcRenderer.invoke(IPC_CHANNELS.SESSION_SET_NAME, name),
+        exportHtml: (outputPath) => ipcRenderer.invoke(IPC_CHANNELS.SESSION_EXPORT_HTML, outputPath),
+        getForkMessages: () => ipcRenderer.invoke(IPC_CHANNELS.SESSION_GET_FORK_MESSAGES),
+        getLineage: () => ipcRenderer.invoke(IPC_CHANNELS.SESSION_GET_LINEAGE),
+        compact: (customInstructions) => ipcRenderer.invoke(IPC_CHANNELS.SESSION_COMPACT, customInstructions),
+        delete: (sessionPath) => ipcRenderer.invoke(IPC_CHANNELS.SESSION_DELETE, sessionPath),
+        archive: (sessionId) => ipcRenderer.invoke(IPC_CHANNELS.SESSION_ARCHIVE, sessionId),
+        unarchive: (sessionId) => ipcRenderer.invoke(IPC_CHANNELS.SESSION_UNARCHIVE, sessionId),
+        listArchived: () => ipcRenderer.invoke(IPC_CHANNELS.SESSION_LIST_ARCHIVED),
+      },
+
+      model: {
+        set: (provider, modelId) => ipcRenderer.invoke(IPC_CHANNELS.MODEL_SET, provider, modelId),
+        cycle: () => ipcRenderer.invoke(IPC_CHANNELS.MODEL_CYCLE),
+        listAvailable: () => ipcRenderer.invoke(IPC_CHANNELS.MODEL_LIST_AVAILABLE),
+      },
+
+      thinking: {
+        setLevel: (level) => ipcRenderer.invoke(IPC_CHANNELS.THINKING_SET_LEVEL, level),
+        cycleLevel: () => ipcRenderer.invoke(IPC_CHANNELS.THINKING_CYCLE_LEVEL),
+      },
+
+      settings: {
+        getAll: () => ipcRenderer.invoke(IPC_CHANNELS.SETTINGS_GET_ALL),
+        save: (settings) => ipcRenderer.invoke(IPC_CHANNELS.SETTINGS_SAVE, settings),
+      },
+
+      permissionRules: {
+        get: (scope) => ipcRenderer.invoke(IPC_CHANNELS.PERMISSION_RULES_GET, scope),
+        set: (scope, rules) => ipcRenderer.invoke(IPC_CHANNELS.PERMISSION_RULES_SET, scope, rules),
+        importFromFile: () => ipcRenderer.invoke(IPC_CHANNELS.PERMISSION_RULES_IMPORT),
+        exportToFile: (rules) => ipcRenderer.invoke(IPC_CHANNELS.PERMISSION_RULES_EXPORT, rules),
+        workspaceStatus: () => ipcRenderer.invoke(IPC_CHANNELS.PERMISSION_RULES_WORKSPACE_STATUS),
+        removeWorkspace: () => ipcRenderer.invoke(IPC_CHANNELS.PERMISSION_RULES_REMOVE_WORKSPACE),
+        setWorkspaceTrust: (trusted) => ipcRenderer.invoke(IPC_CHANNELS.PERMISSION_RULES_SET_WORKSPACE_TRUST, trusted),
+      },
+
+      themes: {
+        list: () => ipcRenderer.invoke(IPC_CHANNELS.THEMES_LIST),
+        save: (file, existingId) => ipcRenderer.invoke(IPC_CHANNELS.THEMES_SAVE, file, existingId),
+        delete: (id) => ipcRenderer.invoke(IPC_CHANNELS.THEMES_DELETE, id),
+        installFromUrl: (url) => ipcRenderer.invoke(IPC_CHANNELS.THEMES_INSTALL_URL, url),
+        export: (file) => ipcRenderer.invoke(IPC_CHANNELS.THEMES_EXPORT, file),
+        import: () => ipcRenderer.invoke(IPC_CHANNELS.THEMES_IMPORT),
+        gallery: () => ipcRenderer.invoke(IPC_CHANNELS.THEMES_GALLERY_LIST),
+        galleryImage: (url) => ipcRenderer.invoke(IPC_CHANNELS.THEMES_GALLERY_IMAGE, url),
+      },
+
+      workspace: {
+        list: () => ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_LIST),
+        create: (name, path) => ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_CREATE, name, path),
+        remove: (workspaceId) => ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_REMOVE, workspaceId),
+        rename: (workspaceId, name) => ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_RENAME, workspaceId, name),
+        changePath: (workspaceId, newPath) => ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_CHANGE_PATH, workspaceId, newPath),
+        pathExists: () => ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_PATH_EXISTS),
+        setActive: (workspaceId) => ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_SET_ACTIVE, workspaceId),
+        getActive: () => ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_GET_ACTIVE),
+        startPi: (workspaceId, options) => ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_START_PI, workspaceId, options),
+        stopPi: (workspaceId) => ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_STOP_PI, workspaceId),
+        createTab: (options) => ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_CREATE_TAB, options),
+        getActivity: () => ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_ACTIVITY_GET),
+        takePendingActivation: () => ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_TAKE_PENDING_ACTIVATION),
+      },
+
+      packages: {
+        listInstalled: () => ipcRenderer.invoke(IPC_CHANNELS.PACKAGE_LIST_INSTALLED),
+        install: (spec) => ipcRenderer.invoke(IPC_CHANNELS.PACKAGE_INSTALL, spec),
+        remove: (spec) => ipcRenderer.invoke(IPC_CHANNELS.PACKAGE_REMOVE, spec),
+        update: (spec) => ipcRenderer.invoke(IPC_CHANNELS.PACKAGE_UPDATE, spec),
+        updateAll: () => ipcRenderer.invoke(IPC_CHANNELS.PACKAGE_UPDATE_ALL),
+        checkUpdates: () => ipcRenderer.invoke(IPC_CHANNELS.PACKAGE_CHECK_UPDATES),
+        fetchCatalog: (query) => ipcRenderer.invoke(IPC_CHANNELS.PACKAGE_CATALOG_FETCH, query),
+      },
+
+      models: {
+        read: () => ipcRenderer.invoke(IPC_CHANNELS.MODELS_READ),
+        write: (config) => ipcRenderer.invoke(IPC_CHANNELS.MODELS_WRITE, config),
+      },
+
+      council: {
+        detect: () => ipcRenderer.invoke(IPC_CHANNELS.COUNCIL_DETECT),
+        runConsultants: (payload) => ipcRenderer.invoke(IPC_CHANNELS.COUNCIL_RUN_CONSULTANTS, payload),
+        arbiter: (payload) => ipcRenderer.invoke(IPC_CHANNELS.COUNCIL_ARBITER, payload),
+        onProgress: (callback) => {
+          const handler = (_event: Electron.IpcRendererEvent, data: CouncilProgressEvent) => callback(data)
+          ipcRenderer.on(IPC_CHANNELS.EVENT_COUNCIL_PROGRESS, handler)
+          return () => ipcRenderer.removeListener(IPC_CHANNELS.EVENT_COUNCIL_PROGRESS, handler)
+        },
+      },
+
+      skills: {
+        list: () => ipcRenderer.invoke(IPC_CHANNELS.SKILLS_LIST),
+      },
+      piCommands: {
+        list: () => ipcRenderer.invoke(IPC_CHANNELS.COMMANDS_LIST),
+      },
+      mcpServers: {
+        list: () => ipcRenderer.invoke(IPC_CHANNELS.MCP_SERVERS_LIST),
+      },
+      tags: {
+        get: (sessionId) => ipcRenderer.invoke(IPC_CHANNELS.TAG_GET, sessionId),
+        set: (sessionId, tags) => ipcRenderer.invoke(IPC_CHANNELS.TAG_SET, sessionId, tags),
+        add: (sessionId, tag) => ipcRenderer.invoke(IPC_CHANNELS.TAG_ADD, sessionId, tag),
+        remove: (sessionId, tag) => ipcRenderer.invoke(IPC_CHANNELS.TAG_REMOVE, sessionId, tag),
+        getAll: () => ipcRenderer.invoke(IPC_CHANNELS.TAG_GET_ALL),
+        getAllUsed: () => ipcRenderer.invoke(IPC_CHANNELS.TAG_GET_ALL_USED),
+        autoGetAll: () => ipcRenderer.invoke(IPC_CHANNELS.TAG_AUTO_GET_ALL),
+        autoEnsure: (sessions) => ipcRenderer.invoke(IPC_CHANNELS.TAG_AUTO_ENSURE, sessions),
+        autoRemove: (sessionId) => ipcRenderer.invoke(IPC_CHANNELS.TAG_AUTO_REMOVE, sessionId),
+      },
+
+      git: {
+        status: () => ipcRenderer.invoke(IPC_CHANNELS.GIT_CONVEYOR_STATUS),
+        commit: (options) => ipcRenderer.invoke(IPC_CHANNELS.GIT_CONVEYOR_COMMIT, options),
+        push: () => ipcRenderer.invoke(IPC_CHANNELS.GIT_CONVEYOR_PUSH),
+        createPullRequest: (options) => ipcRenderer.invoke(IPC_CHANNELS.GIT_CONVEYOR_CREATE_PR, options),
+      },
+
+      notes: {
+        list: () => ipcRenderer.invoke(IPC_CHANNELS.NOTES_LIST),
+        create: (input) => ipcRenderer.invoke(IPC_CHANNELS.NOTES_CREATE, input),
+        update: (id, patch) => ipcRenderer.invoke(IPC_CHANNELS.NOTES_UPDATE, id, patch),
+        remove: (id) => ipcRenderer.invoke(IPC_CHANNELS.NOTES_REMOVE, id),
+      },
+
+      files: {
+        getTree: (maxDepth) => ipcRenderer.invoke(IPC_CHANNELS.FILE_TREE, maxDepth),
+        search: (query) => ipcRenderer.invoke(IPC_CHANNELS.FILE_SEARCH, query),
+        searchContent: (query) => ipcRenderer.invoke(IPC_CHANNELS.FILE_SEARCH_CONTENT, query),
+        read: (path) => ipcRenderer.invoke(IPC_CHANNELS.FILE_READ, path),
+        readAttachment: (path) => ipcRenderer.invoke(IPC_CHANNELS.FILE_READ_ATTACHMENT, path),
+        write: (path, content) => ipcRenderer.invoke(IPC_CHANNELS.FILE_WRITE, path, content),
+        getDiff: (filePath) => ipcRenderer.invoke(IPC_CHANNELS.FILE_DIFF, filePath),
+        getStagedDiff: (filePath) => ipcRenderer.invoke(IPC_CHANNELS.FILE_STAGED_DIFF, filePath),
+        getGitStatus: () => ipcRenderer.invoke(IPC_CHANNELS.GIT_STATUS),
+        getGitBranch: () => ipcRenderer.invoke(IPC_CHANNELS.GIT_BRANCH),
+      },
+
+      system: {
+        openDialog: (options) => ipcRenderer.invoke(IPC_CHANNELS.SYSTEM_OPEN_DIALOG, options),
+        getPath: (name) => ipcRenderer.invoke(IPC_CHANNELS.SYSTEM_GET_PATH, name),
+        getPathForFile: (file) => webUtils.getPathForFile(file),
+        pathKind: (path) => ipcRenderer.invoke(IPC_CHANNELS.SYSTEM_PATH_KIND, path),
+        platform: process.platform,
+        openExternal: (url) => ipcRenderer.invoke(IPC_CHANNELS.SYSTEM_OPEN_EXTERNAL, url),
+        hallUrl: () => ipcRenderer.invoke(IPC_CHANNELS.SYSTEM_HALL_URL),
+      fleet: () => ipcRenderer.invoke(IPC_CHANNELS.FLEET_LIST),
+        getVersion: () => ipcRenderer.invoke(IPC_CHANNELS.SYSTEM_GET_VERSION),
+      },
+
+      activity: {
+        getStats: () => ipcRenderer.invoke(IPC_CHANNELS.ACTIVITY_GET_STATS),
+      },
+
+      workflows: {
+        list: () => ipcRenderer.invoke(IPC_CHANNELS.WORKFLOW_LIST),
+        getRun: (workspaceId, runId) => ipcRenderer.invoke(IPC_CHANNELS.WORKFLOW_GET_RUN, workspaceId, runId),
+        control: (workspaceId, runId, action) => ipcRenderer.invoke(IPC_CHANNELS.WORKFLOW_CONTROL, workspaceId, runId, action),
+        setPersistAgentSessions: (enabled) => ipcRenderer.invoke(IPC_CHANNELS.WORKFLOW_SET_PERSISTENCE, enabled),
+      },
+
+      diagnostics: {
+        get: () => ipcRenderer.invoke(IPC_CHANNELS.DIAGNOSTICS_GET),
+      },
+
+      updates: {
+        check: () => ipcRenderer.invoke(IPC_CHANNELS.UPDATE_CHECK),
+      },
+
+      i18n: {
+        getEnvironment: () => ipcRenderer.invoke(IPC_CHANNELS.I18N_GET_ENVIRONMENT),
+      },
+
+      terminal: {
+        start: (options) => ipcRenderer.invoke(IPC_CHANNELS.TERMINAL_START, options),
+        input: (data) => ipcRenderer.invoke(IPC_CHANNELS.TERMINAL_INPUT, data),
+        resize: (cols, rows) => ipcRenderer.invoke(IPC_CHANNELS.TERMINAL_RESIZE, { cols, rows }),
+        stop: () => ipcRenderer.invoke(IPC_CHANNELS.TERMINAL_STOP),
+        onData: (callback) => {
+          const handler = (_event: Electron.IpcRendererEvent, data: string) => callback(data)
+          ipcRenderer.on(IPC_CHANNELS.EVENT_TERMINAL_DATA, handler)
+          return () => ipcRenderer.removeListener(IPC_CHANNELS.EVENT_TERMINAL_DATA, handler)
+        },
+        onExit: (callback) => {
+          const handler = (_event: Electron.IpcRendererEvent, data: TerminalExitEvent) => callback(data)
+          ipcRenderer.on(IPC_CHANNELS.EVENT_TERMINAL_EXIT, handler)
+          return () => ipcRenderer.removeListener(IPC_CHANNELS.EVENT_TERMINAL_EXIT, handler)
+        },
+      },
+
+      ui: {
+        respondSelect: (id, value) => ipcRenderer.invoke(IPC_CHANNELS.UI_SELECT_RESPONSE, id, value),
+        respondConfirm: (id, confirmed) => ipcRenderer.invoke(IPC_CHANNELS.UI_CONFIRM_RESPONSE, id, confirmed),
+        respondInput: (id, value) => ipcRenderer.invoke(IPC_CHANNELS.UI_INPUT_RESPONSE, id, value),
+        respondEditor: (id, value) => ipcRenderer.invoke(IPC_CHANNELS.UI_EDITOR_RESPONSE, id, value),
+        flushPendingPrompts: (workspaceId) => ipcRenderer.invoke(IPC_CHANNELS.UI_PENDING_FLUSH, workspaceId),
+        getPendingPrompts: () => ipcRenderer.invoke(IPC_CHANNELS.UI_PENDING_GET),
+        setEditorDirty: (dirty, fileName) =>
+          ipcRenderer.send(
+            IPC_CHANNELS.UI_EDITOR_DIRTY_SET,
+            dirty === true,
+            typeof fileName === 'string' ? fileName : null
+          ),
+      },
+
+      onEvent: (callback) => {
+        const handler = (_event: Electron.IpcRendererEvent, data: PiRpcEvent) => callback(data)
+        ipcRenderer.on(IPC_CHANNELS.EVENT_PI, handler)
+        return () => {
+          ipcRenderer.removeListener(IPC_CHANNELS.EVENT_PI, handler)
+        }
+      },
+
+      onPendingPrompts: (callback) => {
+        const handler = (_event: Electron.IpcRendererEvent, data: PendingPromptCounts) => callback(data)
+        ipcRenderer.on(IPC_CHANNELS.EVENT_PENDING_PROMPTS, handler)
+        return () => {
+          ipcRenderer.removeListener(IPC_CHANNELS.EVENT_PENDING_PROMPTS, handler)
+        }
+      },
+
+      onWorkspaceActivity: (callback) => {
+        const handler = (_event: Electron.IpcRendererEvent, data: WorkspaceActivityMap) => callback(data)
+        ipcRenderer.on(IPC_CHANNELS.EVENT_WORKSPACE_ACTIVITY, handler)
+        return () => {
+          ipcRenderer.removeListener(IPC_CHANNELS.EVENT_WORKSPACE_ACTIVITY, handler)
+        }
+      },
+
+      onSessionRuntime: (callback) => {
+        const handler = (_event: Electron.IpcRendererEvent, data: SessionRuntimeInfo) => callback(data)
+        ipcRenderer.on(IPC_CHANNELS.EVENT_SESSION_RUNTIME, handler)
+        return () => {
+          ipcRenderer.removeListener(IPC_CHANNELS.EVENT_SESSION_RUNTIME, handler)
+        }
+      },
+
+      onActivateWorkspace: (callback) => {
+        const handler = (_event: Electron.IpcRendererEvent, data: WorkspaceActivationIntent) => callback(data)
+        ipcRenderer.on(IPC_CHANNELS.EVENT_ACTIVATE_WORKSPACE, handler)
+        return () => {
+          ipcRenderer.removeListener(IPC_CHANNELS.EVENT_ACTIVATE_WORKSPACE, handler)
+        }
+      },
+
+      onFileChange: (callback) => {
+        const handler = (_event: Electron.IpcRendererEvent, data: FileChangeEvent) => callback(data)
+        ipcRenderer.on(IPC_CHANNELS.EVENT_FILE_CHANGE, handler)
+        return () => {
+          ipcRenderer.removeListener(IPC_CHANNELS.EVENT_FILE_CHANGE, handler)
+        }
+      },
+
+      onMenuAction: (callback) => {
+        const handlers: Array<() => void> = []
+        const actions = ['menu:new-session', 'menu:new-workspace', 'menu:open-project']
+
+        for (const action of actions) {
+          const handler = () => callback(action)
+          ipcRenderer.on(action, handler)
+          handlers.push(() => ipcRenderer.removeListener(action, handler))
+        }
+
+        return () => {
+          for (const cleanup of handlers) cleanup()
+        }
+      },
+    }
+    return api
+  }
+
+  // ── HTTP/WS bridge (web shell) ─────────────────────────────────────────
+  return createHttpBridge()
+}
+
+// ─── Expose to Renderer ─────────────────────────────────────────────────────
+
+const bridge = createBridge()
+contextBridge.exposeInMainWorld('piDesktop', bridge)
+
+// Re-export the type for renderer usage
+export type { PiDesktopAPI }

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

@@ -0,0 +1,20 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out/preload",
+    "rootDir": "../..",
+    "lib": ["ES2022", "DOM"],
+    "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/renderer/index.html

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en" class="dark">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta
+      http-equiv="Content-Security-Policy"
+      content="default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self'; connect-src 'self'"
+    />
+    <link rel="icon" type="image/svg+xml" href="./src/assets/pi-logo.svg" />
+<title>Sessrúmnir</title>
+    <script src="/theme-boot.js"></script>
+  </head>
+  <body class="bg-app text-primary antialiased">
+    <div id="root"></div>
+    <script type="module" src="./src/main.tsx"></script>
+  </body>
+</html>

package/apps/sessrumnir/src/renderer/public/theme-boot.js

@@ -0,0 +1,30 @@
+// Paints the last theme's background and text colors before the first frame,
+// so the window does not flash the default dark body while the app bundle
+// loads settings. Loaded as a classic, parser-blocking script from
+// index.html's <head>. The stored value is written by rememberBootTheme in
+// src/renderer/src/utils/theme.ts: { light: BootPaint, dark: BootPaint },
+// where BootPaint is { app, text, kind }. Keep the key and shape in sync.
+(function () {
+  var BOOT_THEME_STORAGE_KEY = 'pi-desktop.boot-theme'
+  var html = document.documentElement
+  var mode = window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light'
+  var paint
+  try {
+    var stored = JSON.parse(localStorage.getItem(BOOT_THEME_STORAGE_KEY))
+    paint = stored && stored[mode]
+  } catch {
+    paint = null
+  }
+  if (!paint || typeof paint.app !== 'string' || typeof paint.text !== 'string'
+      || (paint.kind !== 'light' && paint.kind !== 'dark')) {
+    // First launch or unreadable value: clear the stylesheet's dark default
+    // app color so the canvas, colored by the OS mode, shows through.
+    html.style.setProperty('--color-app', 'transparent')
+    html.style.colorScheme = mode
+    return
+  }
+  html.style.setProperty('--color-app', paint.app)
+  html.style.setProperty('--color-primary', paint.text)
+  html.style.colorScheme = paint.kind
+  html.classList.toggle('light', paint.kind === 'light')
+})()