@bibobonking/opensol 0.0.0-stage → 3.0.2

package/src/plugins/runtime.ts

@@ -0,0 +1,194 @@
+import type { InstalledPlugin } from '../lib/daemon'
+import { getInstalledPluginArchive } from '../lib/daemon'
+import type { PluginContribution } from './types'
+import { registerTheme, unregisterTheme } from '../lib/themes'
+import { createPluginApi, emptyContributions, type PluginHostCalls } from './api'
+import { readPluginArchive } from '../../shared/plugin-package.mjs'
+import { kernel } from '../core/kernel'
+import type { Context } from 'cordis'
+
+const STYLE_ID = (id: string) => `maxcode-plugin-style-${id}`
+
+export const PLUGIN_THEME_PREFIX = 'plugin-'
+
+function tokens(palette: Record<string, string>): Array<[string, string]> {
+  return Object.entries(palette).filter(
+    ([token, value]) => /^[a-z][a-z0-9-]*$/.test(token) && /^[\d\s.]+$/.test(value),
+  )
+}
+
+function isDarkPalette(palette: Record<string, string>): boolean {
+  const canvas = (palette.canvas ?? '').trim().split(/\s+/).map(Number)
+  const [r, g, b] = canvas.length === 3 ? canvas : [255, 255, 255]
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b < 110
+}
+
+/** Plugin theme palettes become `[data-theme='<id>']` custom properties. */
+export function themeCss(themeId: string, palette: Record<string, string>): string {
+  const entries = tokens(palette).map(([token, value]) => `--${token}:${value.trim()}`)
+  return entries.length === 0 ? '' : `[data-theme='${themeId}']{${entries.join(';')}}`
+}
+
+export function styleElement(id: string): HTMLStyleElement | null {
+  return document.getElementById(STYLE_ID(id)) as HTMLStyleElement | null
+}
+
+export function applyStyles(id: string, css: string) {
+  let node = styleElement(id)
+  if (!node) {
+    node = document.createElement('style')
+    node.id = STYLE_ID(id)
+    document.head.append(node)
+  }
+  node.textContent = css
+}
+
+export function removeStyles(id: string) {
+  styleElement(id)?.remove()
+}
+
+export interface PluginRuntime {
+  contributions: Map<string, PluginContribution>
+  themes(): Array<{ id: string; label: string }>
+  contributionsFor(id: string): PluginContribution
+  commands(): Array<{ pluginId: string; id: string; label: string; run: () => void }>
+  activate(plugin: InstalledPlugin, calls: PluginHostCalls): Promise<void>
+  deactivate(id: string): void
+  deactivateAll(): void
+}
+
+interface PluginGlobals {
+  __maxcodePluginApi?: unknown
+}
+
+async function runPluginSource(source: string, api: unknown): Promise<void> {
+  const scoped = globalThis as typeof globalThis & PluginGlobals
+  const url = URL.createObjectURL(
+    new Blob([`const maxcode = globalThis.__maxcodePluginApi;\n${source}\n`], { type: 'text/javascript' }),
+  )
+  scoped.__maxcodePluginApi = api
+  try {
+    await import(/* @vite-ignore */ url)
+  } finally {
+    delete scoped.__maxcodePluginApi
+    URL.revokeObjectURL(url)
+  }
+}
+
+/**
+ * Same-realm execution for plugins the user marked Safe.
+ *
+ * **apiVersion 1** (legacy): plugin receives a restricted `PluginRuntimeApi`.
+ *
+ * **apiVersion 2** (free): plugin receives a Cordis child `Context` — full access
+ * to all kernel services: `ctx.tools.register()`, `ctx.ui.registerCommand()`,
+ * `ctx.on('agent/request', ...)`, `ctx.sessions`, `ctx.llm`, etc.
+ * The child scope is registered as a Cordis plugin (`kernel.plugin(fn)`).
+ * On deactivate, `fiber.dispose()` auto-cleans every hook and registration.
+ * The original source files on disk are never modified.
+ */
+export function createPluginRuntime(): PluginRuntime {
+  // v1 legacy: manual contribution tracking
+  const contributions = new Map<string, PluginContribution>()
+  // v2 free: Cordis fiber per plugin (dispose = full cleanup)
+  const fibers = new Map<string, { dispose(): Promise<void> }>()
+
+  const deactivate = (id: string) => {
+    // v2 cleanup
+    const fiber = fibers.get(id)
+    if (fiber) {
+      fibers.delete(id)
+      void fiber.dispose()
+    }
+
+    // v1 cleanup
+    const entry = contributions.get(id)
+    if (entry) for (const theme of entry.themes.keys()) unregisterTheme(`${PLUGIN_THEME_PREFIX}${id}:${theme}`)
+    contributions.delete(id)
+
+    removeStyles(id)
+  }
+
+  return {
+    contributions,
+    contributionsFor: (id) => contributions.get(id) ?? emptyContributions(),
+    themes() {
+      const out: Array<{ id: string; label: string }> = []
+      for (const [pluginId, entry] of contributions) {
+        for (const [id, theme] of entry.themes) {
+          out.push({ id: `${PLUGIN_THEME_PREFIX}${pluginId}:${id}`, label: theme.label })
+        }
+      }
+      return out
+    },
+    commands() {
+      const out: Array<{ pluginId: string; id: string; label: string; run: () => void }> = []
+      for (const [pluginId, entry] of contributions) {
+        for (const [id, command] of entry.commands) out.push({ pluginId, id, label: command.label, run: command.run })
+      }
+      return out
+    },
+    async activate(plugin, calls) {
+      deactivate(plugin.id)
+      if (!plugin.safe || !plugin.enabled) return
+
+      const { files, manifest } = readPluginArchive(await getInstalledPluginArchive(plugin.id))
+
+      if (manifest.apiVersion === 2) {
+        // Free plugin: load as a Cordis plugin function so the child ctx is
+        // scoped and fiber.dispose() auto-removes all hooks/registrations.
+        let resolve!: () => void
+        let reject!: (e: unknown) => void
+        const ready = new Promise<void>((res, rej) => { resolve = res; reject = rej })
+
+        const pluginFn = async (ctx: Context) => {
+          // Apply stylesheet (DOM side-effect — cleaned up via removeStyles in deactivate)
+          const css = files[manifest.stylesheet] ?? ''
+          if (css) applyStyles(plugin.id, css)
+
+          try {
+            await runPluginSource(files[manifest.entry] ?? '', ctx)
+            resolve()
+          } catch (error) {
+            reject(error)
+          }
+        }
+
+        const fiber = kernel.plugin(pluginFn)
+        fibers.set(plugin.id, fiber)
+
+        try {
+          await ready
+        } catch (error) {
+          deactivate(plugin.id)
+          throw new Error(`Plugin ${plugin.id} failed to start: ${error instanceof Error ? error.message : String(error)}`)
+        }
+      } else {
+        // Legacy v1: restricted API
+        const entry = contributions.get(plugin.id) ?? emptyContributions()
+        contributions.set(plugin.id, entry)
+
+        const api = createPluginApi(plugin, plugin.grants, calls, entry)
+        try {
+          await runPluginSource(files[manifest.entry] ?? '', Object.freeze(api))
+          const themes = [...entry.themes.entries()]
+            .map(([id, theme]) => {
+              const themeId = `${PLUGIN_THEME_PREFIX}${plugin.id}:${id}`
+              registerTheme({ id: themeId, label: theme.label, dark: isDarkPalette(theme.palette) })
+              return themeCss(themeId, theme.palette)
+            })
+            .join('\n')
+          applyStyles(plugin.id, `${files[manifest.stylesheet] ?? ''}\n${themes}`)
+        } catch (error) {
+          deactivate(plugin.id)
+          throw new Error(`Plugin ${plugin.id} failed to start: ${error instanceof Error ? error.message : String(error)}`)
+        }
+      }
+    },
+    deactivate,
+    deactivateAll() {
+      const ids = [...new Set([...contributions.keys(), ...fibers.keys()])]
+      for (const id of ids) deactivate(id)
+    },
+  }
+}

package/src/plugins/types.ts

@@ -0,0 +1,40 @@
+import type { InstalledPlugin } from '../lib/daemon'
+import type { PluginCapability, PluginManifest } from '../../shared/plugin-package.mjs'
+
+export type { PluginCapability, PluginManifest }
+
+export interface PluginGrant {
+  capabilities: PluginCapability[]
+  domains: string[]
+}
+
+export interface PluginRuntimeApi {
+  /** Declared identity of the running plugin. */
+  manifest: Readonly<PluginManifest>
+  version: number
+  registerCommand(id: string, label: string, run: () => void): void
+  registerPanel(id: string, label: string, render: (host: HTMLElement) => void): void
+  registerTheme(id: string, label: string, palette: Record<string, string>): void
+  workspace: {
+    list(path?: string): Promise<{ path: string; name: string; type: string }[]>
+    read(path: string): Promise<string>
+    write(path: string, content: string): Promise<void>
+    edit(path: string, from: string, to: string): Promise<boolean>
+  }
+  network: {
+    request(url: string, init?: { method?: 'GET' | 'POST'; headers?: Record<string, string>; body?: string }): Promise<{
+      status: number
+      contentType: string
+      body: string
+    }>
+  }
+  log(message: string): void
+}
+
+export interface PluginContribution {
+  commands: Map<string, { label: string; run: () => void }>
+  panels: Map<string, { label: string; render: (host: HTMLElement) => void }>
+  themes: Map<string, { label: string; palette: Record<string, string> }>
+}
+
+export type { InstalledPlugin }

package/src/store/chats.ts

@@ -0,0 +1,278 @@
+import { create } from 'zustand'
+import type { AgentMode, ChatSession, Message, ProviderId } from '../types'
+import { csrfToken, saveChats } from '../lib/daemon'
+
+function createId(prefix: string) {
+  const raw =
+    typeof crypto !== 'undefined' && 'randomUUID' in crypto
+      ? crypto.randomUUID()
+      : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 9)}`
+  return `${prefix}_${raw}`
+}
+
+export { createId }
+
+function isSession(value: unknown): value is ChatSession {
+  if (!value || typeof value !== 'object') return false
+  const session = value as ChatSession
+  return typeof session.id === 'string' && typeof session.title === 'string' && Array.isArray(session.messages)
+}
+
+function normalizeSession(session: ChatSession): ChatSession {
+  let round = 0
+  const messages = session.messages
+    .filter((message): message is Message => Boolean(message && typeof message === 'object'))
+    .map((message, index) => {
+      if (message.role === 'user') {
+        if (index > 0) round += 1
+        return message
+      }
+      const existing = typeof message.round === 'number' ? message.round : round
+      if (message.role === 'assistant') {
+        return {
+          ...message,
+          content: typeof message.content === 'string' ? message.content : '',
+          reasoning: typeof message.reasoning === 'string' ? message.reasoning : '',
+          toolCalls: Array.isArray(message.toolCalls) ? message.toolCalls : [],
+          round: existing,
+        }
+      }
+      return { ...message, round: existing }
+    })
+  return {
+    ...session,
+    title: session.title.trim() || 'New conversation',
+    messages,
+    createdAt: typeof session.createdAt === 'number' ? session.createdAt : Date.now(),
+    updatedAt: typeof session.updatedAt === 'number' ? session.updatedAt : Date.now(),
+    mode: session.mode === 'plan' ? 'plan' : session.mode === 'build' ? 'build' : undefined,
+  }
+}
+
+interface PersistedChats {
+  sessions: ChatSession[]
+  activeId: string | null
+}
+
+interface ChatsState {
+  sessions: ChatSession[]
+  activeId: string | null
+  hydrated: boolean
+  hydrate: (payload: PersistedChats) => void
+  setActive: (id: string | null) => void
+  newChat: () => void
+  createSession: (provider: ProviderId, model: string, mode?: AgentMode) => string
+  addMessage: (sessionId: string, message: Message) => void
+  updateMessage: (
+    sessionId: string,
+    messageId: string,
+    patch: Partial<Message> | ((message: Message) => Partial<Message>),
+  ) => void
+  updateSession: (sessionId: string, patch: Partial<ChatSession>) => void
+  renameSession: (sessionId: string, title: string) => void
+  deleteSession: (sessionId: string) => void
+  clearAll: () => void
+  persistNow: () => Promise<void>
+}
+
+function titleFromText(text: string) {
+  const clean = text.replace(/\s+/g, ' ').trim()
+  if (!clean) return 'New conversation'
+  return clean.length > 56 ? `${clean.slice(0, 56).trim()}…` : clean
+}
+
+export const useChats = create<ChatsState>()((set, get) => ({
+  sessions: [],
+  activeId: null,
+  hydrated: false,
+  hydrate: (payload) => {
+    const sessions = (payload.sessions ?? [])
+      .filter(isSession)
+      .map(normalizeSession)
+      .sort((a, b) => b.updatedAt - a.updatedAt)
+    const activeId =
+      typeof payload.activeId === 'string' && sessions.some((session) => session.id === payload.activeId)
+        ? payload.activeId
+        : sessions[0]?.id ?? null
+    set({ sessions, activeId, hydrated: true })
+  },
+  setActive: (id) => set({ activeId: id }),
+  newChat: () => set({ activeId: null }),
+  createSession: (provider, model, mode) => {
+    const id = createId('chat')
+    const now = Date.now()
+    const session: ChatSession = {
+      id,
+      title: 'New conversation',
+      createdAt: now,
+      updatedAt: now,
+      messages: [],
+      provider,
+      model,
+      mode,
+    }
+    set((state) => ({ sessions: [session, ...state.sessions], activeId: id }))
+    return id
+  },
+  addMessage: (sessionId, message) => {
+    set((state) => ({
+      sessions: state.sessions.map((session) => {
+        if (session.id !== sessionId) return session
+        const patch: Partial<ChatSession> = {
+          messages: [...session.messages, message],
+          updatedAt: Date.now(),
+        }
+        if (message.role === 'user' && session.messages.length === 0) {
+          patch.title = titleFromText(message.content)
+        }
+        return { ...session, ...patch }
+      }),
+    }))
+  },
+  updateMessage: (sessionId, messageId, patch) => {
+    set((state) => ({
+      sessions: state.sessions.map((session) => {
+        if (session.id !== sessionId) return session
+        let changed = false
+        const messages = session.messages.map((message) => {
+          if (message.id !== messageId) return message
+          const next = typeof patch === 'function' ? patch(message) : patch
+          if (!next || Object.keys(next).length === 0) return message
+          changed = true
+          return { ...message, ...next } as Message
+        })
+        return changed ? { ...session, messages, updatedAt: Date.now() } : session
+      }),
+    }))
+  },
+  updateSession: (sessionId, patch) => {
+    set((state) => ({
+      sessions: state.sessions.map((session) =>
+        session.id === sessionId ? { ...session, ...patch, updatedAt: Date.now() } : session,
+      ),
+    }))
+  },
+  renameSession: (sessionId, title) => {
+    const clean = title.trim()
+    if (!clean) return
+    get().updateSession(sessionId, { title: clean })
+  },
+  deleteSession: (sessionId) => {
+    set((state) => {
+      const sessions = state.sessions.filter((session) => session.id !== sessionId)
+      return {
+        sessions,
+        activeId: state.activeId === sessionId ? sessions[0]?.id ?? null : state.activeId,
+      }
+    })
+  },
+  clearAll: () => set({ sessions: [], activeId: null }),
+  persistNow: async () => {
+    const { sessions, activeId } = get()
+    await saveChats({ sessions, activeId })
+  },
+}))
+
+let persistenceEnabled = false
+let saveTimer: number | undefined
+let maxTimer: number | undefined
+
+export function enableChatPersistence() {
+  persistenceEnabled = true
+}
+
+function scheduleSave() {
+  if (!persistenceEnabled || typeof window === 'undefined') return
+  if (saveTimer !== undefined) window.clearTimeout(saveTimer)
+  saveTimer = window.setTimeout(() => {
+    saveTimer = undefined
+    void persistChats()
+  }, 900)
+  if (maxTimer === undefined) {
+    maxTimer = window.setTimeout(() => {
+      maxTimer = undefined
+      void persistChats()
+    }, 6000)
+  }
+}
+
+async function persistChats() {
+  if (!persistenceEnabled) return
+  if (saveTimer !== undefined) {
+    window.clearTimeout(saveTimer)
+    saveTimer = undefined
+  }
+  if (maxTimer !== undefined) {
+    window.clearTimeout(maxTimer)
+    maxTimer = undefined
+  }
+  const { sessions, activeId } = useChats.getState()
+  try {
+    await saveChats({ sessions, activeId })
+  } catch (error) {
+    window.dispatchEvent(
+      new CustomEvent('maxcode:notice', {
+        detail: {
+          message: error instanceof Error ? error.message : 'Could not save conversations to the local daemon.',
+          tone: 'error',
+        },
+      }),
+    )
+  }
+}
+
+useChats.subscribe(scheduleSave)
+
+if (typeof window !== 'undefined') {
+  const unload = () => {
+    if (!persistenceEnabled) return
+    const { sessions, activeId } = useChats.getState()
+    try {
+      const body = JSON.stringify({ sessions, activeId })
+      // Browsers cap keepalive bodies at 64 KB; a bigger one would be rejected, so rely on the debounced saves.
+      if (body.length > 60_000) return
+      void fetch('/api/chats', {
+        method: 'PUT',
+        keepalive: true,
+        headers: { 'Content-Type': 'application/json', 'x-maxcode-csrf': csrfToken() },
+        body,
+      }).catch(() => undefined)
+    } catch {
+      // The daemon will keep the last saved snapshot.
+    }
+  }
+  window.addEventListener('beforeunload', unload)
+  document.addEventListener('visibilitychange', () => {
+    if (document.visibilityState === 'hidden') unload()
+  })
+}
+
+export function exportChats() {
+  const data = useChats.getState().sessions
+  const blob = new Blob(
+    [JSON.stringify({ app: 'OpenSol', exportedAt: new Date().toISOString(), sessions: data }, null, 2)],
+    { type: 'application/json' },
+  )
+  const url = URL.createObjectURL(blob)
+  const anchor = document.createElement('a')
+  anchor.href = url
+  anchor.download = `maxcode-history-${new Date().toISOString().slice(0, 10)}.json`
+  anchor.click()
+  URL.revokeObjectURL(url)
+}
+
+export function importChats(file: File): Promise<number> {
+  return file.text().then((text) => {
+    const parsed = JSON.parse(text) as { sessions?: unknown[] }
+    if (!Array.isArray(parsed.sessions)) throw new Error('This file does not contain a OpenSol history.')
+    const sessions = parsed.sessions.filter(isSession).map(normalizeSession)
+    if (sessions.length === 0) throw new Error('No valid conversations were found in this file.')
+    const existing = new Set(useChats.getState().sessions.map((session) => session.id))
+    const added = sessions.filter((session) => !existing.has(session.id))
+    useChats.setState((state) => ({
+      sessions: [...added, ...state.sessions],
+      activeId: added[0]?.id ?? state.activeId,
+    }))
+    return added.length
+  })
+}

package/src/store/models.ts

@@ -0,0 +1,120 @@
+import { useEffect } from 'react'
+import { create } from 'zustand'
+import type { ApiKind, ModelInfo, ProviderId } from '../types'
+import { PROVIDER_MAP } from '../data/providers'
+import { fetchModels as fetchModelsFromDaemon } from '../lib/daemon'
+import { activeModelId, hasCredentials, useSettings } from './settings'
+
+const NO_MODELS: ModelInfo[] = []
+const STALE_MS = 10 * 60 * 1000
+
+interface ModelCatalogState {
+  byProvider: Record<string, ModelInfo[]>
+  loading: Record<string, boolean>
+  errors: Record<string, string>
+  notes: Record<string, string>
+  source: Record<string, 'live' | 'catalog' | ''>
+  fetchedAt: Record<string, number>
+  fetchModels: (provider: ProviderId, force?: boolean) => Promise<ModelInfo[]>
+}
+
+export const useModelCatalog = create<ModelCatalogState>()((set, get) => ({
+  byProvider: {},
+  loading: {},
+  errors: {},
+  notes: {},
+  source: {},
+  fetchedAt: {},
+  fetchModels: async (provider, force = false) => {
+    if (get().loading[provider]) return get().byProvider[provider] ?? NO_MODELS
+    if (!force) {
+      const existing = get().byProvider[provider] ?? NO_MODELS
+      const fetchedAt = get().fetchedAt[provider] ?? 0
+      if (existing.length > 0 && Date.now() - fetchedAt < STALE_MS) return existing
+    }
+    set((state) => ({
+      loading: { ...state.loading, [provider]: true },
+      errors: { ...state.errors, [provider]: '' },
+    }))
+    try {
+      const result = await fetchModelsFromDaemon(provider)
+      set((state) => ({
+        byProvider: { ...state.byProvider, [provider]: result.models },
+        loading: { ...state.loading, [provider]: false },
+        errors: { ...state.errors, [provider]: '' },
+        notes: { ...state.notes, [provider]: result.note || result.catalogError || '' },
+        source: { ...state.source, [provider]: result.source },
+        fetchedAt: { ...state.fetchedAt, [provider]: result.fetchedAt || Date.now() },
+      }))
+      return result.models
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Could not load models from this provider.'
+      set((state) => ({
+        loading: { ...state.loading, [provider]: false },
+        errors: { ...state.errors, [provider]: message },
+        source: { ...state.source, [provider]: '' },
+      }))
+      return get().byProvider[provider] ?? NO_MODELS
+    }
+  },
+}))
+
+export function useProviderModels(provider: ProviderId): ModelInfo[] {
+  return useModelCatalog((state) => state.byProvider[provider]) ?? NO_MODELS
+}
+
+export function useActiveModel(): ModelInfo | null {
+  const provider = useSettings((state) => state.provider)
+  const model = useSettings((state) => state.model)
+  return useModelCatalog((state) => {
+    if (!model) return null
+    return state.byProvider[provider]?.find((entry) => entry.id === model) ?? null
+  })
+}
+
+export function findModel(provider: ProviderId, modelId: string): ModelInfo | null {
+  if (!modelId) return null
+  return useModelCatalog.getState().byProvider[provider]?.find((entry) => entry.id === modelId) ?? null
+}
+
+export function useModelSync() {
+  const hydrated = useSettings((state) => state.hydrated)
+  const provider = useSettings((state) => state.provider)
+
+  useEffect(() => {
+    if (!hydrated) return
+    const settings = useSettings.getState()
+    if (!hasCredentials(settings)) return
+    const state = useModelCatalog.getState()
+    const models = state.byProvider[provider] ?? NO_MODELS
+    const fetchedAt = state.fetchedAt[provider] ?? 0
+    if (models.length > 0 && Date.now() - fetchedAt < STALE_MS) return
+    void state.fetchModels(provider)
+  }, [hydrated, provider])
+}
+
+/**
+ * The transport a model needs. Live model metadata wins; manual IDs fall back
+ * to the provider family, with OpenCode inferred from the model id.
+ */
+export function apiKindFor(provider: ProviderId, modelId: string, model?: ModelInfo | null): ApiKind {
+  if (model?.apiKind) return model.apiKind
+  const preset = PROVIDER_MAP[provider]
+  if (provider !== 'opencode') {
+    if (preset?.format === 'anthropic') return 'anthropic'
+    if (preset?.format === 'gemini') return 'gemini'
+    return 'openai-chat'
+  }
+  const id = modelId.toLowerCase()
+  if (/gemini|gemma/.test(id)) return 'gemini'
+  if (/claude|qwen.*(flash|plus)/.test(id)) return 'anthropic'
+  if (/gpt|grok|muse|codex/.test(id)) return 'openai-responses'
+  return 'openai-chat'
+}
+
+export function activeModelInfo(): ModelInfo | null {
+  const settings = useSettings.getState()
+  return findModel(settings.provider, activeModelId(settings))
+}
+
+export { NO_MODELS }