@pheem49/mint 1.14.0 → 1.16.0

package/src/renderer/shared/library/controller.ts

@@ -0,0 +1,57 @@
+import type { LibraryItem, LibraryPage, LibraryQuery } from '../types'
+export interface LibraryOperations {
+  list(query: LibraryQuery): Promise<LibraryPage>
+  setTrashed(id: string, trashed: boolean): Promise<void>
+  remove(id: string): Promise<void>
+}
+export interface LibraryState { items: LibraryItem[]; query: LibraryQuery; nextCursor: string | null; loading: boolean; error: string; actionId: string | null; actionError: string }
+export function createLibraryController(api: LibraryOperations) {
+  let state: LibraryState = { items: [], query: {}, nextCursor: null, loading: false, error: '', actionId: null, actionError: '' }
+  let generation = 0
+  let loadedPages = 1
+  const listeners = new Set<() => void>()
+  const update = (patch: Partial<LibraryState>) => { state = { ...state, ...patch }; listeners.forEach(listener => listener()) }
+  const load = async (append = false) => {
+    if (append && (state.loading || !state.nextCursor)) return
+    const current = ++generation
+    const query = { ...state.query, cursor: append ? state.nextCursor : undefined }
+    const pagesToRefresh = append ? 1 : loadedPages
+    update({ loading: true, error: '' })
+    try {
+      let page = await api.list(query)
+      if (current !== generation) return
+      let pagesRead = 1
+      const refreshedItems = [...page.items]
+      while (!append && pagesRead < pagesToRefresh && page.nextCursor) {
+        page = await api.list({ ...query, cursor: page.nextCursor })
+        if (current !== generation) return
+        refreshedItems.push(...page.items)
+        pagesRead++
+      }
+      if (!append) page = { ...page, items: refreshedItems }
+      loadedPages = append ? loadedPages + 1 : pagesRead
+      const items = append ? [...new Map([...state.items, ...page.items].map(item => [item.id, item])).values()] : page.items
+      update({ items, nextCursor: page.nextCursor })
+    } catch (error) { if (current === generation) update({ error: String(error) }) }
+    finally { if (current === generation) update({ loading: false }) }
+  }
+  const mutate = async (id: string, operation: () => Promise<void>) => {
+    if (state.actionId) return
+    const current = generation
+    update({ actionId: id, actionError: '' })
+    try {
+      await operation()
+      if (current === generation) { generation++; update({ items: state.items.filter(item => item.id !== id), loading: false }) }
+      else await load()
+    } catch (error) { update({ actionError: String(error) }) }
+    finally { update({ actionId: null }) }
+  }
+  return {
+    remove: (id: string) => mutate(id, () => api.remove(id)),
+    getSnapshot: () => state,
+    subscribe: (listener: () => void) => { listeners.add(listener); return () => { listeners.delete(listener) } },
+    setQuery: async (query: LibraryQuery) => { loadedPages = 1; update({ query: { ...query, cursor: undefined }, items: [], nextCursor: null, actionError: '' }); await load() },
+    refresh: () => load(), loadMore: () => load(true),
+    setTrashed: (id: string, trashed: boolean) => mutate(id, () => api.setTrashed(id, trashed)),
+  }
+}

package/src/renderer/shared/library/transport.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest'
+import { createLibraryTransport } from './transport'
+describe('Library wire contract', () => {
+  it('encodes filters, uses indexed IDs for content and surfaces server errors', async () => {
+    const calls: {url: URL; method: string}[] = []
+    const api = createLibraryTransport({ isNative: () => false, apiBase: () => 'http://localhost/api', fetch: async (input, init) => {
+      const url = new URL(String(input)); calls.push({url,method:init?.method ?? 'GET'})
+      if(url.pathname.endsWith('/content')) return new Response('hello', {headers:{'Content-Type':'text/markdown'}})
+      if(init?.method === 'POST' || init?.method === 'DELETE') return Response.json({message:'Storage unavailable'}, {status:503})
+      return Response.json({items:[],nextCursor:null})
+    } })
+    await api.listLibrary({kind:'file',search:'สรุป & notes',chatId:'A',trashed:true,cursor:'next/+'})
+    expect(calls).toHaveLength(1)
+    expect(calls[0].url.searchParams.get('search')).toBe('สรุป & notes')
+    expect(calls[0].url.searchParams.get('trashed')).toBe('true')
+    expect(calls[0].url.searchParams.get('cursor')).toBe('next/+')
+    expect(await (await api.readLibraryFile('item 1')).text()).toBe('hello')
+    expect(calls[1].url.pathname).toBe('/api/library/item%201/content')
+    await expect(api.setLibraryTrashed('item 1',true)).rejects.toThrow('Storage unavailable')
+    expect(calls[2].method).toBe('POST')
+    expect(calls[2].url.pathname).toBe('/api/library/item%201/trash')
+    await expect(api.removeLibraryItem('item 1')).rejects.toThrow('Storage unavailable')
+    expect(calls[3].method).toBe('DELETE')
+    expect(calls[3].url.pathname).toBe('/api/library/item%201')
+  })
+})

package/src/renderer/shared/library/transport.ts

@@ -0,0 +1,60 @@
+import type { LibraryItem, LibraryPage, LibraryQuery } from '../types';
+interface Environment {
+  isNative(): boolean;
+  apiBase(): string;
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+}
+export function createLibraryTransport(environment: Environment) {
+  const request = async (path: string, init?: RequestInit) => {
+    const response = await environment.fetch(`${environment.apiBase()}/library${path}`, init);
+    if (!response.ok) {
+      const data = await response.json().catch(() => null);
+      throw new Error(data?.message || `Library unavailable (${response.status})`);
+    }
+    return response;
+  };
+  return {
+    async removeLibraryItem(id: string): Promise<void> {
+      if (environment.isNative()) {
+        const { invoke } = await import('@tauri-apps/api/core');
+        await invoke('remove_library_item', { id });
+        return;
+      }
+      await request(`/${encodeURIComponent(id)}`, { method: 'DELETE' });
+    },
+    async listLibrary(query: LibraryQuery): Promise<LibraryPage> {
+      if (environment.isNative()) {
+        const { invoke } = await import('@tauri-apps/api/core');
+        return invoke('list_library', { query });
+      }
+      const params = new URLSearchParams();
+      Object.entries(query).forEach(([key, value]) => { if (value !== undefined && value !== null && value !== '')
+        params.set(key, String(value)); });
+      return (await request(`?${params}`)).json();
+    },
+    async getLibraryItem(id: string): Promise<LibraryItem> {
+      if (environment.isNative()) {
+        const { invoke } = await import('@tauri-apps/api/core');
+        return invoke('get_library_item', { id });
+      }
+      return (await request(`/${encodeURIComponent(id)}`)).json();
+    },
+    async setLibraryTrashed(id: string, trashed: boolean): Promise<void> {
+      if (environment.isNative()) {
+        const { invoke } = await import('@tauri-apps/api/core');
+        await invoke('set_library_trashed', { id, trashed });
+        return;
+      }
+      await request(`/${encodeURIComponent(id)}/${trashed ? 'trash' : 'restore'}`, { method: 'POST' });
+    },
+    async readLibraryFile(id: string, thumbnail = false): Promise<Blob> {
+      if (environment.isNative()) {
+        const { invoke } = await import('@tauri-apps/api/core');
+        const uri = await invoke<string>('read_library_file', { id, thumbnail });
+        // Use a local data URI; remote fetch always passes through the authenticated adapter.
+        return (await fetch(uri)).blob();
+      }
+      return (await request(`/${encodeURIComponent(id)}/${thumbnail ? 'thumbnail' : 'content'}`)).blob();
+    },
+  };
+}

package/src/renderer/shared/library/useLibraryFile.ts

@@ -0,0 +1,38 @@
+import { useEffect, useState } from 'react';
+import { libraryPlatform } from '../platform';
+/** Own each object URL for exactly one mounted consumer, including late responses. */
+export function useLibraryFile(id: string | null, thumbnail = false, revision = 0) {
+  const [state, setState] = useState<{
+    url: string;
+    blob: Blob | null;
+    error: string;
+  }>({ url: '', blob: null, error: '' });
+  useEffect(() => {
+    let active = true;
+    let url = '';
+    setState({ url: '', blob: null, error: '' });
+    if (id)
+      libraryPlatform.readLibraryFile(id, thumbnail).then(blob => {
+        if (!active)
+          return;
+        url = URL.createObjectURL(blob);
+        setState({ url, blob, error: '' });
+      }).catch(error => { if (active)
+        setState({ url: '', blob: null, error: String(error) }); });
+    return () => { active = false; if (url)
+      URL.revokeObjectURL(url); };
+  }, [id, thumbnail, revision]);
+  return state;
+}
+export async function downloadLibraryFile(id: string, name: string) {
+  const blob = await libraryPlatform.readLibraryFile(id);
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement('a');
+  anchor.href = url;
+  anchor.download = name;
+  document.body.append(anchor);
+  anchor.click();
+  anchor.remove();
+  // Allow the browser to start consuming the download before releasing its URL.
+  setTimeout(() => URL.revokeObjectURL(url), 1000);
+}

package/src/renderer/shared/mods.ts

@@ -0,0 +1,58 @@
+export interface ModNode {
+  color?: 'default' | 'yellow' | 'cyan' | 'blue' | 'magenta' | 'red'
+  direction?: 'row' | 'column'
+  type: 'text' | 'stack' | 'button' | 'input' | 'table' | 'badge' | 'progress'
+  text?: string
+  label?: string
+  action?: string
+  value?: string | number
+  max?: number
+  children?: ModNode[]
+  columns?: string[]
+  rows?: (string | number | null)[][]
+}
+export interface ModTestReport { passed: number; failed: number; tests: { file: string; name: string; passed: boolean; error?: string | null }[] }
+
+export interface ModRecord {
+  id: string
+  name: string
+  hash?: string
+  activeHash?: string
+  instanceId?: string
+  enabled: boolean
+  changed?: boolean
+  error?: string | null
+  reloadError?: string | null
+  sourceError?: string
+  source?: string
+  readme?: string
+  manifest?: { id: string; name: string; version: string; sdkVersion: number; entry: string; permissions: string[] }
+  revisions: string[]
+  snapshot?: { ui: { above_composer?: ModNode; side_panel?: ModNode }; commands: { name: string; description: string }[]; logs: string[] }
+}
+export interface ModOperation {
+  workspacePath: string
+  chatId: string
+  action: 'list' | 'enable' | 'disable' | 'action' | 'command' | 'validate' | 'rollback' | 'export' | 'import' | 'close' | 'run_request' | 'inspect_package' | 'hot_reload' | 'viewport' | 'usage' | 'test'
+  id?: string
+  scope?: 'chat' | 'workspace' | 'global'
+  grantPermissions?: boolean
+  expectedHash?: string
+  hash?: string
+  instanceId?: string
+  command?: string
+  value?: string | boolean
+  viewport?: ModViewport
+  package?: string
+}
+export interface ModResponse {
+  session?: { hotReload: boolean; viewport: ModViewport }
+  testReport?: ModTestReport
+  id?: string
+  expectedHash?: string | null
+  mods?: ModRecord[]
+  toolRequests?: { id: string; modId: string; action: string; input: unknown }[]
+  package?: string
+  filename?: string
+}
+export interface ModViewport { surface: 'terminal' | 'desktop' | 'web' | null; columns?: number | null; rows?: number | null; widthPx?: number | null; heightPx?: number | null; sidePanelOpen?: boolean }

package/src/renderer/shared/platform.test.ts

@@ -0,0 +1,90 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { authPlatform, installRendererPlatform, installWorkspacePlatform, workspacePlatform, type WorkspacePlatform } from './platform'
+import * as desktopAdapter from '../src/tauri'
+import * as webAdapter from '../src-web/tauri'
+
+afterEach(() => vi.unstubAllGlobals())
+
+describe.each([['Desktop fallback', desktopAdapter], ['Web', webAdapter]] as const)('%s skill inventory', (_name, adapter) => {
+  it('forwards the selected workspace and returns skill location metadata', async () => {
+    vi.stubGlobal('window', {
+      location: { hostname: 'localhost', port: '9000', protocol: 'http:' },
+      localStorage: { getItem: () => null },
+    })
+    let requestUrl: URL | undefined
+    const skills = [{ id: 0, name: 'example', sourcePath: '/selected project/skills/example.md',
+      content: 'selected workspace', updatedAt: '', createdAt: '', location: 'workspace',
+      description: null, is_workspace: true }]
+    vi.stubGlobal('fetch', async (input: string) => {
+      requestUrl = new URL(input, 'http://localhost:9000')
+      return new Response(JSON.stringify(skills), { headers: { 'Content-Type': 'application/json' } })
+    })
+    await expect(adapter.listLearnedSkills('/selected project')).resolves.toEqual(skills)
+    expect(requestUrl?.pathname).toBe('/api/learned-skills')
+    expect(requestUrl?.searchParams.get('workspacePath')).toBe('/selected project')
+  })
+})
+
+describe('renderer platform interfaces', () => {
+  it('accepts both complete runtime adapters', () => {
+    expect(() => installRendererPlatform(desktopAdapter)).not.toThrow()
+    expect(() => installRendererPlatform(webAdapter)).not.toThrow()
+  })
+  it('routes grouped capabilities through the installed runtime adapter', async () => {
+    const authGetCurrentUser = vi.fn(async () => ({ id: '1', name: 'Mint', email: null, image: null }))
+    installRendererPlatform(new Proxy({ APP_ICON_PATH: './icon.png', authGetCurrentUser }, {
+      get: (target, property) => property in target ? target[property as keyof typeof target] : vi.fn(),
+    }) as any)
+    await expect(authPlatform.authGetCurrentUser()).resolves.toMatchObject({ id: '1', name: 'Mint' })
+    expect(authGetCurrentUser).toHaveBeenCalledOnce()
+  })
+
+  it('routes workspace operations as one request and returns a snapshot', async () => {
+    const operation = { root: '/workspace', relativePath: 'src/main.ts', revision: 7 }
+    const snapshot = { path: '/workspace', revision: 8, tree: { name: 'workspace', path: '.', kind: 'directory', children: [] },
+      git: { isRepository: false, currentBranch: null, detachedHead: null, branches: [], remoteBranches: [], isDirty: false } }
+    const createWorkspaceFile = vi.fn(async () => snapshot)
+    const adapter = {
+      getWorkspaceSnapshot: vi.fn(), getWorkspaceGitDiff: vi.fn(), getGitBranchInfo: vi.fn(), switchGitBranch: vi.fn(),
+      createGitBranch: vi.fn(), checkoutRemoteGitBranch: vi.fn(), getGitGraph: vi.fn(),
+      createWorkspaceFile, createWorkspaceFolder: vi.fn(), deleteWorkspaceItem: vi.fn(),
+      moveWorkspaceItem: vi.fn(), listWorkspaceHistory: vi.fn(), undoWorkspaceAction: vi.fn(),
+    } satisfies WorkspacePlatform
+    installWorkspacePlatform(adapter)
+    await expect(workspacePlatform.createWorkspaceFile(operation)).resolves.toEqual(snapshot)
+    expect(createWorkspaceFile).toHaveBeenCalledWith(operation)
+  })
+})
+
+it('routes background terminal controls through both platform adapters', async () => {
+  const { backgroundPlatform } = await import('./platform')
+  for (const adapter of [desktopAdapter, webAdapter]) {
+    expect(adapter.listBackgroundJobs).toBeTypeOf('function')
+    expect(adapter.getBackgroundJob).toBeTypeOf('function')
+    expect(adapter.stopBackgroundJob).toBeTypeOf('function')
+  }
+  const job = { id: 'bg-backend-1', status: 'running' }
+  const listBackgroundJobs = vi.fn(async () => [job])
+  const getBackgroundJob = vi.fn(async () => ({ ...job, stdout: 'hello', stderr: '' }))
+  const stopBackgroundJob = vi.fn(async () => ({ ...job, status: 'stopping' }))
+  installRendererPlatform(new Proxy({ listBackgroundJobs, getBackgroundJob, stopBackgroundJob }, { get: (target, name) => target[name as keyof typeof target] || vi.fn() }) as any)
+  await expect(backgroundPlatform.list('/Demo')).resolves.toEqual([job])
+  await expect(backgroundPlatform.output(job.id)).resolves.toMatchObject({ stdout: 'hello' })
+  await expect(backgroundPlatform.stop(job.id)).resolves.toMatchObject({ status: 'stopping' })
+  expect(listBackgroundJobs).toHaveBeenCalledWith('/Demo')
+  expect(getBackgroundJob).toHaveBeenCalledWith(job.id)
+  expect(stopBackgroundJob).toHaveBeenCalledWith(job.id)
+})
+
+describe.each([['Desktop fallback', desktopAdapter], ['Web', webAdapter]] as const)('%s workspace mods', (_name, adapter) => {
+  it('forwards explicit workspace, chat, instance and action identity', async () => {
+    vi.stubGlobal('window', { location: { hostname: 'localhost', port: '9000', protocol: 'http:' }, localStorage: { getItem: () => null } })
+    let body: unknown
+    vi.stubGlobal('fetch', async (_url: unknown, init: RequestInit) => {
+      body = JSON.parse(String(init.body))
+      return new Response(JSON.stringify({ mods: [] }), { headers: { 'Content-Type': 'application/json' } })
+    })
+    await adapter.modsOperation({ workspacePath: '/project', chatId: 'chat-a', action: 'action', id: 'checklist', instanceId: 'revision-instance', command: 'add', value: 'Test' })
+    expect(body).toEqual({ workspacePath: '/project', chatId: 'chat-a', action: 'action', id: 'checklist', instanceId: 'revision-instance', command: 'add', value: 'Test' })
+  })
+})

package/src/renderer/shared/platform.ts

@@ -8,12 +8,13 @@ import type {
   ChatResponse,
   TtsUrl,
   InteractionMemory,
+  ConversationSnapshot,
+  ConversationChanges,
   ChatSession,
   PictureEntry,
   ImageGenRequest,
   ImageGenProviders,
   ImageGenResponse,
-  WorkspaceTreeEntry,
   CodeEdit,
   CodeEditProposal,
   DetectedTools,
@@ -23,6 +24,9 @@ import type {
   AgentProgress,
   AuthUser,
   GitCheckpoint,
+  GitBranchInfo,
+  GitBranchChangeOutcome,
+  WorkspaceOperation,
 } from './types'
 
 export function getLocalApiBase(): string {
@@ -47,6 +51,7 @@ export type SlashEffect =
   | { kind: 'config_changed' }
   | { kind: 'provider_changed'; display: string }
   | { kind: 'workspace_changed'; path: string }
+  | { kind: 'workspace_files_changed' }
   | { kind: 'history_cleared' }
   | { kind: 'fast_mode_changed'; enabled: boolean }
   | { kind: 'multi_agent_changed'; enabled: boolean }
@@ -62,8 +67,14 @@ export type SlashResponse =
   | { kind: 'not_handled' }
 
 export interface MintPlatformApi {
+  modsOperation(operation: import("./mods").ModOperation): Promise<import("./mods").ModResponse>
+  readMcpArtifact(id: string): Promise<string>
+  listBackgroundJobs(workspace?: string): Promise<import("./types").BackgroundJob[]>
+  getBackgroundJob(id: string): Promise<import("./types").BackgroundJobOutput>
+  stopBackgroundJob(id: string): Promise<import("./types").BackgroundJob>
+  deleteBackgroundJob(id: string): Promise<void>
   authRegister(name: string | undefined, email: string, password: string): Promise<AuthUser>
-  runSlashCommand(input: string, cwd?: string | null): Promise<SlashResponse>
+  runSlashCommand(input: string, cwd?: string | null, chatId?: string | null): Promise<SlashResponse>
   authLogin(email: string, password: string): Promise<AuthUser>
   authLogout(): Promise<void>
   authGetCurrentUser(): Promise<AuthUser | null>
@@ -80,6 +91,8 @@ export interface MintPlatformApi {
     workspacePath?: string | null,
     chatId?: string | null,
     agentId?: string | null,
+    planMode?: boolean,
+    attachmentMetadata?: import('./types').AttachmentMetadata,
   ): Promise<ChatResponse>
   streamChatMessage(
     message: string,
@@ -93,10 +106,19 @@ export interface MintPlatformApi {
     workspacePath?: string | null,
     chatId?: string | null,
     agentId?: string | null,
+    planMode?: boolean,
+    pinnedMcpServer?: string | null,
+    onApprovalRequested?: (payload: { token: string; approval: any }) => void,
+    onTurnStarted?: (interactionId: number) => void,
+    attachmentMetadata?: import('./types').AttachmentMetadata,
   ): Promise<ChatResponse>
   getTtsUrls(text: string): Promise<TtsUrl[]>
   cancelChatMessage(chatId: string): Promise<void>
-  getRecentInteractions(limit?: number, chatId?: string | null): Promise<InteractionMemory[]>
+  getRecentInteractions(limit?: number, chatId?: string | null, workspacePath?: string | null): Promise<InteractionMemory[]>
+  getConversationSnapshot(chatId: string, beforeId?: number | null, limit?: number): Promise<ConversationSnapshot>
+  getConversationSources(chatId: string): Promise<import('./types').ConversationSources>
+  saveSourceAttachments(chatId: string, interactionId: number, attachments: import('./types').SourceAttachment[]): Promise<void>
+  getConversationChanges(chatId: string, after: number, limit?: number): Promise<ConversationChanges>
   saveSystemInteraction(
     chatId: string,
     userText: string,
@@ -107,6 +129,7 @@ export interface MintPlatformApi {
 
   saveInteractionAgentActivity(interactionId: number, progress: any[]): Promise<void>
   listChatSessions(): Promise<ChatSession[]>
+  updateChatSessionWorkspace(chatId: string, workspacePath: string | null): Promise<void>
   deleteChatSession(chatId: string): Promise<number>
   renameChatSession(chatId: string, newTitle: string): Promise<number>
   getProfileValue(key: string): Promise<string>
@@ -118,15 +141,30 @@ export interface MintPlatformApi {
   saveSubagent(draft: SubagentDraft, workspacePath?: string): Promise<SubagentDefinition>
   deleteSubagent(sourcePath: string): Promise<void>
   clearChatHistory(chatId?: string | null): Promise<number>
+  listLibrary(query: import('./types').LibraryQuery): Promise<import('./types').LibraryPage>
+  getLibraryItem(id: string): Promise<import('./types').LibraryItem>
+  removeLibraryItem(id: string): Promise<void>
+  setLibraryTrashed(id: string, trashed: boolean): Promise<void>
+  readLibraryFile(id: string, thumbnail?: boolean): Promise<Blob>
   listSavedPictures(): Promise<PictureEntry[]>
   deleteSavedPicture(id: string): Promise<void>
   generateImages(req: ImageGenRequest): Promise<ImageGenResponse>
   getImageGenProviders(): Promise<ImageGenProviders>
   setDefaultImageProvider(provider: string): Promise<boolean>
-  getWorkspaceTree(path?: string | null): Promise<WorkspaceTreeEntry>
-  createWorkspaceFile(path: string): Promise<void>
-  createWorkspaceFolder(path: string): Promise<void>
-  deleteWorkspaceItem(path: string): Promise<void>
+  getWorkspaceSnapshot(operation: WorkspaceOperation): Promise<import('./types').WorkspaceSnapshot>
+  getWorkspaceGitDiff(workspacePath: string): Promise<import('./types').FileChange[]>
+  getGitBranchInfo(workspacePath: string): Promise<GitBranchInfo>
+  switchGitBranch(workspacePath: string, branch: string, confirmedDirtyWorkspace?: boolean): Promise<GitBranchChangeOutcome>
+  createGitBranch(workspacePath: string, branch: string, confirmedDirtyWorkspace?: boolean): Promise<GitBranchChangeOutcome>
+  checkoutRemoteGitBranch(workspacePath: string, remoteBranch: string, confirmedDirtyWorkspace?: boolean): Promise<GitBranchChangeOutcome>
+  getGitGraph(workspacePath: string): Promise<string[]>
+  createWorkspaceFile(operation: WorkspaceOperation): Promise<import('./types').WorkspaceSnapshot>
+  createWorkspaceFolder(operation: WorkspaceOperation): Promise<import('./types').WorkspaceSnapshot>
+  deleteWorkspaceItem(operation: WorkspaceOperation): Promise<import('./types').WorkspaceSnapshot>
+  moveWorkspaceItem(operation: WorkspaceOperation, destination: string): Promise<import('./types').WorkspaceSnapshot>
+  startHtmlPreview(root: string, relativePath: string, mintBrowser?: boolean): Promise<{ url: string; jobId: string }>
+  listWorkspaceHistory(root: string): Promise<import('./types').WorkspaceHistoryEntry[]>
+  undoWorkspaceAction(root: string, revision: number, expectedId?: string): Promise<import('./types').WorkspaceSnapshot>
   selectWorkspaceDirectory(): Promise<string | null>
   selectLinkedFolderPath(): Promise<string | null>
   submitToolApproval(token: string, approved: boolean, answer?: string): Promise<void>
@@ -143,3 +181,177 @@ export interface MintPlatformApi {
     headers?: Record<string, string>,
   ): Promise<{ ok: boolean; error?: string; server_info?: any; tools_count?: number; tools?: any[] }>
 }
+
+/** The small workspace interface shared renderer modules cross. */
+export type WorkspacePlatform = Pick<
+  MintPlatformApi,
+  | 'getWorkspaceSnapshot'
+  | 'getWorkspaceGitDiff'
+  | 'getGitBranchInfo'
+  | 'switchGitBranch'
+  | 'createGitBranch'
+  | 'checkoutRemoteGitBranch'
+  | 'getGitGraph'
+  | 'createWorkspaceFile'
+  | 'createWorkspaceFolder'
+  | 'deleteWorkspaceItem'
+  | 'moveWorkspaceItem'
+  | 'startHtmlPreview'
+  | 'listWorkspaceHistory'
+  | 'undoWorkspaceAction'
+>
+
+let workspaceAdapter: WorkspacePlatform | undefined
+type RuntimeOperation = (...args: any[]) => any
+export type RendererAdapter = MintPlatformApi & {
+  APP_ICON_PATH: string
+  resolveAvatarUrl: RuntimeOperation
+  fetchProviderModels: RuntimeOperation
+  fetchImageProviderModels: RuntimeOperation
+  fetchVideoProviderModels: RuntimeOperation
+  reauthMcpServer: RuntimeOperation
+  listMcpServerTools: RuntimeOperation
+  listCronJobs: RuntimeOperation
+  addCronJob: RuntimeOperation
+  removeCronJob: RuntimeOperation
+  setCronJobEnabled: RuntimeOperation
+  listLinkedFolders: RuntimeOperation
+  addLinkedFolder: RuntimeOperation
+  removeLinkedFolder: RuntimeOperation
+  linkedFolderStatus: RuntimeOperation
+  refreshLinkedFolder: RuntimeOperation
+  listLinkedFolderNotes: RuntimeOperation
+  readLinkedFolderNote: RuntimeOperation
+  openLinkedFolderNote: RuntimeOperation
+  startGeminiLiveSession: RuntimeOperation
+  sendGeminiLiveAudioChunk: RuntimeOperation
+  stopGeminiLiveSession: RuntimeOperation
+  generateVideo: RuntimeOperation
+  getVideoGenProviders: RuntimeOperation
+  convertFileSrc: RuntimeOperation
+  setActiveModel: RuntimeOperation
+  selectWorkspaceDirectory: RuntimeOperation
+  selectLinkedFolderPath: RuntimeOperation
+  isTauriRuntime: RuntimeOperation
+}
+let rendererAdapter: RendererAdapter | undefined
+
+/** Install the runtime implementation used by shared renderer modules. */
+export function installRendererPlatform(adapter: RendererAdapter): void {
+  rendererAdapter = adapter
+}
+
+function requireRendererPlatform(): RendererAdapter {
+  if (!rendererAdapter) throw new Error('Renderer platform adapter has not been installed.')
+  return rendererAdapter
+}
+
+function operation<Key extends keyof RendererAdapter>(name: Key): RendererAdapter[Key] {
+  return ((...args: any[]) => {
+    const implementation = requireRendererPlatform()[name]
+    if (typeof implementation !== 'function') throw new Error(`Platform operation is unavailable: ${name}`)
+    return (implementation as RuntimeOperation)(...args)
+  }) as RendererAdapter[Key]
+}
+
+/** Authentication and profile seam. */
+export const authPlatform = {
+  authRegister: operation('authRegister'), authLogin: operation('authLogin'),
+  authLogout: operation('authLogout'), authGetCurrentUser: operation('authGetCurrentUser'),
+  authUploadAvatar: operation('authUploadAvatar'), resolveAvatarUrl: operation('resolveAvatarUrl'),
+}
+
+/** Conversation transport, persistence, live voice, and checkpoint seam. */
+export const conversationPlatform = {
+  getConversationSources: operation('getConversationSources'), saveSourceAttachments: operation('saveSourceAttachments'),
+  clearChatHistory: operation('clearChatHistory'), deleteChatSession: operation('deleteChatSession'),
+  renameChatSession: operation('renameChatSession'), getRecentInteractions: operation('getRecentInteractions'),
+  getConversationSnapshot: operation('getConversationSnapshot'), getConversationChanges: operation('getConversationChanges'),
+  saveSystemInteraction: operation('saveSystemInteraction'), listChatSessions: operation('listChatSessions'),
+  updateChatSessionWorkspace: operation('updateChatSessionWorkspace'),
+  saveInteractionAgentActivity: operation('saveInteractionAgentActivity'), streamChatMessage: operation('streamChatMessage'),
+  cancelChatMessage: operation('cancelChatMessage'), submitToolApproval: operation('submitToolApproval'),
+  listen: operation('listen'), readClipboardImage: operation('readClipboardImage'), getTtsUrls: operation('getTtsUrls'),
+  startGeminiLiveSession: operation('startGeminiLiveSession'), sendGeminiLiveAudioChunk: operation('sendGeminiLiveAudioChunk'),
+  stopGeminiLiveSession: operation('stopGeminiLiveSession'), listGitCheckpoints: operation('listGitCheckpoints'),
+  rollbackGitCheckpoint: operation('rollbackGitCheckpoint'), undoGitCheckpoint: operation('undoGitCheckpoint'),
+}
+
+/** Models, skills, agents, MCP, schedules, linked folders, and slash commands. */
+export const catalogPlatform = {
+  fetchProviderModels: operation('fetchProviderModels'), listLearnedSkills: operation('listLearnedSkills'),
+  addLearnedSkill: operation('addLearnedSkill'), deleteLearnedSkill: operation('deleteLearnedSkill'),
+  detectSystemTools: operation('detectSystemTools'), listMcpServerTools: operation('listMcpServerTools'),
+  testMcpConnection: operation('testMcpConnection'), reauthMcpServer: operation('reauthMcpServer'),
+  listSubagents: operation('listSubagents'), saveSubagent: operation('saveSubagent'),
+  deleteSubagent: operation('deleteSubagent'), getProfileValue: operation('getProfileValue'),
+  setProfileValue: operation('setProfileValue'), listCronJobs: operation('listCronJobs'),
+  addCronJob: operation('addCronJob'), removeCronJob: operation('removeCronJob'),
+  setCronJobEnabled: operation('setCronJobEnabled'), listLinkedFolders: operation('listLinkedFolders'),
+  addLinkedFolder: operation('addLinkedFolder'), removeLinkedFolder: operation('removeLinkedFolder'),
+  linkedFolderStatus: operation('linkedFolderStatus'), refreshLinkedFolder: operation('refreshLinkedFolder'),
+  listLinkedFolderNotes: operation('listLinkedFolderNotes'), readLinkedFolderNote: operation('readLinkedFolderNote'),
+  openLinkedFolderNote: operation('openLinkedFolderNote'),
+  runSlashCommand: operation('runSlashCommand'),
+}
+
+/** Image and video generation and saved media seam. */
+export const mediaPlatform = {
+  readMcpArtifact: operation('readMcpArtifact'),
+  generateImages: operation('generateImages'), getImageGenProviders: operation('getImageGenProviders'),
+  fetchImageProviderModels: operation('fetchImageProviderModels'), listSavedPictures: operation('listSavedPictures'),
+  generateVideo: operation('generateVideo'), getVideoGenProviders: operation('getVideoGenProviders'),
+  fetchVideoProviderModels: operation('fetchVideoProviderModels'), convertFileSrc: operation('convertFileSrc'),
+}
+
+/** Runtime capabilities and native picker seam. */
+export const backgroundPlatform = {
+  list: operation("listBackgroundJobs"),
+  output: operation("getBackgroundJob"),
+  stop: operation("stopBackgroundJob"),
+  delete: operation("deleteBackgroundJob"),
+}
+
+export const runtimePlatform = {
+  appIconPath: () => String(requireRendererPlatform().APP_ICON_PATH ?? './assets/icon.png'),
+  getRuntimeStatus: operation('getRuntimeStatus'), setActiveModel: operation('setActiveModel'),
+  selectWorkspaceDirectory: operation('selectWorkspaceDirectory'), selectLinkedFolderPath: operation('selectLinkedFolderPath'),
+  isTauriRuntime: operation('isTauriRuntime'), readWorkspaceFile: operation('readWorkspaceFile'),
+}
+
+/** Install the Desktop or Web adapter before rendering the application. */
+export function installWorkspacePlatform(adapter: WorkspacePlatform): void {
+  workspaceAdapter = adapter
+}
+
+function requireWorkspacePlatform(): WorkspacePlatform {
+  if (!workspaceAdapter) {
+    throw new Error('Workspace platform adapter has not been installed.')
+  }
+  return workspaceAdapter
+}
+
+/** One seam for workspace and Git behavior used by shared renderer modules. */
+export const workspacePlatform: WorkspacePlatform = {
+  getWorkspaceSnapshot: (...args) => requireWorkspacePlatform().getWorkspaceSnapshot(...args),
+  getWorkspaceGitDiff: (...args) => requireWorkspacePlatform().getWorkspaceGitDiff(...args),
+  getGitBranchInfo: (...args) => requireWorkspacePlatform().getGitBranchInfo(...args),
+  switchGitBranch: (...args) => requireWorkspacePlatform().switchGitBranch(...args),
+  createGitBranch: (...args) => requireWorkspacePlatform().createGitBranch(...args),
+  checkoutRemoteGitBranch: (...args) => requireWorkspacePlatform().checkoutRemoteGitBranch(...args),
+  getGitGraph: (...args) => requireWorkspacePlatform().getGitGraph(...args),
+  createWorkspaceFile: (...args) => requireWorkspacePlatform().createWorkspaceFile(...args),
+  createWorkspaceFolder: (...args) => requireWorkspacePlatform().createWorkspaceFolder(...args),
+  deleteWorkspaceItem: (...args) => requireWorkspacePlatform().deleteWorkspaceItem(...args),
+  moveWorkspaceItem: (...args) => requireWorkspacePlatform().moveWorkspaceItem(...args),
+  startHtmlPreview: (...args) => requireWorkspacePlatform().startHtmlPreview(...args),
+  listWorkspaceHistory: (...args) => requireWorkspacePlatform().listWorkspaceHistory(...args),
+  undoWorkspaceAction: (...args) => requireWorkspacePlatform().undoWorkspaceAction(...args),
+}
+
+export const modsPlatform = { operation: operation("modsOperation") }
+
+export const libraryPlatform: Pick<MintPlatformApi, 'listLibrary' | 'getLibraryItem' | 'setLibraryTrashed' | 'removeLibraryItem' | 'readLibraryFile'> = {
+ listLibrary: operation('listLibrary'), getLibraryItem: operation('getLibraryItem'),
+ removeLibraryItem: operation('removeLibraryItem'), setLibraryTrashed: operation('setLibraryTrashed'), readLibraryFile: operation('readLibraryFile'),
+}