@zerwiz/ymir 0.1.33 → 0.1.35

package/apps/sessrumnir/src/main/ipc/package-handlers.ts

@@ -0,0 +1,330 @@
+import { ipcMain } from 'electron'
+import { IPC_CHANNELS } from '../../shared/ipc-contracts'
+import { isValidPackageSpec } from '../../shared/package-spec'
+import { fetchPackageCatalog } from '../package-catalog'
+import { readFile } from 'fs/promises'
+import { join } from 'path'
+import { assertTrustedSender, isString } from './validation'
+import { runPiCli } from './run-pi-cli'
+import { activeEngineKind } from './active-engine'
+import { parseOmpPluginList, type OmpNpmPlugin } from '../omp-plugin-list'
+import {
+  explainOmpFailure,
+  findPackageUpdates,
+  ompNpmTargets,
+  OmpPluginListError,
+  ompUpdateInstallSpec,
+  piRegistryQuery,
+  type OmpNpmTarget,
+  type OmpRegistryQuery,
+  type UpdateCandidate,
+} from '../package-updates'
+import type { AgentEngineKind, InstalledPackage, PackageUpdate } from '../../shared/ipc-contracts'
+import type { IpcContext } from './context'
+import { t } from '../../shared/i18n'
+
+export function registerPackageHandlers(ctx: IpcContext): void {
+  const { workspaceManager } = ctx
+
+  // ─── Package Management ─────────────────────────────────────────────────
+
+  // Package actions target the engine the user is looking at, and run that
+  // engine's own CLI — a session from the other store can be active while a
+  // different engine is the configured default.
+  const activeEngine = (): AgentEngineKind => activeEngineKind(workspaceManager)
+
+  ipcMain.handle(IPC_CHANNELS.PACKAGE_LIST_INSTALLED, async () => {
+    const ws = workspaceManager.getActiveWorkspace()
+    const cwd = ws?.path ?? process.cwd()
+    return listInstalledPackages(cwd, activeEngine())
+  })
+
+  ipcMain.handle(IPC_CHANNELS.PACKAGE_INSTALL, async (event, packageSpec: unknown) => {
+    assertTrustedSender(event)
+    if (!isString(packageSpec)) throw new Error('packageSpec must be a string')
+    if (!isValidPackageSpec(packageSpec)) throw new Error(t('errors.packages.invalidSpec'))
+    const ws = workspaceManager.getActiveWorkspace()
+    const cwd = ws?.path ?? process.cwd()
+    return installPackage(packageSpec, cwd, activeEngine())
+  })
+
+  ipcMain.handle(IPC_CHANNELS.PACKAGE_REMOVE, async (event, packageSpec: unknown) => {
+    assertTrustedSender(event)
+    if (!isString(packageSpec)) throw new Error('packageSpec must be a string')
+    if (!isValidPackageSpec(packageSpec)) throw new Error(t('errors.packages.invalidSpec'))
+    const ws = workspaceManager.getActiveWorkspace()
+    const cwd = ws?.path ?? process.cwd()
+    return removePackage(packageSpec, cwd, activeEngine())
+  })
+
+  ipcMain.handle(IPC_CHANNELS.PACKAGE_UPDATE, async (event, packageSpec: unknown) => {
+    assertTrustedSender(event)
+    if (!isString(packageSpec)) throw new Error('packageSpec must be a string')
+    if (!isValidPackageSpec(packageSpec)) throw new Error(t('errors.packages.invalidSpec'))
+    const ws = workspaceManager.getActiveWorkspace()
+    const cwd = ws?.path ?? process.cwd()
+    return updatePackage(packageSpec, cwd, activeEngine())
+  })
+
+  ipcMain.handle(IPC_CHANNELS.PACKAGE_UPDATE_ALL, async (event) => {
+    assertTrustedSender(event)
+    const ws = workspaceManager.getActiveWorkspace()
+    const cwd = ws?.path ?? process.cwd()
+    return updateAllPackages(cwd, activeEngine())
+  })
+
+  ipcMain.handle(IPC_CHANNELS.PACKAGE_CHECK_UPDATES, async () => {
+    const ws = workspaceManager.getActiveWorkspace()
+    const cwd = ws?.path ?? process.cwd()
+    return checkPackageUpdates(cwd, activeEngine())
+  })
+
+  ipcMain.handle(IPC_CHANNELS.PACKAGE_CATALOG_FETCH, async (_event, query?: unknown) => {
+    return fetchPackageCatalog(isString(query) ? query : undefined)
+  })
+}
+
+// ─── Package Management ──────────────────────────────────────────────────────
+
+const LIST_TIMEOUT_MS = 30_000
+const INSTALL_TIMEOUT_MS = 120_000
+const REMOVE_TIMEOUT_MS = 30_000
+const UPDATE_TIMEOUT_MS = 120_000
+// Updating every package runs one install per outdated package.
+const UPDATE_ALL_TIMEOUT_MS = 300_000
+
+// Bare `pi update` updates Pi itself; `--extensions` limits it to packages.
+const PI_UPDATE_ALL_ARGS = ['update', '--extensions']
+const OMP_PLUGIN_LIST_ARGS = ['plugin', 'list', '--json']
+// Without a plugin id, OMP upgrades every outdated marketplace plugin.
+const OMP_MARKETPLACE_UPGRADE_ARGS = ['plugin', 'upgrade']
+
+type CliResult = { success: boolean; output: string }
+
+interface PiPackageScope {
+  scope: 'global' | 'project'
+  settingsPath: string
+  npmRoot: string
+}
+
+function homeDir(): string {
+  return process.env.HOME ?? process.env.USERPROFILE ?? ''
+}
+
+function ompPluginsDir(): string {
+  return join(homeDir(), '.omp', 'plugins')
+}
+
+/** Pi's package scopes: each has a settings `packages` array and a shared npm project. */
+function piPackageScopes(cwd: string): PiPackageScope[] {
+  const agentDir = join(homeDir(), '.pi', 'agent')
+  const projectDir = join(cwd, '.pi')
+  return [
+    { scope: 'global', settingsPath: join(agentDir, 'settings.json'), npmRoot: join(agentDir, 'npm') },
+    { scope: 'project', settingsPath: join(projectDir, 'settings.json'), npmRoot: join(projectDir, 'npm') },
+  ]
+}
+
+async function listInstalledPackages(cwd: string, engine: AgentEngineKind): Promise<InstalledPackage[]> {
+  try {
+    if (engine === 'omp') return listOmpPlugins(cwd)
+    const packages: InstalledPackage[] = []
+    for (const { scope, settingsPath } of piPackageScopes(cwd)) {
+      const scopePackages = await readPackagesFromSettings(settingsPath)
+      packages.push(...scopePackages.map((p) => ({ ...p, scope })))
+    }
+    return packages
+  } catch {
+    return []
+  }
+}
+
+/**
+ * OMP does not track packages in a settings.json `packages` array — its plugin
+ * store lives in `~/.omp/plugins/` — so the installed list comes from the CLI.
+ */
+async function listOmpPlugins(cwd: string): Promise<InstalledPackage[]> {
+  const result = await runPiCli(OMP_PLUGIN_LIST_ARGS, cwd, LIST_TIMEOUT_MS, 'omp')
+  if (!result.success) return []
+  return parseOmpPluginList(result.output, ompPluginsDir())
+}
+
+async function readJsonObject(path: string): Promise<Record<string, unknown> | null> {
+  try {
+    const parsed: unknown = JSON.parse(await readFile(path, 'utf-8'))
+    return typeof parsed === 'object' && parsed !== null ? (parsed as Record<string, unknown>) : null
+  } catch {
+    return null
+  }
+}
+
+async function readPackageVersion(packageJsonPath: string): Promise<string | null> {
+  const version = (await readJsonObject(packageJsonPath))?.version
+  return typeof version === 'string' ? version : null
+}
+
+async function piUpdateCandidates(cwd: string): Promise<UpdateCandidate[]> {
+  const candidates: UpdateCandidate[] = []
+  for (const { settingsPath, npmRoot } of piPackageScopes(cwd)) {
+    for (const pkg of await readPackagesFromSettings(settingsPath)) {
+      const query = piRegistryQuery(pkg.source)
+      if (!query) continue
+      const installedVersion = await readPackageVersion(join(npmRoot, 'node_modules', query.name, 'package.json'))
+      if (installedVersion) candidates.push({ source: pkg.source, query, installedVersion })
+    }
+  }
+  return candidates
+}
+
+/**
+ * OMP's npm plugins with their registry lookups. The lookup comes from the
+ * plugin store's package.json, which records how each plugin was installed.
+ */
+async function readOmpNpmTargets(cwd: string): Promise<OmpNpmTarget[]> {
+  const result = await runPiCli(OMP_PLUGIN_LIST_ARGS, cwd, LIST_TIMEOUT_MS, 'omp')
+  const manifest = await readJsonObject(join(ompPluginsDir(), 'package.json'))
+  return ompNpmTargets(result, (manifest?.dependencies ?? {}) as Record<string, unknown>)
+}
+
+/** Run an OMP mutation that needs the npm plugin list; a failed list is the result. */
+async function withOmpNpmTargets(
+  cwd: string,
+  mutate: (targets: OmpNpmTarget[]) => Promise<CliResult>
+): Promise<CliResult> {
+  let targets: OmpNpmTarget[]
+  try {
+    targets = await readOmpNpmTargets(cwd)
+  } catch (error) {
+    if (!(error instanceof OmpPluginListError)) throw error
+    return { success: false, output: t('errors.packages.listFailed', { detail: error.detail }) }
+  }
+  return mutate(targets)
+}
+
+function ompUpdateCandidates(targets: OmpNpmTarget[]): UpdateCandidate[] {
+  return targets.flatMap(({ plugin, query }) =>
+    query && plugin.version ? [{ source: plugin.name, query, installedVersion: plugin.version }] : []
+  )
+}
+
+async function checkPackageUpdates(cwd: string, engine: AgentEngineKind): Promise<PackageUpdate[]> {
+  const candidates = engine === 'omp'
+    ? ompUpdateCandidates(await readOmpNpmTargets(cwd))
+    : await piUpdateCandidates(cwd)
+  return findPackageUpdates(candidates)
+}
+
+function combineResults(results: CliResult[]): CliResult {
+  return {
+    success: results.every((result) => result.success),
+    output: results.map((result) => result.output.trim()).filter(Boolean).join('\n\n'),
+  }
+}
+
+function withOmpFailureExplained(result: CliResult, engine: AgentEngineKind): CliResult {
+  return engine === 'omp' && !result.success ? { ...result, output: explainOmpFailure(result.output) } : result
+}
+
+/** Run an OMP command that changes the plugin store. */
+async function runOmpMutation(args: string[], cwd: string, timeout: number): Promise<CliResult> {
+  return withOmpFailureExplained(await runPiCli(args, cwd, timeout, 'omp'), 'omp')
+}
+
+/**
+ * OMP has no update command for npm plugins, so an update reinstalls from the
+ * registry. The install spec carries the feature selection; `omp install`
+ * also re-enables the plugin, so a disabled plugin is disabled again.
+ */
+async function updateOmpNpmPlugin(plugin: OmpNpmPlugin, query: OmpRegistryQuery, cwd: string): Promise<CliResult> {
+  const install = await runOmpMutation(['install', ompUpdateInstallSpec(query, plugin)], cwd, UPDATE_TIMEOUT_MS)
+  if (!install.success || plugin.enabled) return install
+  const disable = await runOmpMutation(['plugin', 'disable', plugin.name], cwd, UPDATE_TIMEOUT_MS)
+  return combineResults([install, disable])
+}
+
+async function updateOmpPlugin(spec: string, cwd: string): Promise<CliResult> {
+  return withOmpNpmTargets(cwd, async (targets) => {
+    const target = targets.find(({ plugin }) => plugin.name === spec)
+    // Not an npm plugin: marketplace ids (`name@marketplace`) have a native upgrade.
+    if (!target) return runOmpMutation(['plugin', 'upgrade', spec], cwd, UPDATE_TIMEOUT_MS)
+    if (!target.query) {
+      return { success: false, output: t('errors.packages.pinnedOrNotFromNpm', { spec }) }
+    }
+    return updateOmpNpmPlugin(target.plugin, target.query, cwd)
+  })
+}
+
+async function updateAllOmpPlugins(cwd: string): Promise<CliResult> {
+  return withOmpNpmTargets(cwd, async (targets) => {
+    const outdated = new Set((await findPackageUpdates(ompUpdateCandidates(targets))).map((update) => update.source))
+    const results = [await runOmpMutation(OMP_MARKETPLACE_UPGRADE_ARGS, cwd, UPDATE_ALL_TIMEOUT_MS)]
+    // Sequential: every npm plugin shares one bun project and lockfile.
+    for (const { plugin, query } of targets) {
+      if (query && outdated.has(plugin.name)) results.push(await updateOmpNpmPlugin(plugin, query, cwd))
+    }
+    return combineResults(results)
+  })
+}
+
+async function readPackagesFromSettings(settingsPath: string): Promise<InstalledPackage[]> {
+  const packageEntries = (await readJsonObject(settingsPath))?.packages
+  if (!Array.isArray(packageEntries)) return []
+  return packageEntries.map((entry: unknown): InstalledPackage => {
+    if (typeof entry === 'string') {
+      return {
+        name: extractPackageName(entry),
+        source: entry,
+        type: 'package',
+        version: extractVersion(entry),
+        path: settingsPath,
+      }
+    }
+    if (typeof entry === 'object' && entry !== null) {
+      const e = entry as Record<string, unknown>
+      return {
+        name: extractPackageName(String(e.source ?? '')),
+        source: String(e.source ?? ''),
+        type: 'package',
+        version: extractVersion(String(e.source ?? '')),
+        path: settingsPath,
+      }
+    }
+    return { name: 'unknown', source: String(entry), type: 'package', version: null, path: settingsPath }
+  })
+}
+
+function extractPackageName(source: string): string {
+  // npm:@scope/name@1.0.0 -> @scope/name
+  // npm:name@1.0.0 -> name
+  // git:github.com/user/repo -> user/repo
+  const npmMatch = source.match(/^npm:(@?[^@]+)/)
+  if (npmMatch) return npmMatch[1]
+
+  const gitMatch = source.match(/github\.com\/([^/]+\/[^/@]+)/)
+  if (gitMatch) return gitMatch[1]
+
+  return source.split('/').pop() ?? source
+}
+
+function extractVersion(source: string): string | null {
+  const match = source.match(/@([^/]+)$/)
+  return match ? match[1] : null
+}
+
+async function installPackage(spec: string, cwd: string, engine: AgentEngineKind): Promise<CliResult> {
+  return withOmpFailureExplained(await runPiCli(['install', spec], cwd, INSTALL_TIMEOUT_MS, engine), engine)
+}
+
+async function removePackage(spec: string, cwd: string, engine: AgentEngineKind): Promise<CliResult> {
+  return runPiCli(['remove', spec], cwd, REMOVE_TIMEOUT_MS, engine)
+}
+
+async function updatePackage(spec: string, cwd: string, engine: AgentEngineKind): Promise<CliResult> {
+  if (engine === 'omp') return updateOmpPlugin(spec, cwd)
+  return runPiCli(['update', spec], cwd, UPDATE_TIMEOUT_MS, engine)
+}
+
+async function updateAllPackages(cwd: string, engine: AgentEngineKind): Promise<CliResult> {
+  if (engine === 'omp') return updateAllOmpPlugins(cwd)
+  return runPiCli(PI_UPDATE_ALL_ARGS, cwd, UPDATE_ALL_TIMEOUT_MS, engine)
+}

package/apps/sessrumnir/src/main/ipc/permission-rules-handlers.ts

@@ -0,0 +1,223 @@
+import { ipcMain, dialog } from 'electron'
+import { WorkspaceManager } from '../workspace-manager'
+import type {
+  PermissionRulesScope,
+  PermissionRulesGetResult,
+  PermissionRulesSetResult,
+  PermissionRulesImportResult,
+  PermissionRulesExportResult,
+  PermissionRulesWorkspaceStatus,
+  PermissionRulesRemoveResult,
+  PermissionRulesFile,
+} from '../../shared/ipc-contracts'
+import { IPC_CHANNELS } from '../../shared/ipc-contracts'
+import { readFile, writeFile, mkdir, stat, unlink } from 'fs/promises'
+import { dirname } from 'path'
+import { existsSync } from 'fs'
+import { workspaceTrustStore } from '../workspace-trust'
+import {
+  PERMISSION_RULES_FILE_NAME,
+  PERMISSION_RULES_VERSION,
+  loadEffectiveRules,
+  validatePermissionRulesFile,
+  workspaceRulesPath,
+} from '../../../resources/permission-rules'
+import { assertTrustedSender } from './validation'
+import { getGlobalPermissionRulesPath, applyResumePreference, applyPermissionModeToStartOptions } from './pi-start-options'
+import { loadAppSettings, saveAppSettings } from './settings'
+import type { IpcContext } from './context'
+import { t } from '../../shared/i18n'
+
+const MAX_PERMISSION_RULES_FILE_BYTES = 512 * 1024
+function permissionRulesFileFilter(): Electron.FileFilter {
+  return { name: t('dialogs.permissionRules.fileFilterName'), extensions: ['json'] }
+}
+
+function validatePermissionRulesScope(scope: unknown): PermissionRulesScope {
+  if (scope === 'global' || scope === 'workspace') return scope
+  throw new Error('scope must be "global" or "workspace"')
+}
+
+function activeWorkspaceRulesPath(workspaceManager: WorkspaceManager): { path: string; workspacePath: string } {
+  const activeWs = workspaceManager.getActiveWorkspace()
+  if (!activeWs) throw new Error(t('errors.workspace.noneActive'))
+  return { path: workspaceRulesPath(activeWs.path), workspacePath: activeWs.path }
+}
+
+/** Also consumed by the diagnostics report. */
+export async function buildWorkspaceRulesStatus(
+  workspaceManager: WorkspaceManager,
+): Promise<PermissionRulesWorkspaceStatus> {
+  const activeWs = workspaceManager.getActiveWorkspace()
+  if (!activeWs) {
+    return { hasWorkspaceRules: false, workspacePath: null, acknowledged: false, trusted: false, hasAllowRules: false }
+  }
+  const settings = await loadAppSettings(workspaceManager)
+  // Read the workspace's own rules (as if trusted, no global) purely to detect
+  // whether it contains allow rules — the only case where trust matters.
+  const workspaceOwnRules = loadEffectiveRules(activeWs.path, null, { workspaceTrusted: true })
+  const hasAllowRules =
+    workspaceOwnRules.source === 'workspace' && workspaceOwnRules.rules.some((r) => r.action === 'allow')
+  return {
+    hasWorkspaceRules: existsSync(workspaceRulesPath(activeWs.path)),
+    workspacePath: activeWs.path,
+    acknowledged: settings.permissionRulesAckWorkspaces.includes(activeWs.path),
+    trusted: workspaceTrustStore.isTrusted(activeWs.path),
+    hasAllowRules,
+  }
+}
+
+export function registerPermissionRulesHandlers(ctx: IpcContext): void {
+  const { workspaceManager } = ctx
+
+  // ─── Permission Rules ───────────────────────────────────────────────────
+
+  ipcMain.handle(IPC_CHANNELS.PERMISSION_RULES_GET, async (_event, scope: unknown): Promise<PermissionRulesGetResult> => {
+    try {
+      let rulesPath: string
+      if (validatePermissionRulesScope(scope) === 'global') {
+        rulesPath = getGlobalPermissionRulesPath()
+      } else {
+        // No active workspace means no workspace file — not an error, so the
+        // panel never mistakes this state for a corrupt file.
+        const activeWs = workspaceManager.getActiveWorkspace()
+        if (!activeWs) return { ok: true, rules: [], exists: false }
+        rulesPath = workspaceRulesPath(activeWs.path)
+      }
+      if (!existsSync(rulesPath)) return { ok: true, rules: [], exists: false }
+      const file = validatePermissionRulesFile(JSON.parse(await readFile(rulesPath, 'utf-8')))
+      return { ok: true, rules: file.rules, exists: true }
+    } catch (error) {
+      return { ok: false, error: error instanceof Error ? error.message : String(error) }
+    }
+  })
+
+  ipcMain.handle(IPC_CHANNELS.PERMISSION_RULES_SET, async (_event, scope: unknown, rules: unknown): Promise<PermissionRulesSetResult> => {
+    try {
+      const validScope = validatePermissionRulesScope(scope)
+      const file = validatePermissionRulesFile({ version: PERMISSION_RULES_VERSION, rules })
+      if (validScope === 'global') {
+        const rulesPath = getGlobalPermissionRulesPath()
+        await mkdir(dirname(rulesPath), { recursive: true })
+        await writeFile(rulesPath, `${JSON.stringify(file, null, 2)}\n`, 'utf-8')
+        return { ok: true }
+      }
+      const { path: rulesPath, workspacePath } = activeWorkspaceRulesPath(workspaceManager)
+      await mkdir(dirname(rulesPath), { recursive: true })
+      await writeFile(rulesPath, `${JSON.stringify(file, null, 2)}\n`, 'utf-8')
+      // The user created this file deliberately — acknowledge the workspace so
+      // the one-time "workspace has its own rules" notice never fires for it.
+      const settings = await loadAppSettings(workspaceManager)
+      if (!settings.permissionRulesAckWorkspaces.includes(workspacePath)) {
+        await saveAppSettings({
+          permissionRulesAckWorkspaces: [...settings.permissionRulesAckWorkspaces, workspacePath],
+        })
+      }
+      return { ok: true }
+    } catch (error) {
+      return { ok: false, error: error instanceof Error ? error.message : String(error) }
+    }
+  })
+
+  ipcMain.handle(IPC_CHANNELS.PERMISSION_RULES_IMPORT, async (): Promise<PermissionRulesImportResult> => {
+    const result = await dialog.showOpenDialog({
+      title: t('dialogs.permissionRules.importTitle'),
+      properties: ['openFile'],
+      filters: [permissionRulesFileFilter()],
+    })
+    if (result.canceled || result.filePaths.length === 0) return { ok: false, canceled: true }
+    try {
+      const filePath = result.filePaths[0]
+      const { size } = await stat(filePath)
+      if (size > MAX_PERMISSION_RULES_FILE_BYTES) {
+        return { ok: false, error: t('errors.permissionRules.fileTooLarge', { limit: MAX_PERMISSION_RULES_FILE_BYTES }) }
+      }
+      const file = validatePermissionRulesFile(JSON.parse(await readFile(filePath, 'utf-8')))
+      return { ok: true, rules: file.rules }
+    } catch (error) {
+      return { ok: false, error: error instanceof Error ? error.message : String(error) }
+    }
+  })
+
+  ipcMain.handle(IPC_CHANNELS.PERMISSION_RULES_EXPORT, async (_event, rules: unknown): Promise<PermissionRulesExportResult> => {
+    let file: PermissionRulesFile
+    try {
+      file = validatePermissionRulesFile({ version: PERMISSION_RULES_VERSION, rules })
+    } catch (error) {
+      return { ok: false, error: error instanceof Error ? error.message : String(error) }
+    }
+    const result = await dialog.showSaveDialog({
+      title: t('dialogs.permissionRules.exportTitle'),
+      defaultPath: PERMISSION_RULES_FILE_NAME,
+      filters: [permissionRulesFileFilter()],
+    })
+    if (result.canceled || !result.filePath) return { ok: false, canceled: true }
+    try {
+      await writeFile(result.filePath, `${JSON.stringify(file, null, 2)}\n`, 'utf-8')
+      return { ok: true }
+    } catch (error) {
+      console.error('Failed to write exported permission rules file:', error)
+      return { ok: false, error: error instanceof Error ? error.message : String(error) }
+    }
+  })
+
+  ipcMain.handle(IPC_CHANNELS.PERMISSION_RULES_WORKSPACE_STATUS, async (): Promise<PermissionRulesWorkspaceStatus> => {
+    return buildWorkspaceRulesStatus(workspaceManager)
+  })
+
+  ipcMain.handle(
+    IPC_CHANNELS.PERMISSION_RULES_SET_WORKSPACE_TRUST,
+    async (event, trusted: unknown): Promise<PermissionRulesWorkspaceStatus> => {
+      assertTrustedSender(event)
+      if (typeof trusted !== 'boolean') throw new Error('trusted must be a boolean')
+      const activeWs = workspaceManager.getActiveWorkspace()
+      if (!activeWs) throw new Error(t('errors.workspace.noneActive'))
+
+      if (trusted !== workspaceTrustStore.isTrusted(activeWs.path)) {
+        if (trusted) {
+          await workspaceTrustStore.trust(activeWs.path)
+        } else {
+          await workspaceTrustStore.revoke(activeWs.path)
+        }
+
+        // Trust is read into PI_DESKTOP_WORKSPACE_TRUSTED at spawn time and
+        // gates the preview guest at attach time. Restart every live session
+        // runtime in this workspace, not only the foreground one.
+        const fresh = await loadAppSettings(workspaceManager)
+        const liveRuntimes = workspaceManager
+          .getSessionRuntimes(activeWs.id)
+          .filter((runtime) => runtime.status === 'running')
+        if (liveRuntimes.length > 0) {
+          await Promise.all(liveRuntimes.map((runtime) =>
+            workspaceManager.restartSessionRuntime(
+              runtime.runtimeId,
+              applyPermissionModeToStartOptions(applyResumePreference({ cwd: activeWs.path }, fresh), fresh)
+            )
+          ))
+        } else {
+          const pi = workspaceManager.getPiManager(activeWs.id)
+          if (pi && pi.getStatus().status === 'running') {
+            pi.stop()
+            await pi.start(
+              applyPermissionModeToStartOptions(applyResumePreference({ cwd: activeWs.path }, fresh), fresh)
+            )
+          }
+        }
+      }
+      return buildWorkspaceRulesStatus(workspaceManager)
+    }
+  )
+
+  ipcMain.handle(IPC_CHANNELS.PERMISSION_RULES_REMOVE_WORKSPACE, async (): Promise<PermissionRulesRemoveResult> => {
+    try {
+      const { path: rulesPath } = activeWorkspaceRulesPath(workspaceManager)
+      await unlink(rulesPath)
+      return { ok: true }
+    } catch (error) {
+      // Already gone is still success — the caller's goal (no workspace rules
+      // file) is met either way.
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { ok: true }
+      return { ok: false, error: error instanceof Error ? error.message : String(error) }
+    }
+  })
+}

package/apps/sessrumnir/src/main/ipc/pi-handlers.ts

@@ -0,0 +1,136 @@
+import { ipcMain } from 'electron'
+import { IPC_CHANNELS } from '../../shared/ipc-contracts'
+import { access } from 'fs/promises'
+import { isString, isObject } from './validation'
+import { validateStartOptions, applyResumePreference, applyPermissionModeToStartOptions } from './pi-start-options'
+import { loadAppSettings } from './settings'
+import type { IpcContext } from './context'
+import { detectPiInstallations, getConfiguredEngineKind } from '../pi-rpc-manager'
+import { t } from '../../shared/i18n'
+
+export function registerPiHandlers(ctx: IpcContext): void {
+  const { workspaceManager, getActivePi } = ctx
+
+  // ─── Pi Process Lifecycle ───────────────────────────────────────────────
+
+  ipcMain.handle(IPC_CHANNELS.PI_START, async (_event, options?: unknown) => {
+    const opts = validateStartOptions(options)
+    const settings = await loadAppSettings(workspaceManager)
+    const activeWs = workspaceManager.getActiveWorkspace()
+    if (!activeWs) throw new Error(t('errors.workspace.noneActive'))
+
+    // Validate cwd exists; fall back to home directory if not
+    let cwd = activeWs.path
+    try {
+      await access(cwd)
+    } catch {
+      cwd = process.env.HOME ?? process.env.USERPROFILE ?? process.cwd()
+    }
+
+    // Prefer explicit start options, else last model chosen in the GUI.
+    const withDefaults = {
+      ...opts,
+      cwd,
+      provider: opts.provider ?? settings.defaultProvider ?? undefined,
+      model: opts.model ?? settings.defaultModel ?? undefined,
+    }
+    await workspaceManager.startPiForWorkspace(
+      activeWs.id,
+      applyPermissionModeToStartOptions(applyResumePreference(withDefaults, settings), settings)
+    )
+    const pi = workspaceManager.getPiManager(activeWs.id)
+    if (!pi) throw new Error(t('errors.pi.failedToCreateManager'))
+
+    return pi.getStatus()
+  })
+
+  ipcMain.handle(IPC_CHANNELS.PI_STOP, async () => {
+    const activeWs = workspaceManager.getActiveWorkspace()
+    if (activeWs) {
+      workspaceManager.stopPiForWorkspace(activeWs.id)
+    }
+    return { status: 'stopped', pid: null, error: null }
+  })
+
+  ipcMain.handle(IPC_CHANNELS.PI_RESTART, async (_event, options?: unknown) => {
+    const opts = validateStartOptions(options)
+    const settings = await loadAppSettings(workspaceManager)
+    const activeWs = workspaceManager.getActiveWorkspace()
+    if (!activeWs) throw new Error(t('errors.workspace.noneActive'))
+
+    const pi = workspaceManager.getPiManager(activeWs.id)
+    if (!pi) throw new Error(t('errors.pi.noManagerForWorkspace'))
+
+    // Restart the runtime, not just its process: the runtime owns the session
+    // binding, and restartSessionRuntime re-applies it. Starting the manager
+    // directly would drop it — `--continue` picks whatever file on disk is
+    // newest (possibly another live runtime's), and without the resume setting
+    // Pi opens a blank session, either way leaving the tab lying about which
+    // session it shows.
+    const runtimeId = workspaceManager.runtimeIdFor(pi)
+    const runtime = runtimeId ? workspaceManager.getSessionRuntime(runtimeId) : null
+    const startOptions = applyPermissionModeToStartOptions(
+      applyResumePreference({ cwd: activeWs.path, ...opts }, settings),
+      settings
+    )
+    if (runtime) {
+      const info = await workspaceManager.restartSessionRuntime(runtime.runtimeId, startOptions)
+      return { status: info.status, pid: info.pid, error: info.error }
+    }
+
+    pi.stop()
+    return pi.start(startOptions)
+  })
+
+  ipcMain.handle(IPC_CHANNELS.PI_STATUS, async () => {
+    const pi = workspaceManager.getActivePiManager()
+    // No manager yet is the normal state at launch. Report the engine that
+    // would start anyway, or the status bar names Pi until something runs.
+    if (!pi) return { status: 'stopped', pid: null, error: null, engine: getConfiguredEngineKind() }
+    return pi.getStatus()
+  })
+
+  // `{ force: true }` is what the Rescan button must send: without it the
+  // handler may answer from a cache up to 30 s old and an engine installed
+  // moments ago never appears.
+  ipcMain.handle(IPC_CHANNELS.PI_DETECT_INSTALLATIONS, async (_event, options?: unknown) => ({
+    installations: detectPiInstallations(isObject(options) && options.force === true),
+  }))
+
+  // ─── Pi Commands ────────────────────────────────────────────────────────
+
+  ipcMain.handle(IPC_CHANNELS.PI_PROMPT, async (_event, message: unknown, options?: unknown) => {
+    if (!isString(message)) throw new Error('message must be a string')
+    const cmd: Record<string, unknown> = { type: 'prompt', message }
+    if (isObject(options)) {
+      if (options.images) cmd.images = options.images
+      if (options.streamingBehavior) cmd.streamingBehavior = options.streamingBehavior
+    }
+    return getActivePi().sendCommand(cmd)
+  })
+
+  ipcMain.handle(IPC_CHANNELS.PI_STEER, async (_event, message: unknown, images?: unknown) => {
+    if (!isString(message)) throw new Error('message must be a string')
+    const cmd: Record<string, unknown> = { type: 'steer', message }
+    if (Array.isArray(images) && images.length > 0) cmd.images = images
+    return getActivePi().sendCommand(cmd)
+  })
+
+  ipcMain.handle(IPC_CHANNELS.PI_FOLLOW_UP, async (_event, message: unknown) => {
+    if (!isString(message)) throw new Error('message must be a string')
+    return getActivePi().sendCommand({ type: 'follow_up', message })
+  })
+
+  ipcMain.handle(IPC_CHANNELS.PI_ABORT, async () => {
+    return getActivePi().sendCommand({ type: 'abort' })
+  })
+
+  ipcMain.handle(IPC_CHANNELS.PI_BASH, async (_event, command: unknown) => {
+    if (!isString(command)) throw new Error('command must be a string')
+    return getActivePi().sendCommand({ type: 'bash', command })
+  })
+
+  ipcMain.handle(IPC_CHANNELS.PI_ABORT_BASH, async () => {
+    return getActivePi().sendCommand({ type: 'abort_bash' })
+  })
+}