@clawpump/claw-agent 0.1.5 → 0.1.6

package/agent/apps/desktop/src/themes/vscode.ts

@@ -0,0 +1,343 @@
+/**
+ * VS Code color-theme → DesktopTheme converter.
+ *
+ * VS Code themes carry ~hundreds of `workbench.colorCustomization` keys, but the
+ * desktop theme model only needs a `DesktopThemeColors` struct — `applyTheme`
+ * derives every glass/shadcn token from a small seed chain via `color-mix()`.
+ * In practice ~6 workbench keys carry the whole look (background, foreground,
+ * accent, elevated surface, sidebar, error); everything else we derive by mixing
+ * those toward the background/foreground. That's the "naive token converter".
+ *
+ * A VS Code theme is single-mode (light OR dark). Rather than synthesise the
+ * opposite mode, we set both `colors` and `darkColors` to the converted palette
+ * so the imported theme renders faithfully no matter where the light/dark toggle
+ * sits — `renderedModeFor` still picks the `.dark` class from the real
+ * background luminance, so surface-bound UI matches what's on screen.
+ */
+
+import { ensureContrast, luminance, mix, normalizeHex, readableOn } from './color'
+import type { DesktopTerminalPalette, DesktopTheme, DesktopThemeColors } from './types'
+
+// Section headers / sidebar labels render in --theme-primary directly on the
+// sidebar surface as small (~10px) uppercase text, so the accent has to clear
+// WCAG AA for normal text (4.5:1) or it's unreadable — the "invisible purple
+// label" case. Imported accents below this get nudged lighter/darker.
+const ACCENT_MIN_CONTRAST = 4.5
+
+/** The shape of a VS Code `*-color-theme.json` (only the fields we read). */
+export interface VscodeColorTheme {
+  name?: string
+  type?: string
+  /** Relative path to a base theme this one extends. We don't follow it. */
+  include?: string
+  colors?: Record<string, unknown>
+  tokenColors?: unknown
+}
+
+export interface ConvertOptions {
+  /** Stable id (slug). Defaults to a slug of `raw.name`. */
+  slug?: string
+  /** Display label. Defaults to `raw.name`. */
+  label?: string
+  /** Shown under the label in the picker (e.g. the marketplace extension id). */
+  source?: string
+}
+
+export interface ConvertResult {
+  theme: DesktopTheme
+  /** The source theme's own light/dark (from `type`, else background luminance). */
+  mode: 'light' | 'dark'
+  /** Workbench keys we wanted but the theme omitted (we derived fallbacks). */
+  derived: string[]
+}
+
+/** Tolerant slug: lowercase, alnum + dashes, deduped, `vsc-` namespaced. */
+export function vscodeThemeSlug(name: string): string {
+  const base = name
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 48)
+
+  return `vsc-${base || 'theme'}`
+}
+
+/**
+ * Parse a VS Code theme file. These ship as JSONC (line/block comments and
+ * trailing commas), so a plain `JSON.parse` rejects most real-world files.
+ * Strips comments + trailing commas, then parses. Throws on hard syntax errors.
+ */
+export function parseVscodeTheme(text: string): VscodeColorTheme {
+  const stripped = text
+    // Block comments.
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    // Line comments (not inside strings — naive but fine for theme files).
+    .replace(/(^|[^:"'\\])\/\/[^\n\r]*/g, '$1')
+    // Trailing commas before } or ].
+    .replace(/,(\s*[}\]])/g, '$1')
+
+  const parsed: unknown = JSON.parse(stripped)
+
+  if (!parsed || typeof parsed !== 'object') {
+    throw new Error('Theme file is not a JSON object.')
+  }
+
+  return parsed as VscodeColorTheme
+}
+
+const isDarkType = (raw: VscodeColorTheme, background: string): boolean => {
+  const type = (raw.type ?? '').toLowerCase()
+
+  if (type.includes('light')) {
+    return false
+  }
+
+  if (type === 'dark' || type === 'hc' || type === 'hc-black' || type.includes('dark')) {
+    return true
+  }
+
+  // No usable `type` — bucket by background luminance.
+  return luminance(background) < 0.4
+}
+
+// xterm ITheme ANSI slots ← VS Code `terminal.ansi*` tokens. Background is
+// deliberately excluded — the pane keeps the live skin surface (transparency).
+const ANSI_TOKENS: ReadonlyArray<readonly [keyof DesktopTerminalPalette, string]> = [
+  ['black', 'terminal.ansiBlack'],
+  ['red', 'terminal.ansiRed'],
+  ['green', 'terminal.ansiGreen'],
+  ['yellow', 'terminal.ansiYellow'],
+  ['blue', 'terminal.ansiBlue'],
+  ['magenta', 'terminal.ansiMagenta'],
+  ['cyan', 'terminal.ansiCyan'],
+  ['white', 'terminal.ansiWhite'],
+  ['brightBlack', 'terminal.ansiBrightBlack'],
+  ['brightRed', 'terminal.ansiBrightRed'],
+  ['brightGreen', 'terminal.ansiBrightGreen'],
+  ['brightYellow', 'terminal.ansiBrightYellow'],
+  ['brightBlue', 'terminal.ansiBrightBlue'],
+  ['brightMagenta', 'terminal.ansiBrightMagenta'],
+  ['brightCyan', 'terminal.ansiBrightCyan'],
+  ['brightWhite', 'terminal.ansiBrightWhite']
+]
+
+const BASE_ANSI: ReadonlyArray<keyof DesktopTerminalPalette> = [
+  'black',
+  'red',
+  'green',
+  'yellow',
+  'blue',
+  'magenta',
+  'cyan',
+  'white'
+]
+
+const HEX_RE = /^#[0-9a-f]{3,8}$/i
+
+/**
+ * Lift a theme's integrated-terminal ANSI palette, if it ships one.
+ *
+ * All-or-nothing on the base-8 colors: a half-filled palette mixed with our
+ * defaults reads worse than just keeping the defaults, so we adopt the theme's
+ * palette only when the full base set is present. ANSI slots flatten alpha over
+ * the editor background; selection keeps its alpha so xterm can blend it.
+ */
+function extractTerminalPalette(colors: Record<string, unknown>, background: string): DesktopTerminalPalette | undefined {
+  const hex = (key: string): string | undefined =>
+    normalizeHex(typeof colors[key] === 'string' ? (colors[key] as string) : null, background) ?? undefined
+
+  const palette: DesktopTerminalPalette = {}
+
+  for (const [slot, token] of ANSI_TOKENS) {
+    const value = hex(token)
+
+    if (value) {
+      palette[slot] = value
+    }
+  }
+
+  if (!BASE_ANSI.every(slot => palette[slot])) {
+    return undefined
+  }
+
+  const foreground = hex('terminal.foreground')
+  const cursor = hex('terminalCursor.foreground') ?? hex('terminalCursor.background')
+  const selection = typeof colors['terminal.selectionBackground'] === 'string' ? colors['terminal.selectionBackground'].trim() : ''
+
+  if (foreground) {
+    palette.foreground = foreground
+  }
+
+  if (cursor) {
+    palette.cursor = cursor
+  }
+
+  if (HEX_RE.test(selection)) {
+    palette.selectionBackground = selection
+  }
+
+  return palette
+}
+
+/** First normalizable hex among `keys`, composited over `backdrop`. */
+const pick = (
+  colors: Record<string, unknown>,
+  keys: string[],
+  backdrop: string
+): { key: string; value: string } | null => {
+  for (const key of keys) {
+    const value = normalizeHex(typeof colors[key] === 'string' ? (colors[key] as string) : null, backdrop)
+
+    if (value) {
+      return { key, value }
+    }
+  }
+
+  return null
+}
+
+export function convertVscodeColorTheme(raw: VscodeColorTheme, opts: ConvertOptions = {}): ConvertResult {
+  const colors = raw.colors && typeof raw.colors === 'object' ? (raw.colors as Record<string, unknown>) : null
+
+  if (!colors) {
+    throw new Error('Theme has no "colors" map — not a VS Code color theme.')
+  }
+
+  const derived: string[] = []
+
+  // Background first: it's the backdrop every other token flattens alpha over.
+  const backgroundHit = pick(colors, ['editor.background', 'editorPane.background', 'editorGroup.background'], '#000000')
+  const dark = isDarkType(raw, backgroundHit?.value ?? '#1e1e1e')
+  const background = backgroundHit?.value ?? (dark ? '#1e1e1e' : '#ffffff')
+
+  if (!backgroundHit) {
+    derived.push('editor.background')
+  }
+
+  // `take` records a derived fallback when the theme omits the key.
+  const take = (keys: string[], fallback: string): string => {
+    const hit = pick(colors, keys, background)
+
+    if (hit) {
+      return hit.value
+    }
+
+    derived.push(keys[0])
+
+    return fallback
+  }
+
+  const foreground = take(['editor.foreground', 'foreground'], dark ? '#d4d4d4' : '#1f1f1f')
+
+  // Brand accent — the single most load-bearing token. Drives primary buttons,
+  // focus rings, the streaming cursor, active-session pills, and sidebar labels.
+  // Prefer the saturated "brand" tokens (button / link / badge) over focusBorder,
+  // which many themes set to a muted gray — picking it first made imported
+  // accents look like the desktop defaults. We enforce contrast below regardless.
+  const accentSource = take(
+    [
+      'button.background',
+      'textLink.activeForeground',
+      'textLink.foreground',
+      'activityBarBadge.background',
+      'badge.background',
+      'progressBar.background',
+      'pickerGroup.foreground',
+      'list.highlightForeground',
+      'editorLink.activeForeground',
+      'focusBorder',
+      'tab.activeBorder',
+      'statusBarItem.remoteBackground'
+    ],
+    mix(foreground, background, 0.55)
+  )
+
+  const elevated = take(
+    ['editorWidget.background', 'dropdown.background', 'menu.background', 'quickInput.background', 'editorSuggestWidget.background'],
+    mix(background, foreground, dark ? 0.08 : 0.05)
+  )
+
+  const card = take(
+    ['sideBarSectionHeader.background', 'tab.inactiveBackground', 'editorGroupHeader.tabsBackground'],
+    mix(background, foreground, dark ? 0.04 : 0.025)
+  )
+
+  const sidebar = take(['sideBar.background', 'activityBar.background'], mix(background, foreground, dark ? 0.02 : 0.012))
+
+  // The accent labels the sidebar (--theme-primary), so guarantee it reads
+  // there — otherwise low-contrast brand colors leave invisible section headers.
+  const accent = ensureContrast(accentSource, sidebar, ACCENT_MIN_CONTRAST)
+
+  const border = take(
+    ['panel.border', 'editorGroup.border', 'sideBar.border', 'contrastBorder', 'widget.border', 'input.border'],
+    mix(background, foreground, dark ? 0.16 : 0.14)
+  )
+
+  const input = take(['input.background', 'dropdown.background', 'quickInput.background'], mix(background, foreground, dark ? 0.1 : 0.06))
+
+  const mutedForeground = take(
+    ['descriptionForeground', 'editorLineNumber.foreground', 'tab.inactiveForeground', 'disabledForeground'],
+    mix(foreground, background, 0.45)
+  )
+
+  const destructive = take(
+    ['editorError.foreground', 'errorForeground', 'editorOverviewRuler.errorForeground', 'notificationsErrorIcon.foreground'],
+    '#e25563'
+  )
+
+  const muted = mix(background, foreground, dark ? 0.06 : 0.04)
+  const accentSoft = mix(accent, background, dark ? 0.82 : 0.88)
+  const secondary = mix(accent, background, dark ? 0.72 : 0.86)
+
+  const palette: DesktopThemeColors = {
+    background,
+    foreground,
+    card,
+    cardForeground: foreground,
+    muted,
+    mutedForeground,
+    popover: elevated,
+    popoverForeground: foreground,
+    primary: accent,
+    primaryForeground: readableOn(accent),
+    secondary,
+    secondaryForeground: foreground,
+    accent: accentSoft,
+    accentForeground: foreground,
+    border,
+    input,
+    ring: accent,
+    midground: accent,
+    midgroundForeground: readableOn(accent),
+    composerRing: accent,
+    destructive,
+    destructiveForeground: readableOn(destructive),
+    sidebarBackground: sidebar,
+    sidebarBorder: border,
+    userBubble: mix(card, accent, dark ? 0.18 : 0.12),
+    userBubbleBorder: border
+  }
+
+  const label = (opts.label ?? raw.name ?? 'VS Code Theme').trim()
+  const slug = opts.slug ?? vscodeThemeSlug(label)
+  const terminal = extractTerminalPalette(colors, background)
+
+  return {
+    derived,
+    mode: dark ? 'dark' : 'light',
+    theme: {
+      name: slug,
+      label,
+      description: opts.source ? `VS Code · ${opts.source}` : 'Imported from VS Code',
+      // Single palette in both slots. A lone VS Code theme is one-mode; callers
+      // that have both a light and dark variant (a Marketplace extension family)
+      // recombine them into proper colors/darkColors via buildThemeFromMarketplace.
+      colors: palette,
+      darkColors: palette,
+      // Only set when the theme ships a full ANSI palette — the terminal keeps
+      // its built-in VS Code defaults otherwise.
+      ...(terminal ? { terminal } : {})
+    }
+  }
+}

package/agent/apps/desktop/src/types/hermes.ts

@@ -47,8 +47,13 @@ export interface OAuthProviderStatus {
 
 export interface OAuthProvider {
   cli_command: string
+  /** Shell command that clears an external provider's credentials, run in the
+   *  embedded terminal. Null when Hermes doesn't know how to remove it. */
+  disconnect_command?: null | string
+  disconnect_hint?: null | string
+  disconnectable?: boolean
   docs_url: string
-  flow: 'device_code' | 'external' | 'pkce'
+  flow: 'device_code' | 'external' | 'loopback' | 'pkce'
   id: string
   name: string
   status: OAuthProviderStatus
@@ -73,6 +78,12 @@ export type OAuthStartResponse =
       user_code: string
       verification_url: string
     }
+  | {
+      auth_url: string
+      expires_in: number
+      flow: 'loopback'
+      session_id: string
+    }
 
 export interface OAuthSubmitResponse {
   message?: string
@@ -90,14 +101,49 @@ export interface OAuthPollResponse {
 export interface EnvVarInfo {
   advanced: boolean
   category: string
+  // True when this var is a messaging-platform credential owned by a card on
+  // the dedicated Messaging page. The Keys page hides these to avoid
+  // duplicating the richer channel-configuration UI.
+  channel_managed?: boolean
   description: string
   is_password: boolean
   is_set: boolean
+  // Backend-derived provider grouping hints (from the unified provider catalog
+  // in hermes_cli/provider_catalog.py). When present, the Keys tab groups by
+  // this provider identity — the SAME one `hermes model` uses — instead of
+  // desktop-only env-var prefix guesses. Empty for non-provider env vars.
+  provider?: string
+  provider_label?: string
   redacted_value: null | string
   tools: string[]
   url: null | string
 }
 
+export type MemoryProviderFieldKind = 'secret' | 'select' | 'text'
+
+export interface MemoryProviderFieldOption {
+  description: string
+  label: string
+  value: string
+}
+
+export interface MemoryProviderField {
+  description: string
+  is_set: boolean
+  key: string
+  kind: MemoryProviderFieldKind
+  label: string
+  options: MemoryProviderFieldOption[]
+  placeholder: string
+  value: string
+}
+
+export interface MemoryProviderConfig {
+  fields: MemoryProviderField[]
+  label: string
+  name: string
+}
+
 export interface MessagingEnvVarInfo {
   advanced: boolean
   description: string
@@ -203,6 +249,18 @@ export interface ModelOptionProvider {
   slug: string
   total_models?: number
   warning?: string
+  /** True when the provider has usable credentials. False for canonical
+   *  providers surfaced by `include_unconfigured` that the user hasn't set up
+   *  yet — render these with a setup affordance instead of hiding them. */
+  authenticated?: boolean
+  /** Auth flow for an unconfigured provider: "api_key" can be activated inline
+   *  by pasting `key_env`; anything else (oauth_*, external, aws_sdk, …) needs
+   *  the `hermes model` CLI / onboarding OAuth flow. */
+  auth_type?: string
+  /** Env var to paste an API key into, for unconfigured `api_key` providers. */
+  key_env?: string
+  /** True for providers defined via the user's `providers:` config block. */
+  is_user_defined?: boolean
   /** Per-model pricing keyed by model id (present when the picker requested
    *  pricing and the provider supports live pricing). */
   pricing?: Record<string, ModelPricing>
@@ -210,6 +268,14 @@ export interface ModelOptionProvider {
   free_tier?: boolean
   /** Nous only: paid models a free-tier user cannot select (shown disabled). */
   unavailable_models?: string[]
+  /** Per-model option support, keyed by model id (present when the picker
+   *  requested capabilities). Lets the UI gate fast/reasoning controls. */
+  capabilities?: Record<string, ModelCapabilities>
+}
+
+export interface ModelCapabilities {
+  fast: boolean
+  reasoning: boolean
 }
 
 export interface ModelOptionsResponse {
@@ -223,6 +289,14 @@ export interface PaginatedSessions {
   offset: number
   sessions: SessionInfo[]
   total: number
+  /** Listable conversation count per profile (children excluded), keyed by
+   *  profile name. Lets the sidebar scope its "Load more" footer to the active
+   *  profile instead of the global total. Present only on
+   *  `/api/profiles/sessions`. */
+  profile_totals?: Record<string, number>
+  /** Per-profile read failures from the cross-profile aggregator (e.g. a locked
+   *  or corrupt state.db). Present only on `/api/profiles/sessions`. */
+  errors?: Array<{ profile: string; error: string }>
 }
 
 export interface RpcEvent<T = unknown> {
@@ -259,6 +333,20 @@ export interface SessionInfo {
   started_at: number
   title: null | string
   tool_call_count: number
+  /** Origin platform when this session was handed off from a messaging
+   *  platform (e.g. a Telegram thread continued in the desktop app). The live
+   *  {@link source} becomes local (tui/desktop) after a handoff, so the origin
+   *  is preserved here to surface the platform badge on the row. */
+  handoff_platform?: null | string
+  /** Handoff lifecycle: 'pending' | 'in_progress' | 'completed' | 'failed'. */
+  handoff_state?: null | string
+  handoff_error?: null | string
+  /** Owning profile name, set by the cross-profile aggregator
+   *  (`/api/profiles/sessions`). Absent on legacy single-profile responses,
+   *  which the UI treats as the default profile. */
+  profile?: string
+  /** True when {@link profile} is the default profile. */
+  is_default_profile?: boolean
 }
 
 export interface SessionMessage {
@@ -307,6 +395,7 @@ export interface SessionRuntimeInfo {
   tools?: Record<string, string[]>
   usage?: Partial<UsageStats>
   version?: string
+  yolo?: boolean
 }
 
 export interface UsageStats {
@@ -416,6 +505,8 @@ export interface CronJobUpdates {
 }
 
 export interface ProfileCreatePayload {
+  clone_all?: boolean
+  clone_from?: null | string
   clone_from_default?: boolean
   name: string
   no_skills?: boolean
@@ -489,8 +580,12 @@ export interface ToolsetConfig {
 }
 
 export interface SessionSearchResult {
+  /** Lineage root of the matched conversation. Stable across compression and
+   *  used as the durable pin id; falls back to session_id when absent. */
+  lineage_root?: string | null
   model: string | null
   role: string | null
+  /** Live compression tip of the matched conversation — resume by this id. */
   session_id: string
   session_started: number | null
   snippet: string
@@ -545,6 +640,27 @@ export interface ActionStatusResponse {
   running: boolean
 }
 
+export interface BackendUpdateCommit {
+  sha: string
+  summary: string
+  author: string
+  at: number
+}
+
+/** Shape of `GET /api/hermes/update/check` — the backend's own update state.
+ *  Used by the desktop's remote update overlay so the backend version (not the
+ *  Electron client clone) drives "what's changed + Install" in remote mode. */
+export interface BackendUpdateCheckResponse {
+  install_method: string
+  current_version: string
+  behind: number | null
+  update_available: boolean
+  can_apply: boolean
+  update_command: string | null
+  message: string | null
+  commits?: BackendUpdateCommit[]
+}
+
 export interface AuxiliaryTaskAssignment {
   base_url: string
   model: string
@@ -558,13 +674,30 @@ export interface AuxiliaryModelsResponse {
 }
 
 export interface ModelAssignmentRequest {
+  /** Optional API key for a custom/local endpoint. Persisted to model.api_key
+   *  (where the runtime reads it) for self-hosted endpoints that require auth.
+   *  Only honored for custom/local providers on the main slot. */
+  api_key?: string
+  /** OpenAI-compatible endpoint URL. Only honored for custom/local providers
+   *  on the main slot — wires a self-hosted endpoint into runtime resolution. */
+  base_url?: string
   model: string
   provider: string
   scope: 'main' | 'auxiliary'
   task?: string
 }
 
+/** An auxiliary task still pinned to a provider that differs from the
+ *  newly-selected main provider after a main-model switch. */
+export interface StaleAuxAssignment {
+  task: string
+  provider: string
+  model: string
+}
+
 export interface ModelAssignmentResponse {
+  /** Persisted endpoint URL for custom/local providers (echoed back). */
+  base_url?: string
   /** Toolset keys auto-routed through the Nous Tool Gateway as a result of
    *  switching the main provider to Nous. Empty unless provider === 'nous'
    *  and the user is a paid subscriber with unconfigured tools. */
@@ -574,5 +707,9 @@ export interface ModelAssignmentResponse {
   provider?: string
   reset?: boolean
   scope?: string
+  /** Auxiliary slots still pinned to a different provider than the new main.
+   *  Switching main never clears aux pins; this lets the UI warn the user
+   *  their helper tasks aren't following the switch. Only set on scope:'main'. */
+  stale_aux?: StaleAuxAssignment[]
   tasks?: string[]
 }

package/agent/apps/desktop/tsconfig.json

@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
-    "target": "ES2022",
+    "target": "ES2023",
     "useDefineForClassFields": true,
-    "lib": ["DOM", "DOM.Iterable", "ES2022"],
+    "lib": ["DOM", "DOM.Iterable", "ES2023"],
     "allowJs": false,
     "skipLibCheck": true,
     "esModuleInterop": true,

package/agent/apps/desktop/vite.config.ts

@@ -6,9 +6,27 @@ import path from 'path'
 export default defineConfig({
   base: './',
   plugins: [react(), tailwindcss()],
+  css: {
+    // Pin an explicit (empty) PostCSS config. Tailwind is handled entirely by
+    // `@tailwindcss/vite`, so the renderer needs no PostCSS plugins — and
+    // without this, Vite's `postcss-load-config` walks UP the filesystem
+    // looking for a stray `postcss.config.*` / `tailwind.config.*`. The desktop
+    // build runs from inside the user's home tree (e.g.
+    // `C:\Users\<name>\AppData\Local\hermes\hermes-agent\apps\desktop`), so an
+    // unrelated Tailwind v3 config higher up the tree gets picked up and
+    // reprocesses our v4 stylesheet, failing the build with
+    // "`@layer base` is used but no matching `@tailwind base` directive is
+    // present." Pinning the config makes the build hermetic.
+    postcss: { plugins: [] }
+  },
   build: {
     // Keep desktop packaging stable: Shiki ships many dynamic chunks by
     // default, and electron-builder can OOM scanning thousands of files.
+    // Collapsing to a single chunk is intentional, so the renderer bundle is
+    // large by design (~22 MB). Raise the warning ceiling above that so the
+    // cosmetic "chunk larger than 500 kB" nag stays quiet, while still acting
+    // as a regression alarm if the bundle balloons well past today's size.
+    chunkSizeWarningLimit: 25000,
     rolldownOptions: {
       output: {
         codeSplitting: false

package/agent/apps/shared/package.json

@@ -8,7 +8,7 @@
   },
   "types": "./src/index.ts",
   "scripts": {
-    "type-check": "tsc -p tsconfig.json --noEmit"
+    "typecheck": "tsc -p . --noEmit"
   },
   "devDependencies": {
     "typescript": "^6.0.3"