@bibobonking/opensol 0.0.0-stage → 3.0.1

package/src/lib/daemon.ts

@@ -0,0 +1,475 @@
+import type {
+  AgentMode,
+  AppSettings,
+  ChatSession,
+  DaemonSnapshot,
+  DeployEvent,
+  DeployProviderId,
+  DeployRequest,
+  DeployResult,
+  ModelInfo,
+  ProviderId,
+  ProviderStatus,
+  SecretsSummary,
+  WorkspaceFile,
+  WorkspaceInfo,
+} from '../types'
+import type { PluginManifest, PluginCapability } from '../../shared/plugin-package.mjs'
+
+export interface InstalledPlugin {
+  id: string
+  manifest: PluginManifest
+  manifestHash: string
+  installedAt: string
+  safe: boolean
+  enabled: boolean
+  grants: { capabilities: PluginCapability[]; domains: string[] }
+}
+
+export class DaemonError extends Error {
+  status: number
+  code: string
+
+  constructor(message: string, status = 0, code = 'daemon_error') {
+    super(message)
+    this.name = 'DaemonError'
+    this.status = status
+    this.code = code
+  }
+}
+
+let csrf = ''
+let sessionPromise: Promise<void> | null = null
+
+export function csrfToken() {
+  return csrf
+}
+
+async function parseError(response: Response): Promise<DaemonError> {
+  const raw = await response.text().catch(() => '')
+  if (raw) {
+    try {
+      const parsed = JSON.parse(raw) as { error?: { message?: string; code?: string; status?: number } }
+      if (parsed.error?.message) {
+        return new DaemonError(
+          parsed.error.message,
+          parsed.error.status ?? response.status,
+          parsed.error.code ?? 'daemon_error',
+        )
+      }
+    } catch {
+      // Fall through to the raw response.
+    }
+  }
+  return new DaemonError(
+    raw.trim().slice(0, 400) || `The local daemon returned ${response.status}.`,
+    response.status,
+    'daemon_error',
+  )
+}
+
+export async function ensureSession(force = false): Promise<void> {
+  if (sessionPromise && !force) return sessionPromise
+  sessionPromise = (async () => {
+    let response: Response
+    try {
+      response = await fetch('/api/session', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'same-origin',
+      })
+    } catch {
+      throw new DaemonError(
+        'OpenSol’s local daemon is not reachable. Start it with “npm start” in the OpenSol folder, then reload this page.',
+        0,
+        'daemon_unreachable',
+      )
+    }
+    if (!response.ok) throw await parseError(response)
+    const data = (await response.json()) as { csrf?: string }
+    csrf = typeof data.csrf === 'string' ? data.csrf : ''
+  })().catch((error) => {
+    sessionPromise = null
+    throw error
+  })
+  return sessionPromise
+}
+
+export async function api<T>(path: string, init: RequestInit = {}, retry = true): Promise<T> {
+  await ensureSession()
+  const method = (init.method ?? 'GET').toUpperCase()
+  const headers = new Headers(init.headers)
+  if (init.body && !headers.has('Content-Type')) headers.set('Content-Type', 'application/json')
+  if (!['GET', 'HEAD'].includes(method)) headers.set('x-maxcode-csrf', csrf)
+  let response: Response
+  try {
+    response = await fetch(path, { ...init, method, headers, credentials: 'same-origin' })
+  } catch {
+    throw new DaemonError(
+      'Lost the connection to the local daemon. Check that it is still running.',
+      0,
+      'daemon_unreachable',
+    )
+  }
+  if (response.status === 401 && retry) {
+    await ensureSession(true)
+    return api<T>(path, init, false)
+  }
+  if (!response.ok) throw await parseError(response)
+  if (response.status === 204) return undefined as T
+  const type = response.headers.get('content-type') ?? ''
+  if (!type.includes('application/json')) return (await response.text()) as T
+  return (await response.json()) as T
+}
+
+function jsonBody(value: unknown): RequestInit {
+  return { method: 'POST', body: JSON.stringify(value) }
+}
+
+export function getState(): Promise<DaemonSnapshot> {
+  return api<DaemonSnapshot>('/api/state')
+}
+
+export function getHealth(): Promise<{ ok: boolean; pid: number; port: number; dist: boolean }> {
+  return api('/api/health')
+}
+
+export function listInstalledPlugins(): Promise<{ plugins: InstalledPlugin[] }> {
+  return api('/api/plugins')
+}
+
+function base64ToBytes(value: string): Uint8Array {
+  const binary = atob(value)
+  const bytes = new Uint8Array(binary.length)
+  for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index)
+  return bytes
+}
+
+export async function getInstalledPluginArchive(id: string): Promise<Uint8Array> {
+  const result = await api<{ archive: string }>(`/api/plugins/${encodeURIComponent(id)}/package`)
+  return base64ToBytes(result.archive)
+}
+
+function bytesToBase64(bytes: Uint8Array): string {
+  let binary = ''
+  for (let offset = 0; offset < bytes.length; offset += 0x8000) {
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + 0x8000))
+  }
+  return btoa(binary)
+}
+
+export function installPluginArchive(archive: Uint8Array): Promise<{ plugin: InstalledPlugin }> {
+  return api('/api/plugins', {
+    method: 'POST',
+    body: JSON.stringify({ archive: bytesToBase64(archive) }),
+  })
+}
+
+export function savePluginGrants(
+  id: string,
+  grants: { capabilities: PluginCapability[]; domains: string[] },
+): Promise<{ plugin: InstalledPlugin }> {
+  return api(`/api/plugins/${encodeURIComponent(id)}/grants`, {
+    method: 'PUT',
+    body: JSON.stringify(grants),
+  })
+}
+
+export function setPluginTrust(id: string, safe: boolean): Promise<{ plugin: InstalledPlugin }> {
+  return api(`/api/plugins/${encodeURIComponent(id)}/safe`, {
+    method: 'PUT',
+    body: JSON.stringify({ safe }),
+  })
+}
+
+export function setPluginActivation(id: string, enabled: boolean): Promise<{ plugin: InstalledPlugin }> {
+  return api(`/api/plugins/${encodeURIComponent(id)}/enabled`, {
+    method: 'PUT',
+    body: JSON.stringify({ enabled }),
+  })
+}
+
+export function removeInstalledPlugin(id: string): Promise<{ id: string; removed: boolean }> {
+  return api(`/api/plugins/${encodeURIComponent(id)}`, { method: 'DELETE' })
+}
+
+export function pluginNetworkRequest(id: string, request: {
+  url: string
+  method?: 'GET' | 'POST'
+  headers?: Record<string, string>
+  body?: string
+}): Promise<{ status: number; contentType: string; body: string }> {
+  return api(`/api/plugins/${encodeURIComponent(id)}/network`, {
+    method: 'POST',
+    body: JSON.stringify(request),
+  })
+}
+
+export function patchSettings(patch: Partial<AppSettings>): Promise<{ settings: AppSettings }> {
+  return api('/api/settings', { method: 'PATCH', body: JSON.stringify(patch) })
+}
+
+export function saveChats(chats: { sessions: ChatSession[]; activeId: string | null }) {
+  return api<{ sessions: number; activeId: string | null }>('/api/chats', {
+    method: 'PUT',
+    body: JSON.stringify(chats),
+  })
+}
+
+export function migrateLegacy(payload: { settings?: unknown; chats?: unknown }) {
+  return api<{
+    migratedSettings: boolean
+    migratedChats: number
+    migratedSecrets: boolean
+    state: DaemonSnapshot
+  }>('/api/migrate', jsonBody(payload))
+}
+
+export function listProviders(): Promise<{ providers: ProviderStatus[] }> {
+  return api('/api/providers')
+}
+
+export function fetchModels(provider: ProviderId) {
+  return api<{
+    provider: ProviderId
+    models: ModelInfo[]
+    source: 'live' | 'catalog'
+    fetchedAt: number
+    note: string
+    catalogError: string
+  }>(`/api/models?provider=${encodeURIComponent(provider)}`)
+}
+
+export function setProviderKey(provider: ProviderId, apiKey: string) {
+  if (!apiKey) return api<{ configured: boolean; hint: string }>(`/api/providers/${provider}/key`, { method: 'DELETE' })
+  return api<{ configured: boolean; hint: string }>(`/api/providers/${provider}/key`, {
+    method: 'PUT',
+    body: JSON.stringify({ apiKey }),
+  })
+}
+
+export function setSearchKey(apiKey: string) {
+  return api<{ configured: boolean; hint: string }>('/api/search/key', {
+    method: 'PUT',
+    body: JSON.stringify({ apiKey }),
+  })
+}
+
+export function setDeployCredentials(provider: DeployProviderId, fields: Record<string, string>) {
+  return api(`/api/deploy/credentials/${provider}`, {
+    method: 'PUT',
+    body: JSON.stringify(fields),
+  })
+}
+
+export function resetScope(scope: 'history' | 'secrets' | 'settings' | 'all'): Promise<DaemonSnapshot> {
+  return api('/api/reset', jsonBody({ scope }))
+}
+
+export function addWorkspace(path: string): Promise<{ workspace: WorkspaceInfo; entry: { path: string; name: string } }> {
+  return api('/api/workspaces', jsonBody({ path }))
+}
+
+export function forgetWorkspace(): Promise<WorkspaceInfo> {
+  return api('/api/workspaces', { method: 'DELETE' })
+}
+
+export function browseFolders(path: string) {
+  return api<{ path: string; parent: string; home: string; entries: Array<{ name: string; path: string }> }>(
+    `/api/workspaces/browse?path=${encodeURIComponent(path)}`,
+  )
+}
+
+export function getWorkspaceTree(path = '', depth = 6) {
+  return api<{
+    root: string
+    path: string
+    entries: Array<{ name: string; path: string; type: 'file' | 'dir' | 'link'; size: number; mtime: number }>
+    truncated: boolean
+    workspace: WorkspaceInfo
+  }>(`/api/workspace/tree?depth=${depth}&path=${encodeURIComponent(path)}`)
+}
+
+export function readWorkspaceFile(path: string): Promise<WorkspaceFile> {
+  return api(`/api/workspace/file?path=${encodeURIComponent(path)}`)
+}
+
+export function writeWorkspaceFile(path: string, content: string) {
+  return api<{ path: string; size: number; mtime: number; created: boolean; hash: string }>(
+    '/api/workspace/file',
+    { method: 'PUT', body: JSON.stringify({ path, content }) },
+  )
+}
+
+export function createWorkspaceEntry(path: string, type: 'file' | 'dir') {
+  return api<{ path: string; type: 'file' | 'dir' }>('/api/workspace/file', {
+    method: 'POST',
+    body: JSON.stringify({ action: 'create', path, type }),
+  })
+}
+
+export function renameWorkspaceEntry(from: string, to: string) {
+  return api<{ from: string; to: string }>('/api/workspace/file', {
+    method: 'POST',
+    body: JSON.stringify({ action: 'rename', from, to }),
+  })
+}
+
+export function deleteWorkspaceEntry(path: string) {
+  return api<{ path: string; type: 'file' | 'dir' }>('/api/workspace/file', {
+    method: 'POST',
+    body: JSON.stringify({ action: 'delete', path }),
+  })
+}
+
+export function gitSummary() {
+  return api<{
+    available: boolean
+    root: string
+    branch: string
+    entries: Array<{ status: string; path: string }>
+    error: string
+  }>('/api/git')
+}
+
+export interface DaemonToolResult {
+  name: string
+  result: unknown
+}
+
+export function executeDaemonTool(
+  name: string,
+  args: Record<string, unknown>,
+  mode: AgentMode,
+  signal?: AbortSignal,
+  /** Groups file edits of one turn so they can be undone together. */
+  checkpoint?: string,
+) {
+  return api<DaemonToolResult>(
+    '/api/tools/execute',
+    { ...jsonBody({ name, args, mode, checkpoint }), signal },
+  )
+}
+
+export function getPreviewToken() {
+  return api<{ token: string }>('/api/preview/token')
+}
+
+export function getProjectInstructions() {
+  return api<{ file: string; content: string; truncated: boolean }>('/api/workspace/instructions')
+}
+
+export interface CheckpointSummary {
+  id: string
+  createdAt: number
+  files: Array<{ path: string; existed: boolean; skipped: boolean }>
+}
+
+export function getCheckpoint(id: string) {
+  return api<CheckpointSummary>(`/api/checkpoints/${encodeURIComponent(id)}`)
+}
+
+export function restoreCheckpoint(id: string) {
+  return api<{ id: string; restored: string[]; removed: string[]; skipped: string[] }>(
+    `/api/checkpoints/${encodeURIComponent(id)}/restore`,
+    { method: 'POST', body: JSON.stringify({}) },
+  )
+}
+
+export function runGit(action: string, args: Record<string, unknown> = {}, mode: AgentMode = 'build') {
+  return api<Record<string, unknown>>('/api/git', jsonBody({ action, args, mode }))
+}
+
+export async function requestLLM(
+  provider: ProviderId,
+  kind: string,
+  model: string,
+  body: Record<string, unknown>,
+  signal?: AbortSignal,
+  retry = true,
+): Promise<Response> {
+  await ensureSession()
+  let response: Response
+  try {
+    response = await fetch('/api/llm', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-maxcode-csrf': csrf,
+      },
+      body: JSON.stringify({ provider, kind, model, body }),
+      signal,
+      credentials: 'same-origin',
+    })
+  } catch (error) {
+    if (error instanceof DOMException && error.name === 'AbortError') throw error
+    throw new DaemonError('Lost the connection to the local daemon while calling the model.', 0, 'daemon_unreachable')
+  }
+  // The daemon forgets sessions when it restarts; get a fresh one and retry once.
+  if (response.status === 401 && retry) {
+    await ensureSession(true)
+    return requestLLM(provider, kind, model, body, signal, false)
+  }
+  if (!response.ok) throw await parseError(response)
+  return response
+}
+
+export async function* streamDeploy(
+  request: DeployRequest,
+  signal?: AbortSignal,
+): AsyncGenerator<DeployEvent> {
+  await ensureSession()
+  let response: Response
+  try {
+    response = await fetch('/api/deploy', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-maxcode-csrf': csrf,
+      },
+      body: JSON.stringify(request),
+      signal,
+      credentials: 'same-origin',
+    })
+  } catch (error) {
+    if (error instanceof DOMException && error.name === 'AbortError') throw error
+    throw new DaemonError('Lost the connection to the local daemon while deploying.', 0, 'daemon_unreachable')
+  }
+  if (!response.ok) throw await parseError(response)
+  if (!response.body) throw new DaemonError('The deploy stream was empty.', 502, 'empty_stream')
+  const reader = response.body.getReader()
+  const decoder = new TextDecoder()
+  let buffer = ''
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      buffer += decoder.decode(value, { stream: true })
+      let index = buffer.indexOf('\n')
+      while (index !== -1) {
+        const line = buffer.slice(0, index).trim()
+        buffer = buffer.slice(index + 1)
+        if (line) {
+          try {
+            yield JSON.parse(line) as DeployEvent
+          } catch {
+            yield { type: 'log', stream: 'meta', text: line }
+          }
+        }
+        index = buffer.indexOf('\n')
+      }
+    }
+    const tail = buffer.trim()
+    if (tail) {
+      try {
+        yield JSON.parse(tail) as DeployEvent
+      } catch {
+        yield { type: 'log', stream: 'meta', text: tail }
+      }
+    }
+  } finally {
+    reader.releaseLock()
+  }
+}
+
+export type { DeployResult, SecretsSummary }

package/src/lib/hooks.ts

@@ -0,0 +1,33 @@
+import { useEffect, useRef, type RefObject } from 'react'
+
+export function useClickOutside<T extends HTMLElement>(
+  ref: RefObject<T | null>,
+  handler: () => void,
+  active = true,
+  ignoreRef?: RefObject<HTMLElement | null>,
+) {
+  const saved = useRef(handler)
+  saved.current = handler
+
+  useEffect(() => {
+    if (!active) return
+    const onPointer = (event: PointerEvent) => {
+      const node = ref.current
+      if (!node) return
+      const target = event.target
+      if (!(target instanceof Node)) return
+      if (node.contains(target)) return
+      if (ignoreRef?.current?.contains(target)) return
+      saved.current()
+    }
+    const onKey = (event: KeyboardEvent) => {
+      if (event.key === 'Escape') saved.current()
+    }
+    document.addEventListener('pointerdown', onPointer, true)
+    document.addEventListener('keydown', onKey)
+    return () => {
+      document.removeEventListener('pointerdown', onPointer, true)
+      document.removeEventListener('keydown', onKey)
+    }
+  }, [active, ref, ignoreRef])
+}

package/src/lib/permissions.ts

@@ -0,0 +1,60 @@
+import type { AppSettings, ToolName, ToolSetting } from '../types'
+
+export type PermissionMode = 'ask' | 'accept-edits' | 'full'
+
+export const PERMISSION_MODES: Array<{ value: PermissionMode; label: string; description: string }> = [
+  {
+    value: 'ask',
+    label: 'Ask first',
+    description: 'Confirm shell commands, edits and git changes before they run.',
+  },
+  {
+    value: 'accept-edits',
+    label: 'Accept edits',
+    description: 'Apply file edits automatically; still confirm shell and git.',
+  },
+  {
+    value: 'full',
+    label: 'Full access',
+    description: 'Run every enabled tool without asking. Use only in trusted folders.',
+  },
+]
+
+const WRITE_TOOLS: ToolName[] = ['write_file', 'edit_file', 'rewrite_file']
+const GUARDED_TOOLS: ToolName[] = ['shell', 'git', 'subagent']
+
+export function permissionMode(tools: AppSettings['tools']): PermissionMode {
+  const writesAuto = WRITE_TOOLS.every((tool) => tools[tool]?.approval === 'auto')
+  const guardedAuto = GUARDED_TOOLS.every((tool) => tools[tool]?.approval === 'auto')
+  if (writesAuto && guardedAuto) return 'full'
+  if (writesAuto) return 'accept-edits'
+  return 'ask'
+}
+
+export function permissionTools(
+  tools: AppSettings['tools'],
+  mode: PermissionMode,
+): Record<ToolName, ToolSetting> {
+  const next = {} as Record<ToolName, ToolSetting>
+  for (const key of Object.keys(tools) as ToolName[]) {
+    const mutating = WRITE_TOOLS.includes(key) || GUARDED_TOOLS.includes(key)
+    const approval: ToolSetting['approval'] =
+      mode === 'full'
+        ? 'auto'
+        : mode === 'accept-edits'
+          ? WRITE_TOOLS.includes(key)
+            ? 'auto'
+            : GUARDED_TOOLS.includes(key)
+              ? 'ask'
+              : tools[key].approval
+          : mutating
+            ? 'ask'
+            : tools[key].approval
+    next[key] = { ...tools[key], approval }
+  }
+  return next
+}
+
+export function permissionLabel(mode: PermissionMode): string {
+  return PERMISSION_MODES.find((entry) => entry.value === mode)?.label ?? 'Ask first'
+}

package/src/lib/pixlesol.test.mjs

@@ -0,0 +1,51 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { pixleMood, PIXLE_LABELS } from './pixlesol.ts'
+
+const user = { id: 'u', role: 'user', content: 'hi', createdAt: 0 }
+const assistant = (patch) => ({
+  id: 'a',
+  role: 'assistant',
+  content: '',
+  reasoning: '',
+  toolCalls: [],
+  round: 0,
+  createdAt: 0,
+  ...patch,
+})
+const tool = (status) => ({
+  id: 't',
+  role: 'tool',
+  call: { id: 'c', name: 'read_file', args: {} },
+  status,
+  round: 0,
+  createdAt: 0,
+})
+
+test('no messages means PixleSol waves', () => {
+  assert.equal(pixleMood([], false), 'wave')
+})
+
+test('reasoning while streaming is thinking', () => {
+  assert.equal(pixleMood([user, assistant({ reasoning: 'hmm' })], true), 'thinking')
+})
+
+test('streaming with content is typing', () => {
+  assert.equal(pixleMood([user, assistant({ reasoning: 'hmm', content: 'so far' })], true), 'typing')
+})
+
+test('an awaiting tool needs approval, a failed tool is an error', () => {
+  assert.equal(pixleMood([user, tool('awaiting')], true), 'alert')
+  assert.equal(pixleMood([user, tool('error')], false), 'error')
+})
+
+test('a finished answer is happy, a stopped answer is sleepy', () => {
+  assert.equal(pixleMood([user, assistant({ content: 'done' })], false), 'happy')
+  assert.equal(pixleMood([user, assistant({ stopped: true })], false), 'sleepy')
+})
+
+test('every mood has a label', () => {
+  for (const mood of Object.keys(PIXLE_LABELS)) {
+    assert.ok(PIXLE_LABELS[mood])
+  }
+})

package/src/lib/pixlesol.ts

@@ -0,0 +1,55 @@
+import type { Message } from '../types'
+
+export type PixleMood =
+  | 'wave'
+  | 'idle'
+  | 'thinking'
+  | 'working'
+  | 'typing'
+  | 'happy'
+  | 'alert'
+  | 'error'
+  | 'sleepy'
+  | 'party'
+
+export const PIXLE_LABELS: Record<PixleMood, string> = {
+  wave: 'Ready when you are',
+  idle: 'Standing by',
+  thinking: 'Thinking it through…',
+  working: 'Running tools…',
+  typing: 'Writing the answer…',
+  happy: 'Answer ready',
+  alert: 'Needs your approval',
+  error: 'Hit a snag',
+  sleepy: 'Waiting for the next turn',
+  party: 'All steps finished',
+}
+
+/**
+ * Pick PixleSol's face from the tail of the conversation. Presentation only —
+ * nothing here mutates a session.
+ */
+export function pixleMood(messages: Message[], streaming: boolean): PixleMood {
+  if (messages.length === 0) return 'wave'
+  const last = messages[messages.length - 1]
+
+  if (last.role === 'tool') {
+    if (last.status === 'awaiting') return 'alert'
+    if (last.status === 'error') return 'error'
+    if (streaming || last.status === 'running') return 'working'
+    return 'party'
+  }
+
+  if (last.role === 'assistant') {
+    if (last.error) return 'error'
+    if (streaming) {
+      if (last.reasoning.trim() && !last.content.trim()) return 'thinking'
+      return 'typing'
+    }
+    if (last.stopped) return 'sleepy'
+    if (last.content.trim()) return 'happy'
+    return 'idle'
+  }
+
+  return streaming ? 'working' : 'idle'
+}