ethagent 2.4.0 → 3.0.0

package/src/chat/views/PermissionPrompt.tsx

@@ -72,16 +72,16 @@ export const PermissionPrompt: React.FC<PermissionPromptProps> = ({ request, onD
 export function permissionOptionsForRequest(request: PermissionRequest): Array<{ value: PermissionDecision; label: string; hint?: string; disabled?: boolean }> {
   if (request.kind === 'bash') {
     return [
-      { value: 'allow-once', label: 'Allow Once', hint: 'Approve only this command execution' },
+      { value: 'allow-once', label: 'Allow once', hint: 'Approve only this command execution' },
       {
         value: 'allow-command-project',
-        label: 'Allow Exact Command',
+        label: 'Allow exact command',
         hint: 'Remember this exact command for this project',
         disabled: !request.canPersistExact,
       },
       {
         value: 'allow-command-prefix-project',
-        label: request.commandPrefix ? `Allow ${request.commandPrefix} Commands` : 'Allow Command Family',
+        label: request.commandPrefix ? `Allow ${request.commandPrefix} commands` : 'Allow command family',
         hint: 'Remember this base command in this working directory for this project',
         disabled: !request.canPersistPrefix,
       },
@@ -91,63 +91,63 @@ export function permissionOptionsForRequest(request: PermissionRequest): Array<{
 
   if (request.kind === 'mcp') {
     const risk = request.destructive
-      ? 'server marks this tool as destructive'
+      ? 'Server marks this tool as destructive'
       : request.openWorld
-        ? 'server marks this tool as open-world'
+        ? 'Server marks this tool as open-world'
         : request.readOnly
-          ? 'server marks this tool as read-only'
-          : 'server did not mark this tool read-only'
+          ? 'Server marks this tool as read-only'
+          : 'Server did not mark this tool read-only'
     return [
-      { value: 'allow-once', label: 'allow once', hint: risk },
-      { value: 'allow-mcp-tool-project', label: 'always allow this MCP tool', hint: request.toolKey },
+      { value: 'allow-once', label: 'Allow once', hint: risk },
+      { value: 'allow-mcp-tool-project', label: 'Always allow this MCP tool', hint: request.toolKey },
       {
         value: 'allow-mcp-server-project',
-        label: `always allow ${request.serverName}`,
-        hint: 'remember all tools from this MCP server for this project',
+        label: `Always allow ${request.serverName}`,
+        hint: 'Remember all tools from this MCP server for this project',
         disabled: !request.canPersistServer,
       },
-      { value: 'deny', label: 'deny', hint: 'return a denial back to the model' },
+      { value: 'deny', label: 'Deny', hint: 'Return a denial back to the model' },
     ]
   }
 
   if (request.kind === 'delete') {
     return [
-      { value: 'allow-once', label: 'delete this file', hint: 'approve this deletion only' },
-      { value: 'deny', label: 'deny', hint: 'keep the file unchanged' },
+      { value: 'allow-once', label: 'Delete this file', hint: 'Approve this deletion only' },
+      { value: 'deny', label: 'Deny', hint: 'Keep the file unchanged' },
     ]
   }
 
   if (request.kind === 'private-continuity-read') {
     return [
-      { value: 'allow-once', label: 'allow once', hint: `read ${request.file}` },
-      { value: 'deny', label: 'deny', hint: 'keep private continuity hidden' },
+      { value: 'allow-once', label: 'Allow once', hint: `Read ${request.file}` },
+      { value: 'deny', label: 'Deny', hint: 'Keep private continuity hidden' },
     ]
   }
 
   if (request.kind === 'private-continuity-edit') {
     return [
-      { value: 'allow-once', label: 'Approve Once', hint: `Apply this edit to ${request.file}` },
+      { value: 'allow-once', label: 'Approve once', hint: `Apply this edit to ${request.file}` },
       { value: 'deny', label: 'Deny', hint: 'Keep private continuity unchanged' },
     ]
   }
 
   return [
-    { value: 'allow-once', label: 'allow once', hint: 'approve only this action' },
-    { value: 'allow-path-project', label: 'always allow this file', hint: request.relativePath },
-    { value: 'allow-directory-project', label: 'always allow this folder', hint: request.directoryPath },
+    { value: 'allow-once', label: 'Allow once', hint: 'Approve only this action' },
+    { value: 'allow-path-project', label: 'Always allow this file', hint: request.relativePath },
+    { value: 'allow-directory-project', label: 'Always allow this folder', hint: request.directoryPath },
     {
       value: 'allow-kind-project',
       label:
         request.kind === 'edit'
-          ? 'always allow edits'
+          ? 'Always allow edits'
           : request.kind === 'write'
-            ? 'always allow writes'
+            ? 'Always allow writes'
           : request.kind === 'cd'
-            ? 'always allow directory changes'
-            : 'always allow reads',
-      hint: 'remember this tool kind for this project',
+            ? 'Always allow directory changes'
+            : 'Always allow reads',
+      hint: 'Remember this tool kind for this project',
     },
-    { value: 'deny', label: 'deny', hint: 'return a denial back to the model' },
+    { value: 'deny', label: 'Deny', hint: 'Return a denial back to the model' },
   ]
 }
 

package/src/chat/views/PermissionsView.tsx

@@ -118,18 +118,24 @@ export const PermissionsView: React.FC<PermissionsViewProps> = ({
 }
 
 function buildOptions(rules: SessionPermissionRule[]): Array<SelectOption<SessionPermissionRule | typeof CLEAR_ALL_VALUE>> {
-  return [
-    ...rules.map(rule => ({
-      value: rule,
-      label: describeRule(rule),
-      hint: describeRuleScope(rule),
-    })),
-    {
-      value: CLEAR_ALL_VALUE,
-      label: 'Remove all saved rules',
-      hint: 'Clear all remembered permissions for this project',
-    },
-  ]
+  const out: Array<SelectOption<SessionPermissionRule | typeof CLEAR_ALL_VALUE>> = []
+  if (rules.length > 0) {
+    out.push({ value: CLEAR_ALL_VALUE, role: 'section', label: 'Saved Rules' })
+    for (const rule of rules) {
+      out.push({
+        value: rule,
+        label: describeRule(rule),
+        hint: describeRuleScope(rule),
+      })
+    }
+  }
+  out.push({ value: CLEAR_ALL_VALUE, role: 'section', label: 'Manage' })
+  out.push({
+    value: CLEAR_ALL_VALUE,
+    label: 'Remove all saved rules',
+    hint: 'Clear all remembered permissions for this project',
+  })
+  return out
 }
 
 function describeRule(rule: SessionPermissionRule): string {

package/src/chat/views/RewindView.tsx

@@ -142,11 +142,13 @@ export const RewindView: React.FC<RewindViewProps> = ({
     const canRestoreCode = selectedRow.entries.length > 0
 
     const actionOptions: Array<SelectOption<ConfirmOption>> = [
+      { value: 'both', role: 'section', label: 'Restore' },
       { value: 'both', prefix: '1.', label: 'Restore code and conversation', disabled: !canRestoreCode },
       { value: 'conversation', prefix: '2.', label: 'Restore conversation' },
       { value: 'code', prefix: '3.', label: 'Restore code', disabled: !canRestoreCode },
       { value: 'summarize', prefix: '4.', label: 'Summarize from here' },
-      { value: 'nevermind', prefix: '5.', label: 'Never mind' },
+      { value: 'nevermind', role: 'section', label: 'Navigation' },
+      { value: 'nevermind', prefix: '5.', label: 'Never mind', role: 'utility' },
     ]
     const defaultValue: ConfirmOption = canRestoreCode ? 'both' : 'conversation'
     const initialIndex = actionOptions.findIndex(option => option.value === defaultValue && !option.disabled)

package/src/cli/ResetConfirmView.tsx

@@ -5,6 +5,8 @@ import { Select } from '../ui/Select.js'
 import { theme } from '../ui/theme.js'
 import type { FactoryResetPlan } from '../storage/factoryReset.js'
 
+type SectionTone = 'destructive' | 'safe' | 'untouched'
+
 export const ResetConfirmView: React.FC<{
   plan: FactoryResetPlan
   onDone: (confirmed: boolean) => void
@@ -16,17 +18,22 @@ export const ResetConfirmView: React.FC<{
   }
 
   return (
-    <Surface title="Reset Local Data?" subtitle="Deletes this machine's ethagent data. Models and onchain records stay." footer="enter select · esc cancel">
+    <Surface
+      title="Reset Local Data?"
+      subtitle="Deletes this machine's ethagent data. Models and onchain records stay."
+      footer="enter select · esc cancel"
+      tone="error"
+    >
       <Box flexDirection="column">
-        <Section title="Deletes" lines={[
+        <Section tone="destructive" title="Deletes" lines={[
           'Identity files, sessions, history, credentials',
           localDataLine(plan.deletePaths.length),
         ]} />
-        <Section title="Keeps" lines={[
+        <Section tone="safe" title="Keeps" lines={[
           'Local GGUF models and llama.cpp runners',
           ...(plan.preservedPaths.length > 0 ? [`${plan.preservedPaths.length} local model path${plan.preservedPaths.length === 1 ? '' : 's'}`] : ['No local model assets found']),
         ]} />
-        <Section title="Not Touched" lines={[
+        <Section tone="untouched" title="Not Touched" lines={[
           'ERC-8004 tokens and onchain records',
           'IPFS snapshots and public metadata',
         ]} />
@@ -34,9 +41,11 @@ export const ResetConfirmView: React.FC<{
       <Box marginTop={1}>
         <Select<'confirm' | 'cancel'>
           options={[
-            { value: 'confirm', label: 'Reset Local Data', hint: 'Delete local ethagent data now' },
-            { value: 'cancel', label: 'Cancel', hint: 'Leave local data unchanged' },
+            { value: 'confirm', label: 'Yes, reset local data', hint: 'Delete local ethagent data on this machine', bold: true },
+            { value: 'cancel', label: 'No, cancel', hint: 'Leave local data unchanged', role: 'utility' },
           ]}
+          hintLayout="inline"
+          initialIndex={1}
           onSubmit={choice => finish(choice === 'confirm')}
           onCancel={() => finish(false)}
         />
@@ -45,15 +54,21 @@ export const ResetConfirmView: React.FC<{
   )
 }
 
-const Section: React.FC<{ title: string; lines: string[] }> = ({ title, lines }) => (
+const Section: React.FC<{ tone: SectionTone; title: string; lines: string[] }> = ({ tone, title, lines }) => (
   <Box flexDirection="column" marginBottom={1}>
-    <Text color={theme.accentPeriwinkle}>{title}</Text>
+    <Text color={sectionTitleColor(tone)}>{title}</Text>
     {lines.map(line => (
-      <Text key={line} color={theme.textSubtle}>- {line}</Text>
+      <Text key={line} color={theme.textSubtle}>· {line}</Text>
     ))}
   </Box>
 )
 
+function sectionTitleColor(tone: SectionTone): string {
+  if (tone === 'destructive') return theme.accentError
+  if (tone === 'safe') return theme.accentPeriwinkle
+  return theme.dim
+}
+
 function localDataLine(count: number): string {
   if (count === 0) return 'No local ethagent data found'
   return `${count} local path${count === 1 ? '' : 's'} under ~/.ethagent`

package/src/identity/continuity/editor.ts

@@ -12,9 +12,20 @@ type EditorCommand = {
   shell?: boolean
 }
 
-export function openFileInEditor(file: string): Promise<EditorOpenResult> {
+export async function openFileInEditor(file: string): Promise<EditorOpenResult> {
+  if (isVscodeEnvironment()) {
+    const vscode = vscodeEditorCommand(file)
+    const result = await openEditorCommand(vscode)
+    if (result.ok) return result
+  }
   const command = defaultEditorCommand(file)
-  if (!command) return Promise.resolve({ ok: false, error: 'no default open command for this platform' })
+  if (!command) return { ok: false, error: 'no default open command for this platform' }
+  return openEditorCommand(command)
+}
+
+export async function openInFileManager(target: string): Promise<EditorOpenResult> {
+  const command = defaultEditorCommand(target)
+  if (!command) return { ok: false, error: 'no default open command for this platform' }
   return openEditorCommand(command)
 }
 
@@ -47,3 +58,17 @@ export function defaultEditorCommand(file: string, platform: NodeJS.Platform = p
   if (platform === 'darwin') return { cmd: 'open', args: [file], method: 'open', waited: false }
   return { cmd: 'xdg-open', args: [file], method: 'xdg-open', waited: false }
 }
+
+export function isVscodeEnvironment(env: NodeJS.ProcessEnv = process.env): boolean {
+  if (env.TERM_PROGRAM === 'vscode') return true
+  if (env.VSCODE_PID) return true
+  if (env.VSCODE_GIT_IPC_HANDLE) return true
+  return false
+}
+
+export function vscodeEditorCommand(file: string, platform: NodeJS.Platform = process.platform): EditorCommand {
+  if (platform === 'win32') {
+    return { cmd: 'cmd', args: ['/c', 'code', '--reuse-window', file], method: 'vscode', waited: false }
+  }
+  return { cmd: 'code', args: ['--reuse-window', file], method: 'vscode', waited: false }
+}

package/src/identity/continuity/envelope.ts

@@ -10,6 +10,16 @@ export type ContinuityFiles = {
   'MEMORY.md': string
 }
 
+export type ContinuitySkillsTree = Record<string, string>
+
+const PRIVATE_SKILL_FILE_RE = /^[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)+$/
+const PRIVATE_SKILL_LAST_SEG_FILE_RE = /^[A-Za-z0-9._-]+\.[A-Za-z0-9]+$/
+const LEGACY_NESTED_SKILL_RE = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+\/.+$/
+const LEGACY_FLAT_NAME_MD_RE = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+\.md$/i
+const MAX_PRIVATE_SKILL_ENTRIES = 500
+const MAX_PRIVATE_SKILL_BODY_BYTES = 256 * 1024
+const MAX_PRIVATE_SKILL_PATH_LEN = 256
+
 type ContinuityTranscriptSummary = {
   sessionId?: string
   createdAt?: string
@@ -33,6 +43,7 @@ type ContinuitySnapshotPayload = {
   sequence?: number
   agent: ContinuityAgentSnapshot
   files: ContinuityFiles
+  skills?: ContinuitySkillsTree
   transcript: ContinuityTranscriptSummary[]
   state: Record<string, unknown>
 }
@@ -997,6 +1008,7 @@ function continuityPayloadFromArgs(args: {
   createdAt: string
   payload: Omit<ContinuitySnapshotPayload, 'version' | 'ownerAddress' | 'createdAt'> & { createdAt?: string }
 }): ContinuitySnapshotPayload {
+  const skills = normalizeContinuitySkills(args.payload.skills)
   return {
     version: 1,
     ownerAddress: args.ownerAddress,
@@ -1004,6 +1016,7 @@ function continuityPayloadFromArgs(args: {
     ...(args.payload.sequence !== undefined ? { sequence: args.payload.sequence } : {}),
     agent: normalizeAgentSnapshot(args.payload.agent),
     files: normalizeContinuityFiles(args.payload.files),
+    ...(skills ? { skills } : {}),
     transcript: normalizeTranscript(args.payload.transcript),
     state: normalizeState(args.payload.state),
   }
@@ -1015,6 +1028,7 @@ function normalizeContinuityPayload(input: unknown): ContinuitySnapshotPayload {
   if (obj.version !== 1) throw new Error('Continuity snapshot payload version is invalid')
   if (typeof obj.ownerAddress !== 'string') throw new Error('Continuity snapshot owner is invalid')
   if (typeof obj.createdAt !== 'string') throw new Error('Continuity snapshot timestamp is invalid')
+  const skills = normalizeContinuitySkills(obj.skills)
   return {
     version: 1,
     ownerAddress: toChecksumAddress(obj.ownerAddress),
@@ -1022,11 +1036,122 @@ function normalizeContinuityPayload(input: unknown): ContinuitySnapshotPayload {
     ...(typeof obj.sequence === 'number' && Number.isSafeInteger(obj.sequence) ? { sequence: obj.sequence } : {}),
     agent: normalizeAgentSnapshot(obj.agent),
     files: normalizeContinuityFiles(obj.files),
+    ...(skills ? { skills } : {}),
     transcript: normalizeTranscript(obj.transcript),
     state: normalizeState(obj.state),
   }
 }
 
+export function normalizeContinuitySkills(input: unknown): ContinuitySkillsTree | undefined {
+  if (input === undefined || input === null) return undefined
+  if (typeof input !== 'object' || Array.isArray(input)) return undefined
+  const obj = input as Record<string, unknown>
+  const out: ContinuitySkillsTree = {}
+  let count = 0
+  const tryInsert = (key: string, rawValue: unknown): void => {
+    if (count >= MAX_PRIVATE_SKILL_ENTRIES) return
+    if (typeof rawValue !== 'string') return
+    if (key.length === 0 || key.length > MAX_PRIVATE_SKILL_PATH_LEN) return
+    if (key.includes('\0')) return
+    if (key.includes('..')) return
+    if (key.startsWith('/')) return
+    if (/^[A-Za-z]:/.test(key)) return
+    if (!isAcceptableSkillKey(key)) return
+    if (Buffer.byteLength(rawValue, 'utf8') > MAX_PRIVATE_SKILL_BODY_BYTES) return
+    if (out[key] !== undefined) return
+    out[key] = rawValue
+    count++
+  }
+  const legacyRoots = new Set<string>()
+  const realSkillFolders = new Set<string>()
+  for (const rawKey of Object.keys(obj)) {
+    const key = rawKey.replace(/\\/g, '/')
+    const segments = key.split('/')
+    if (segments.length === 3 && segments[2] === 'SKILL.md' && segments[0] && segments[1]) {
+      legacyRoots.add(`${segments[0]}/${segments[1]}`)
+    }
+    if (segments.length === 2 && segments[1] === 'SKILL.md' && segments[0]) {
+      realSkillFolders.add(segments[0])
+    }
+  }
+  for (const [rawKey, rawValue] of Object.entries(obj)) {
+    const key = rawKey.replace(/\\/g, '/')
+    if (!isCanonicalFlatKey(key)) continue
+    if (isUnderLegacyRoot(key, legacyRoots)) continue
+    if (!keyHasRealSkillFolder(key, realSkillFolders)) continue
+    tryInsert(key, rawValue)
+  }
+  for (const [rawKey, rawValue] of Object.entries(obj)) {
+    const key = rawKey.replace(/\\/g, '/')
+    if (
+      isCanonicalFlatKey(key)
+      && !isUnderLegacyRoot(key, legacyRoots)
+      && keyHasRealSkillFolder(key, realSkillFolders)
+    ) continue
+    const upgraded = upgradeLegacySkillKey(key, legacyRoots)
+    if (!upgraded) continue
+    tryInsert(upgraded, rawValue)
+  }
+  return count > 0 ? out : undefined
+}
+
+function isUnderLegacyRoot(key: string, legacyRoots: Set<string>): boolean {
+  for (const root of legacyRoots) {
+    if (key === `${root}/SKILL.md`) return true
+    if (key.startsWith(`${root}/`)) return true
+  }
+  return false
+}
+
+function keyHasRealSkillFolder(key: string, realSkillFolders: Set<string>): boolean {
+  const first = key.split('/')[0]
+  if (!first) return false
+  return realSkillFolders.has(first)
+}
+
+function isCanonicalFlatKey(key: string): boolean {
+  if (!PRIVATE_SKILL_FILE_RE.test(key)) return false
+  const segments = key.split('/')
+  if (segments.length < 2) return false
+  const last = segments[segments.length - 1]!
+  if (last === 'SKILL.md') return segments.length === 2
+  return PRIVATE_SKILL_LAST_SEG_FILE_RE.test(last)
+}
+
+function isAcceptableSkillKey(key: string): boolean {
+  return isCanonicalFlatKey(key)
+}
+
+function upgradeLegacySkillKey(key: string, legacyRoots: Set<string>): string | null {
+  for (const root of legacyRoots) {
+    if (key === `${root}/SKILL.md` || key.startsWith(`${root}/`)) {
+      const [first, second] = root.split('/')
+      if (!first || !second) continue
+      const rest = key.slice(root.length + 1)
+      const flattened = `${first}-${second}/${rest}`
+      return isCanonicalFlatKey(flattened) ? flattened : null
+    }
+  }
+  if (LEGACY_FLAT_NAME_MD_RE.test(key)) {
+    const [category, file] = key.split('/')
+    if (!category || !file) return null
+    const slug = file.replace(/\.md$/i, '')
+    if (!slug) return null
+    const flattened = `${category}-${slug}/SKILL.md`
+    return isCanonicalFlatKey(flattened) ? flattened : null
+  }
+  if (LEGACY_NESTED_SKILL_RE.test(key)) {
+    const segments = key.split('/')
+    if (segments.length < 3) return null
+    const [first, second, ...rest] = segments
+    if (!first || !second || rest.length === 0) return null
+    const flattened = `${first}-${second}/${rest.join('/')}`
+    return isCanonicalFlatKey(flattened) ? flattened : null
+  }
+  if (isCanonicalFlatKey(key)) return key
+  return null
+}
+
 function normalizeAgentSnapshot(input: unknown): ContinuityAgentSnapshot {
   if (!input || typeof input !== 'object' || Array.isArray(input)) return {}
   const obj = input as Record<string, unknown>

package/src/identity/continuity/publicSkills.ts

@@ -1,4 +1,5 @@
 import type { EthagentIdentity } from '../../storage/config.js'
+import type { SkillIndexEntry } from './skills/types.js'
 
 type PublicSkill = {
   id: string
@@ -45,7 +46,7 @@ export function defaultPublicSkillsProfile(identity: EthagentIdentity): PublicSk
     : identity.agentId ? `ethagent #${identity.agentId}` : 'ethagent'
   const description = typeof state.description === 'string' && state.description.trim()
     ? state.description.trim()
-    : 'A wallet-owned AI coding agent.'
+    : 'privacy-first AI agent with a portable Ethereum identity'
   const imageUrl = typeof state.imageUrl === 'string' && state.imageUrl.trim()
     ? state.imageUrl.trim()
     : undefined
@@ -80,6 +81,41 @@ export function defaultPublicSkillsProfile(identity: EthagentIdentity): PublicSk
   }
 }
 
+export function appendPublicSkillEntries(
+  profile: PublicSkillsProfile,
+  entries: readonly SkillIndexEntry[],
+): PublicSkillsProfile {
+  if (entries.length === 0) return profile
+  const baselineIds = new Set(profile.skills.map(skill => skill.id))
+  const appended: PublicSkill[] = []
+  const usedIds = new Set(baselineIds)
+  for (const entry of entries) {
+    if (entry.visibility !== 'public' && entry.visibility !== 'discoverable') continue
+    const id = uniqueSkillId(entry.name, usedIds)
+    usedIds.add(id)
+    appended.push({
+      id,
+      name: entry.displayName ?? entry.name,
+      description: entry.description || entry.name,
+      inputModes: ['text/markdown'],
+      outputModes: ['text/markdown'],
+    })
+  }
+  if (appended.length === 0) return profile
+  return {
+    ...profile,
+    skills: [...profile.skills, ...appended],
+  }
+}
+
+function uniqueSkillId(base: string, used: Set<string>): string {
+  const slug = base.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'skill'
+  if (!used.has(slug)) return slug
+  let i = 2
+  while (used.has(`${slug}-${i}`)) i++
+  return `${slug}-${i}`
+}
+
 export function renderPublicSkillsJson(profile: PublicSkillsProfile): string {
   const inputModes = unique(profile.skills.flatMap(skill => skill.inputModes))
   const outputModes = unique(profile.skills.flatMap(skill => skill.outputModes))