@bibobonking/opensol 3.0.3 → 3.1.1

package/src/core/services/tools.ts

@@ -1,5 +1,6 @@
 import { Service, type Context } from 'cordis'
 import type { AgentMode, AppSettings, ToolName } from '../../types'
+import { mcpDefinition, mcpDefinitions, resolveToolSetting } from '../mcp-tools'
 import type {
   ToolDefinition,
   ToolExecutionContext,
@@ -39,11 +40,11 @@ export class ToolService extends Service {
   }
 
   get(name: ToolName): ToolDefinition | undefined {
-    return this.definitions.get(name)
+    return this.definitions.get(name) ?? mcpDefinition(name)
   }
 
   list(): ToolDefinition[] {
-    return [...this.definitions.values()]
+    return [...this.definitions.values(), ...mcpDefinitions()]
   }
 
   schemas(
@@ -52,9 +53,11 @@ export class ToolService extends Service {
     { subagent = false }: { subagent?: boolean } = {},
   ): ToolSchema[] {
     const list: ToolSchema[] = []
-    for (const def of this.definitions.values()) {
+    // Subagents stay on the built-in read-only tools; MCP tools are not offered to them.
+    const all = subagent ? [...this.definitions.values()] : this.list()
+    for (const def of all) {
       if (def.name === 'subagent' && subagent) continue
-      if (!settings.tools[def.name]?.enabled) continue
+      if (!resolveToolSetting(settings, def.name)?.enabled) continue
       const allowed = def.allowedInMode ? def.allowedInMode(mode) : toolAllowedInMode(def.name, mode)
       if (!allowed) continue
       if ((def.name === 'web_search' || def.name === 'read_url') && !settings.webSearchEnabled) continue
@@ -83,10 +86,10 @@ export class ToolService extends Service {
       'tools/pre-execute',
       exec,
       async () => {
-        if (!settings.tools[name]?.enabled) {
-          return { decision: 'deny', reason: 'This tool is disabled in Settings → Tools.' }
+        if (!resolveToolSetting(settings, name)?.enabled) {
+          return { decision: 'deny', reason: 'This tool is disabled or its MCP server is not connected (Settings → Tools / MCP).' }
         }
-        const def = this.definitions.get(name)
+        const def = this.get(name)
         const allowed = def?.allowedInMode ? def.allowedInMode(mode) : toolAllowedInMode(name, mode)
         if (!allowed) {
           return {
@@ -113,7 +116,7 @@ export class ToolService extends Service {
 
     // 2. tools/execute waterfall
     const result: ToolResult = await this.ctx.events.waterfall('tools/execute', exec, async () => {
-      const def = this.definitions.get(name)
+      const def = this.get(name)
       if (!def) {
         return { output: `Tool "${name}" is not registered.`, isError: true }
       }

package/src/core/types.ts

@@ -2,6 +2,7 @@ import type {
   AgentMode,
   AppSettings,
   AssistantMessage,
+  FileDiff,
   Message,
   ModelInfo,
   ToolCall,
@@ -32,6 +33,8 @@ export interface ToolSchema {
 export interface ToolResult {
   output: string
   isError: boolean
+  /** Set by file tools so the UI can show +added / −removed lines. */
+  diff?: FileDiff
 }
 
 export interface ToolExecutionContext {
@@ -120,6 +123,7 @@ declare module 'cordis' {
     subagents: import('./services/subagents').SubagentService
     agentLoop: import('./services/agent-loop').AgentLoopService
     ui: import('./services/ui').UiService
+    titles: import('./services/titles').TitleService
   }
 
   interface Events {

package/src/data/providers.ts

@@ -7,7 +7,7 @@ export const PROVIDERS: ProviderDef[] = [
     format: 'openai',
     baseUrl: 'https://api.openai.com/v1',
     keyHint: 'sk-…',
-    note: 'GPT and Codex models. Requests are made by your local daemon, never by OpenSoft.',
+    note: 'GPT and Codex models. Requests are made by your local daemon, never by OpenSoftX.',
   },
   {
     id: 'anthropic',

package/src/index.css

@@ -222,7 +222,15 @@
   }
 
   .settings-row {
-    @apply flex flex-col gap-2 border-b border-line py-4 last:border-b-0 sm:flex-row sm:items-center sm:justify-between sm:gap-6;
+    @apply -mx-3 flex flex-col gap-2 rounded-2xl border-b border-transparent px-3 py-4 transition-colors duration-200 hover:bg-raised/50 sm:flex-row sm:items-center sm:justify-between sm:gap-6;
+  }
+
+  .settings-card {
+    @apply relative rounded-2xl border border-line bg-panel p-4 shadow-pill transition-all duration-300 sm:p-5;
+  }
+
+  .settings-card:hover {
+    border-color: rgb(var(--accent) / 0.25);
   }
 
   .settings-label {
@@ -774,3 +782,91 @@
   33% { transform: translateX(0); }
   66% { transform: translateX(1px); }
 }
+
+
+/* ───────── v3.1 motion & animation ───────── */
+
+.settings-enter > * {
+  animation: rise 0.55s cubic-bezier(0.16, 1, 0.3, 1) both;
+}
+.settings-enter > *:nth-child(2) { animation-delay: 60ms; }
+.settings-enter > *:nth-child(3) { animation-delay: 120ms; }
+.settings-enter > *:nth-child(4) { animation-delay: 180ms; }
+.settings-enter > *:nth-child(n + 5) { animation-delay: 240ms; }
+
+.settings-title-in {
+  animation: blurin 0.55s cubic-bezier(0.16, 1, 0.3, 1) both;
+}
+
+.settings-shell {
+  animation: shell-in 0.42s cubic-bezier(0.16, 1, 0.3, 1) backwards;
+}
+
+.settings-glow {
+  background:
+    radial-gradient(120% 100% at 0% 0%, rgb(var(--accent) / 0.16), transparent 65%),
+    radial-gradient(80% 80% at 100% 0%, rgb(var(--accent) / 0.06), transparent 70%);
+}
+
+@keyframes shell-in {
+  from { opacity: 0; transform: translateY(18px) scale(0.975); filter: blur(6px); }
+  to { opacity: 1; transform: none; filter: blur(0); }
+}
+
+/* Model deck */
+.deck-scrim { animation: fade 0.25s ease-out both; }
+.deck-panel { animation: deck-in 0.5s cubic-bezier(0.16, 1, 0.3, 1) backwards; }
+.deck-row { animation: deck-row 0.4s cubic-bezier(0.16, 1, 0.3, 1) backwards; }
+.deck-pop { animation: scalein 0.5s cubic-bezier(0.34, 1.56, 0.64, 1) both; }
+.deck-aurora {
+  background:
+    radial-gradient(70% 120% at 12% 0%, rgb(var(--accent) / 0.18), transparent 70%),
+    radial-gradient(50% 100% at 95% 0%, rgb(var(--accent) / 0.07), transparent 70%);
+}
+.deck-throttle {
+  background-image: radial-gradient(rgb(var(--line)) 1px, transparent 1px);
+  background-size: 14px 14px;
+  background-color: rgb(var(--canvas) / 0.7);
+}
+.throttle-knob { box-shadow: 0 0 0 4px rgb(var(--accent) / 0.16), 0 6px 18px -6px rgb(var(--accent) / 0.55); }
+.throttle-knob::after {
+  content: '';
+  position: absolute;
+  inset: -6px;
+  border-radius: 9999px;
+  border: 1px solid rgb(var(--accent) / 0.5);
+  animation: ping 2.4s cubic-bezier(0, 0, 0.2, 1) infinite;
+}
+.deck-trigger:active { transform: scale(0.96); }
+
+@keyframes deck-in {
+  from { opacity: 0; transform: translateY(24px) scale(0.96); filter: blur(8px); }
+  to { opacity: 1; transform: none; filter: blur(0); }
+}
+@keyframes deck-row {
+  from { opacity: 0; transform: translateX(-10px); }
+  to { opacity: 1; transform: none; }
+}
+
+/* Diff rows slide in as a tool card opens. */
+.diff-row { animation: deck-row 0.35s cubic-bezier(0.16, 1, 0.3, 1) backwards; }
+.diff-badge { animation: scalein 0.4s cubic-bezier(0.34, 1.56, 0.64, 1) both; }
+
+/* Messages and tool rows arrive with a soft rise. */
+.msg-enter { animation: rise 0.5s cubic-bezier(0.16, 1, 0.3, 1) both; }
+
+/* Buttons feel physical. */
+button:not(:disabled) { -webkit-tap-highlight-color: transparent; }
+.chip, .nav-item, .sidebar-item { will-change: transform; }
+
+/* Streaming caret and send-button pulse while the agent works. */
+.session-card:hover { transform: translateX(2px); }
+
+@media (prefers-reduced-motion: reduce) {
+  *, *::before, *::after {
+    animation-duration: 0.001ms !important;
+    animation-iteration-count: 1 !important;
+    transition-duration: 0.001ms !important;
+    scroll-behavior: auto !important;
+  }
+}

package/src/lib/daemon.ts

@@ -7,6 +7,7 @@ import type {
   DeployProviderId,
   DeployRequest,
   DeployResult,
+  McpServer,
   ModelInfo,
   ProviderId,
   ProviderStatus,
@@ -274,6 +275,43 @@ export function forgetWorkspace(): Promise<WorkspaceInfo> {
   return api('/api/workspaces', { method: 'DELETE' })
 }
 
+/** Remove one folder from the saved list. The folder stays on disk. */
+export function removeWorkspaceFromList(path: string): Promise<WorkspaceInfo> {
+  return api(`/api/workspaces?path=${encodeURIComponent(path)}`, { method: 'DELETE' })
+}
+
+export type { McpServerInput } from './mcp-config'
+import type { McpServerInput } from './mcp-config'
+
+export function mcpList(): Promise<{ servers: McpServer[] }> {
+  return api('/api/mcp')
+}
+
+export function mcpSave(servers: McpServerInput[]): Promise<{ servers: McpServer[] }> {
+  return api('/api/mcp', { method: 'PUT', body: JSON.stringify({ servers }) })
+}
+
+export function mcpAction(id: string, action: 'connect' | 'disconnect' | 'refresh'): Promise<{ servers: McpServer[] }> {
+  return api(`/api/mcp/${encodeURIComponent(id)}/${action}`, { method: 'POST', body: '{}' })
+}
+
+export function mcpAuthorize(id: string): Promise<{ url: string }> {
+  return api(`/api/mcp/${encodeURIComponent(id)}/authorize`, { method: 'POST', body: '{}' })
+}
+
+export function mcpLogout(id: string): Promise<{ servers: McpServer[] }> {
+  return api(`/api/mcp/${encodeURIComponent(id)}/logout`, { method: 'POST', body: '{}' })
+}
+
+export function mcpCall(
+  server: string,
+  tool: string,
+  args: Record<string, unknown>,
+  signal?: AbortSignal,
+): Promise<{ result: { text: string; isError: boolean } }> {
+  return api('/api/mcp/call', { method: 'POST', body: JSON.stringify({ server, tool, args }), signal })
+}
+
 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)}`,

package/src/lib/diff.ts

@@ -0,0 +1,62 @@
+export interface DiffOp {
+  type: 'ctx' | 'add' | 'del'
+  text: string
+}
+
+/** Line diff via LCS on the changed middle; common head and tail are trimmed first. */
+export function diffLines(before: string, after: string): DiffOp[] {
+  const a = before === '' ? [] : before.split('\n')
+  const b = after === '' ? [] : after.split('\n')
+  let start = 0
+  while (start < a.length && start < b.length && a[start] === b[start]) start += 1
+  let endA = a.length
+  let endB = b.length
+  while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
+    endA -= 1
+    endB -= 1
+  }
+  const x = a.slice(start, endA)
+  const y = b.slice(start, endB)
+  const ops: DiffOp[] = a.slice(0, start).map((text) => ({ type: 'ctx', text }))
+
+  if (x.length * y.length > 2_000_000) {
+    x.forEach((text) => ops.push({ type: 'del', text }))
+    y.forEach((text) => ops.push({ type: 'add', text }))
+  } else {
+    const table: Uint32Array[] = Array.from({ length: x.length + 1 }, () => new Uint32Array(y.length + 1))
+    for (let i = x.length - 1; i >= 0; i -= 1) {
+      for (let j = y.length - 1; j >= 0; j -= 1) {
+        table[i][j] = x[i] === y[j] ? table[i + 1][j + 1] + 1 : Math.max(table[i + 1][j], table[i][j + 1])
+      }
+    }
+    let i = 0
+    let j = 0
+    while (i < x.length && j < y.length) {
+      if (x[i] === y[j]) {
+        ops.push({ type: 'ctx', text: x[i] })
+        i += 1
+        j += 1
+      } else if (table[i + 1][j] >= table[i][j + 1]) {
+        ops.push({ type: 'del', text: x[i] })
+        i += 1
+      } else {
+        ops.push({ type: 'add', text: y[j] })
+        j += 1
+      }
+    }
+    while (i < x.length) ops.push({ type: 'del', text: x[i++] })
+    while (j < y.length) ops.push({ type: 'add', text: y[j++] })
+  }
+  a.slice(endA).forEach((text) => ops.push({ type: 'ctx', text }))
+  return ops
+}
+
+export function diffStats(ops: DiffOp[]) {
+  let added = 0
+  let removed = 0
+  for (const op of ops) {
+    if (op.type === 'add') added += 1
+    else if (op.type === 'del') removed += 1
+  }
+  return { added, removed }
+}

package/src/lib/mcp-config.test.mjs

@@ -0,0 +1,47 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { draftFromServer, inputFromDraft, joinArgs, parseMcpJson, splitArgs } from './mcp-config.ts'
+
+test('imports Claude Desktop style config with local and remote servers', () => {
+  const { servers, skipped } = parseMcpJson(
+    JSON.stringify({
+      mcpServers: {
+        files: { command: 'npx', args: ['-y', 'server-filesystem', '/my dir'], env: { TOKEN: 'x' } },
+        linear: { url: 'https://mcp.linear.app/mcp' },
+        legacy: { url: 'https://example.com/sse', type: 'sse' },
+        keyed: { url: 'https://example.com/mcp', headers: { Authorization: 'Bearer k' } },
+        broken: { nothing: true },
+      },
+    }),
+  )
+  assert.deepEqual(skipped, ['broken'])
+  const byName = Object.fromEntries(servers.map((server) => [server.name, server]))
+  assert.equal(byName.files.transport, 'stdio')
+  assert.deepEqual(byName.files.args, ['-y', 'server-filesystem', '/my dir'])
+  assert.equal(byName.linear.transport, 'http')
+  assert.equal(byName.linear.oauth?.enabled, true)
+  assert.equal(byName.legacy.transport, 'sse')
+  assert.equal(byName.keyed.oauth, null)
+})
+
+test('accepts a single server object and rejects junk', () => {
+  assert.equal(parseMcpJson('{"command":"node","args":["a.js"]}').servers[0].name, 'Imported')
+  assert.throws(() => parseMcpJson('nope'), /valid JSON/)
+  assert.throws(() => parseMcpJson('{"a":1}'), /No MCP servers/)
+})
+
+test('draft round-trip keeps secrets masked and quoting intact', () => {
+  assert.deepEqual(splitArgs('-y "my dir" x'), ['-y', 'my dir', 'x'])
+  assert.equal(joinArgs(['-y', 'my dir']), '-y "my dir"')
+  const server = {
+    id: 'a', name: 'A', transport: 'http', enabled: false, approval: 'auto', disabledTools: ['t'], status: 'connected',
+    error: '', serverInfo: null, connectedAt: null, tools: [], url: 'https://x.dev/mcp', headers: { 'X-Key': '••••••••' },
+    oauth: { enabled: true, clientId: 'cid', clientSecret: '••••••••', scope: 'read', authorized: true },
+  }
+  const input = inputFromDraft(draftFromServer(server), server)
+  assert.equal(input.enabled, false)
+  assert.equal(input.approval, 'auto')
+  assert.equal(input.headers['X-Key'], '••••••••')
+  assert.equal(input.oauth.clientSecret, '••••••••')
+  assert.deepEqual(input.disabledTools, ['t'])
+})

package/src/lib/mcp-config.ts

@@ -0,0 +1,203 @@
+// Pure helpers for the MCP panel: form <-> config conversion, presets and JSON import.
+// Keep `import type` only here: node --test loads this file directly (see CLAUDE.md).
+import type { McpServer, McpTransport } from '../types'
+
+export interface McpServerInput {
+  id?: string
+  name: string
+  transport?: McpTransport
+  enabled?: boolean
+  approval?: 'auto' | 'ask'
+  disabledTools?: string[]
+  command?: string
+  args?: string[]
+  env?: Record<string, string>
+  url?: string
+  headers?: Record<string, string>
+  oauth?: { enabled: boolean; clientId?: string; clientSecret?: string; scope?: string } | null
+}
+
+export interface McpDraft {
+  /** Present when editing an existing server. */
+  id?: string
+  name: string
+  transport: McpTransport
+  command: string
+  args: string
+  env: string
+  url: string
+  headers: string
+  oauth: boolean
+  clientId: string
+  clientSecret: string
+  scope: string
+}
+
+export const EMPTY_DRAFT: McpDraft = {
+  name: '',
+  transport: 'stdio',
+  command: '',
+  args: '',
+  env: '',
+  url: '',
+  headers: '',
+  oauth: false,
+  clientId: '',
+  clientSecret: '',
+  scope: '',
+}
+
+export interface McpPreset {
+  label: string
+  description: string
+  draft: Partial<McpDraft>
+}
+
+export const MCP_PRESETS: McpPreset[] = [
+  { label: 'Filesystem', description: 'Read and write files in a folder', draft: { name: 'Filesystem', command: 'npx', args: '-y @modelcontextprotocol/server-filesystem .' } },
+  { label: 'Memory', description: 'Knowledge-graph memory', draft: { name: 'Memory', command: 'npx', args: '-y @modelcontextprotocol/server-memory' } },
+  { label: 'Fetch', description: 'Fetch web pages as markdown', draft: { name: 'Fetch', command: 'uvx', args: 'mcp-server-fetch' } },
+  { label: 'Linear', description: 'Issues and projects · OAuth', draft: { name: 'Linear', transport: 'http', url: 'https://mcp.linear.app/mcp', oauth: true } },
+  { label: 'Notion', description: 'Pages and databases · OAuth', draft: { name: 'Notion', transport: 'http', url: 'https://mcp.notion.com/mcp', oauth: true } },
+  { label: 'Sentry', description: 'Errors and traces · OAuth', draft: { name: 'Sentry', transport: 'http', url: 'https://mcp.sentry.dev/mcp', oauth: true } },
+  { label: 'Atlassian', description: 'Jira and Confluence · SSE + OAuth', draft: { name: 'Atlassian', transport: 'sse', url: 'https://mcp.atlassian.com/v1/sse', oauth: true } },
+  { label: 'DeepWiki', description: 'Repo docs · no sign-in', draft: { name: 'DeepWiki', transport: 'http', url: 'https://mcp.deepwiki.com/mcp' } },
+]
+
+/** Shell-like split that keeps quoted segments together. */
+export function splitArgs(value: string): string[] {
+  const out: string[] = []
+  const pattern = /"([^"]*)"|'([^']*)'|(\S+)/g
+  let match: RegExpExecArray | null
+  while ((match = pattern.exec(value))) out.push(match[1] ?? match[2] ?? match[3])
+  return out
+}
+
+export function joinArgs(args: string[] = []): string {
+  return args.map((arg) => (/\s/.test(arg) ? `"${arg}"` : arg)).join(' ')
+}
+
+export function parsePairs(value: string, separator: string): Record<string, string> {
+  const out: Record<string, string> = {}
+  for (const line of value.split('\n')) {
+    const index = line.indexOf(separator)
+    if (index < 1) continue
+    out[line.slice(0, index).trim()] = line.slice(index + 1).trim()
+  }
+  return out
+}
+
+export function formatPairs(record: Record<string, string> | undefined, separator: string): string {
+  return Object.entries(record ?? {})
+    .map(([key, value]) => `${key}${separator === ':' ? ': ' : separator}${value}`)
+    .join('\n')
+}
+
+export function draftFromServer(server: McpServer): McpDraft {
+  return {
+    id: server.id,
+    name: server.name,
+    transport: server.transport,
+    command: server.command ?? '',
+    args: joinArgs(server.args),
+    env: formatPairs(server.env, '='),
+    url: server.url ?? '',
+    headers: formatPairs(server.headers, ':'),
+    oauth: Boolean(server.oauth?.enabled),
+    clientId: server.oauth?.clientId ?? '',
+    clientSecret: server.oauth?.clientSecret ?? '',
+    scope: server.oauth?.scope ?? '',
+  }
+}
+
+export function draftIsValid(draft: McpDraft): boolean {
+  if (!draft.name.trim()) return false
+  if (draft.transport === 'stdio') return Boolean(draft.command.trim())
+  return /^https?:\/\//i.test(draft.url.trim())
+}
+
+/** Builds the payload for PUT /api/mcp. `previous` keeps flags the form does not edit. */
+export function inputFromDraft(draft: McpDraft, previous?: McpServer): McpServerInput {
+  const base = {
+    ...(draft.id ? { id: draft.id } : {}),
+    name: draft.name.trim(),
+    transport: draft.transport,
+    enabled: previous?.enabled ?? true,
+    approval: previous?.approval ?? ('ask' as const),
+    disabledTools: previous?.disabledTools ?? [],
+  }
+  if (draft.transport === 'stdio') {
+    return { ...base, command: draft.command.trim(), args: splitArgs(draft.args), env: parsePairs(draft.env, '=') }
+  }
+  return {
+    ...base,
+    url: draft.url.trim(),
+    headers: parsePairs(draft.headers, ':'),
+    oauth: draft.oauth
+      ? { enabled: true, clientId: draft.clientId.trim(), clientSecret: draft.clientSecret.trim(), scope: draft.scope.trim() }
+      : null,
+  }
+}
+
+export function inputFromServer(server: McpServer): McpServerInput {
+  return inputFromDraft(draftFromServer(server), server)
+}
+
+type Json = Record<string, unknown>
+const isObject = (value: unknown): value is Json => typeof value === 'object' && value !== null && !Array.isArray(value)
+const strings = (value: unknown): Record<string, string> => {
+  const out: Record<string, string> = {}
+  if (isObject(value)) for (const [key, item] of Object.entries(value)) if (typeof item === 'string' || typeof item === 'number') out[key] = String(item)
+  return out
+}
+
+function entryToInput(name: string, raw: Json): McpServerInput | null {
+  const enabled = raw.disabled === true ? false : true
+  const url = [raw.url, raw.serverUrl, raw.httpUrl].find((item): item is string => typeof item === 'string')
+  if (url) {
+    const kind = String(raw.type ?? raw.transport ?? '').toLowerCase()
+    const transport: McpTransport = kind.includes('sse') || (!kind && /\/sse\/?$/i.test(url)) ? 'sse' : 'http'
+    const headers = strings(raw.headers)
+    const hasAuthHeader = Object.keys(headers).some((key) => key.toLowerCase() === 'authorization')
+    return { name, transport, enabled, url, headers, oauth: hasAuthHeader ? null : { enabled: true } }
+  }
+  if (typeof raw.command === 'string' && raw.command.trim()) {
+    const args = Array.isArray(raw.args) ? raw.args.filter((item): item is string => typeof item === 'string') : []
+    return { name, transport: 'stdio', enabled, command: raw.command, args, env: strings(raw.env) }
+  }
+  return null
+}
+
+const looksLikeServer = (value: unknown) => isObject(value) && (typeof value.command === 'string' || typeof value.url === 'string' || typeof value.serverUrl === 'string' || typeof value.httpUrl === 'string')
+
+/** Accepts Claude Desktop / Cursor / VS Code style JSON ({ mcpServers | servers: {...} }) or one server object. */
+export function parseMcpJson(text: string): { servers: McpServerInput[]; skipped: string[] } {
+  let data: unknown
+  try {
+    data = JSON.parse(text)
+  } catch {
+    throw new Error('That is not valid JSON.')
+  }
+  if (!isObject(data)) throw new Error('Expected a JSON object.')
+  let map: Json | null = null
+  for (const candidate of [data.mcpServers, data.servers, isObject(data.mcp) ? data.mcp.servers : undefined]) {
+    if (isObject(candidate)) {
+      map = candidate
+      break
+    }
+  }
+  if (!map) {
+    if (looksLikeServer(data)) map = { Imported: data }
+    else if (Object.values(data).length > 0 && Object.values(data).every(looksLikeServer)) map = data
+  }
+  if (!map) throw new Error('No MCP servers found. Expect {"mcpServers": {"name": {"command": …} or {"url": …}}}.')
+  const servers: McpServerInput[] = []
+  const skipped: string[] = []
+  for (const [name, raw] of Object.entries(map)) {
+    const input = isObject(raw) ? entryToInput(name.slice(0, 60), raw) : null
+    if (input) servers.push(input)
+    else skipped.push(name)
+  }
+  if (servers.length === 0) throw new Error('None of those entries has a "command" or a "url".')
+  return { servers, skipped }
+}

package/src/lib/permissions.ts

@@ -1,4 +1,4 @@
-import type { AppSettings, ToolName, ToolSetting } from '../types'
+import type { AppSettings, BuiltinToolName, ToolSetting } from '../types'
 
 export type PermissionMode = 'ask' | 'accept-edits' | 'full'
 
@@ -20,8 +20,8 @@ export const PERMISSION_MODES: Array<{ value: PermissionMode; label: string; des
   },
 ]
 
-const WRITE_TOOLS: ToolName[] = ['write_file', 'edit_file', 'rewrite_file']
-const GUARDED_TOOLS: ToolName[] = ['shell', 'git', 'subagent']
+const WRITE_TOOLS: BuiltinToolName[] = ['write_file', 'edit_file', 'rewrite_file']
+const GUARDED_TOOLS: BuiltinToolName[] = ['shell', 'git', 'subagent']
 
 export function permissionMode(tools: AppSettings['tools']): PermissionMode {
   const writesAuto = WRITE_TOOLS.every((tool) => tools[tool]?.approval === 'auto')
@@ -34,9 +34,9 @@ export function permissionMode(tools: AppSettings['tools']): PermissionMode {
 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[]) {
+): Record<BuiltinToolName, ToolSetting> {
+  const next = {} as Record<BuiltinToolName, ToolSetting>
+  for (const key of Object.keys(tools) as BuiltinToolName[]) {
     const mutating = WRITE_TOOLS.includes(key) || GUARDED_TOOLS.includes(key)
     const approval: ToolSetting['approval'] =
       mode === 'full'

package/src/store/chats.ts

@@ -1,6 +1,7 @@
 import { create } from 'zustand'
 import type { AgentMode, ChatSession, Message, ProviderId } from '../types'
 import { csrfToken, saveChats } from '../lib/daemon'
+import { useWorkspace } from './workspace'
 
 function createId(prefix: string) {
   const raw =
@@ -46,6 +47,11 @@ function normalizeSession(session: ChatSession): ChatSession {
     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,
+    workspace: typeof session.workspace === 'string' ? session.workspace : undefined,
+    titleSource:
+      session.titleSource === 'ai' || session.titleSource === 'user' || session.titleSource === 'auto'
+        ? session.titleSource
+        : undefined,
   }
 }
 
@@ -110,6 +116,8 @@ export const useChats = create<ChatsState>()((set, get) => ({
       provider,
       model,
       mode,
+      workspace: useWorkspace.getState().info.root || undefined,
+      titleSource: 'auto',
     }
     set((state) => ({ sessions: [session, ...state.sessions], activeId: id }))
     return id
@@ -155,7 +163,7 @@ export const useChats = create<ChatsState>()((set, get) => ({
   renameSession: (sessionId, title) => {
     const clean = title.trim()
     if (!clean) return
-    get().updateSession(sessionId, { title: clean })
+    get().updateSession(sessionId, { title: clean, titleSource: 'user' })
   },
   deleteSession: (sessionId) => {
     set((state) => {