ethagent 2.3.0 → 3.0.0

package/src/tools/readSkillTool.ts

@@ -0,0 +1,107 @@
+import path from 'node:path'
+import { z } from 'zod'
+import {
+  continuityVaultRef,
+} from '../identity/continuity/storage.js'
+import {
+  readSkill,
+  readSkillFile,
+} from '../identity/continuity/skills/loadSkills.js'
+import type { Tool } from './contracts.js'
+
+const schema = z.object({
+  name: z.string().min(1),
+  file: z.string().min(1).optional(),
+})
+
+export const readSkillTool: Tool<typeof schema> = {
+  name: 'read_private_skill',
+  kind: 'private-continuity-read',
+  readOnly: true,
+  description: [
+    'Read a file from the owner-authored private skill folder for the active identity.',
+    'Pass the skill folder name as `name` (e.g. "writing-obit"). Without `file`, returns the SKILL.md entry point.',
+    'With `file`, returns a supporting file from the same folder (e.g. file: "references/api.md"). Supporting-file responses include an absolute filesystem `path=` attribute; run executable scripts via run_bash using that absolute path.',
+    'List available supporting files with list_private_skill_files. Bodies are markdown and may include private instructions; treat them like SOUL.md guidance.',
+  ].join(' '),
+  inputSchema: schema,
+  inputSchemaJson: {
+    type: 'object',
+    properties: {
+      name: { type: 'string', description: 'Skill folder name from the private skills index, e.g. "writing-obit".' },
+      file: { type: 'string', description: 'Optional supporting file path inside the skill folder. Defaults to SKILL.md.' },
+    },
+    required: ['name'],
+    additionalProperties: false,
+  },
+  parse(input) {
+    return schema.parse(input)
+  },
+  async buildPermissionRequest(input, context) {
+    const identity = context.config?.identity
+    if (!identity) throw new Error('No active identity; create or load an identity before reading a private skill')
+    const ref = continuityVaultRef(identity)
+    const folder = input.name.replace(/^.*:/, '')
+    const file = input.file ?? 'SKILL.md'
+    const skillPath = path.join(ref.skillsDir, folder, file)
+    const display = input.file ? `${folder}/${input.file}` : `${folder}/SKILL.md`
+    return {
+      kind: 'private-skill-read',
+      path: skillPath,
+      relativePath: `identity-vault/skills/${display}`,
+      directoryPath: path.dirname(skillPath),
+      title: 'Allow private skill read?',
+      subtitle: `Load ${display}`,
+      skillName: input.name,
+      mode: 'read',
+    }
+  },
+  async execute(input, context) {
+    const identity = context.config?.identity
+    if (!identity) {
+      return { ok: false, summary: 'no active identity', content: 'No active identity; cannot read private skill.' }
+    }
+    try {
+      const folder = input.name.replace(/^.*:/, '')
+      if (input.file && input.file !== 'SKILL.md') {
+        const result = await readSkillFile(identity, folder, input.file)
+        return {
+          ok: true,
+          summary: `read ${result.relativePath}`,
+          content: [
+            `<private_skill_file name="${folder}" file="${input.file}" path="${result.absolutePath}">`,
+            result.content,
+            '</private_skill_file>',
+          ].join('\n'),
+        }
+      }
+      const skill = await readSkill(identity, folder)
+      const meta: string[] = []
+      meta.push(`name: ${skill.displayName ?? skill.name}`)
+      if (skill.whenToUse) meta.push(`when_to_use: ${skill.whenToUse}`)
+      if (skill.argumentHint) meta.push(`argument_hint: ${skill.argumentHint}`)
+      if (skill.version) meta.push(`version: ${skill.version}`)
+      if (skill.tags && skill.tags.length > 0) meta.push(`tags: ${skill.tags.join(', ')}`)
+      meta.push(`visibility: ${skill.visibility}`)
+      const content = [
+        `<private_skill name="${skill.name}" visibility="${skill.visibility}">`,
+        ...meta,
+        '',
+        skill.body,
+        '</private_skill>',
+      ].join('\n')
+      return {
+        ok: true,
+        summary: `read private skill ${skill.name}`,
+        content,
+      }
+    } catch (err: unknown) {
+      const message = (err as Error).message
+      return {
+        ok: false,
+        summary: 'read failed',
+        content: message,
+      }
+    }
+  },
+}

package/src/tools/readTool.ts

@@ -37,7 +37,7 @@ export const readTool: Tool<typeof schema> = {
       path: fullPath,
       relativePath,
       directoryPath: path.dirname(fullPath),
-      title: 'allow file read?',
+      title: 'Allow file read?',
       subtitle: input.startLine || input.endLine
         ? `${fullPath} · lines ${input.startLine ?? 1}-${input.endLine ?? 'end'}`
         : fullPath,

package/src/tools/registry.ts

@@ -8,8 +8,11 @@ import { changeDirectoryTool } from './changeDirectoryTool.js'
 import { deleteFileTool } from './deleteFileTool.js'
 import { editTool } from './editTool.js'
 import { listDirectoryTool } from './listDirectoryTool.js'
+import { listSkillsTool } from './listSkillsTool.js'
+import { listSkillFilesTool } from './listSkillFilesTool.js'
 import { privateContinuityEditTool } from './privateContinuityEditTool.js'
 import { privateContinuityReadTool } from './privateContinuityReadTool.js'
+import { readSkillTool } from './readSkillTool.js'
 import { readTool } from './readTool.js'
 import { listMcpResourcesTool, readMcpResourceTool } from './mcpResourceTools.js'
 import { writeFileTool } from './writeFileTool.js'
@@ -19,6 +22,9 @@ export const BUILTIN_TOOLS: Tool[] = [
   listDirectoryTool,
   readTool,
   privateContinuityReadTool,
+  listSkillsTool,
+  listSkillFilesTool,
+  readSkillTool,
   listMcpResourcesTool,
   readMcpResourceTool,
   writeFileTool,

package/src/tools/writeFileTool.ts

@@ -28,7 +28,7 @@ export const writeFileTool: Tool<typeof schema> = {
     required: ['path', 'content'],
   },
   parse(input) {
-    return schema.parse(input)
+    return schema.parse(normalizeWriteFileInput(input))
   },
   async buildPermissionRequest(input, context) {
     const prepared = await prepareWrite(input, context)
@@ -37,7 +37,7 @@ export const writeFileTool: Tool<typeof schema> = {
       path: prepared.fullPath,
       relativePath: prepared.relativePath,
       directoryPath: path.dirname(prepared.fullPath),
-      title: prepared.existedBefore ? 'allow file rewrite?' : 'allow file creation?',
+      title: prepared.existedBefore ? 'Allow file rewrite?' : 'Allow file creation?',
       subtitle: prepared.fullPath,
       before: previewText(prepared.before),
       after: previewText(input.content),
@@ -76,6 +76,26 @@ export const writeFileTool: Tool<typeof schema> = {
   },
 }
 
+function normalizeWriteFileInput(input: unknown): unknown {
+  let value: unknown = input
+  if (typeof value === 'string') {
+    const trimmed = value.trim()
+    if (trimmed.startsWith('{')) {
+      try {
+        value = JSON.parse(trimmed)
+      } catch {
+        return input
+      }
+    }
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return value
+  const normalized: Record<string, unknown> = { ...(value as Record<string, unknown>) }
+  if (typeof normalized.path === 'string' && normalized.path.trim() === '') {
+    normalized.path = undefined
+  }
+  return normalized
+}
+
 async function prepareWrite(
   input: z.infer<typeof schema>,
   context: { workspaceRoot: string; config?: EthagentConfig },

package/src/ui/Spinner.tsx

@@ -243,7 +243,7 @@ export const Spinner: React.FC<SpinnerProps> = ({
   useEffect(() => {
     if (!active) return
     internalStartedAtRef.current = startedAt ?? Date.now()
-  }, [active, startedAt, label, verb])
+  }, [active, startedAt])
 
   useEffect(() => {
     if (!active) return
@@ -295,8 +295,20 @@ export const Spinner: React.FC<SpinnerProps> = ({
 function formatElapsedSeconds(milliseconds: number): string {
   const seconds = Math.max(0, Math.floor(milliseconds / 1000))
   if (seconds < 60) return `${seconds}s`
-  const minutes = Math.floor(seconds / 60)
-  return `${minutes}:${(seconds % 60).toString().padStart(2, '0')}`
+
+  const hours = Math.floor(seconds / 3600)
+  const minutes = Math.floor((seconds % 3600) / 60)
+  const remainingSeconds = seconds % 60
+
+  if (hours > 0) {
+    return remainingSeconds > 0
+      ? `${hours}h ${minutes}min ${remainingSeconds}s`
+      : `${hours}h ${minutes}min`
+  }
+
+  return remainingSeconds > 0
+    ? `${minutes}min ${remainingSeconds}s`
+    : `${minutes}min`
 }
 
 function restoreSpinnerTerms(value: string): string {

package/src/ui/theme.ts

@@ -11,6 +11,8 @@ export const theme = {
   accentBlue: '#e8eefd',
   accentWhite: '#f5f8ff',
   accentError: '#d99898',
+  modePlan: '#f0c7a8',
+  modeAcceptEdits: '#c7b6f2',
   diffAdded: '#8fd49d',
   diffRemoved: '#d99898',
   diffAddedBackground: '#16351f',

package/src/utils/images.ts

@@ -0,0 +1,140 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import type { ImageBlock, Message, MessageContentBlock } from '../providers/contracts.js'
+
+const IMAGE_MARKER_RE = /\[image:\s*([^\]]+?)\]/gi
+const PLACEHOLDER_RE = /^([<{[].*[>}\]]|#\d+)$/
+
+export class ImageLoadError extends Error {
+  readonly imagePath: string
+  constructor(imagePath: string, message: string) {
+    super(message)
+    this.name = 'ImageLoadError'
+    this.imagePath = imagePath
+  }
+}
+
+export function collapseImagePathsToRefs(text: string): string {
+  let counter = 0
+  return text.replace(IMAGE_MARKER_RE, (full, raw: string) => {
+    const trimmed = raw.trim()
+    if (!trimmed || PLACEHOLDER_RE.test(trimmed)) return full
+    counter += 1
+    return `[Image #${counter}]`
+  })
+}
+
+export function modelSupportsImages(
+  provider: string,
+  model: string,
+  extra?: { mmprojPath?: string },
+): boolean {
+  const normalized = model.toLowerCase()
+  switch (provider) {
+    case 'anthropic':
+      return /claude-3|claude-sonnet-4|claude-opus-4|claude-haiku-4/.test(normalized)
+    case 'gemini':
+      return /gemini-1\.5|gemini-2\.0|gemini-2\.5/.test(normalized)
+    case 'openai':
+      if (normalized.includes('gpt-3.5')) return false
+      return /gpt-4o|gpt-4\.1|gpt-4-turbo|gpt-4-vision|gpt-5|o1|o3|o4|chatgpt-4/.test(normalized)
+    case 'llamacpp':
+      return Boolean(extra?.mmprojPath)
+    default:
+      return false
+  }
+}
+
+export function hasImageBlocks(messages: Message[]): boolean {
+  return messages.some(message => Array.isArray(message.content) && message.content.some(block => block.type === 'image'))
+}
+
+export function userTextToContentBlocks(text: string): string | MessageContentBlock[] {
+  const blocks = parseImageMarkers(text)
+  return blocks.length === 1 && blocks[0]?.type === 'text' ? blocks[0].text : blocks
+}
+
+export function parseImageMarkers(text: string): MessageContentBlock[] {
+  const out: MessageContentBlock[] = []
+  let lastIndex = 0
+  let match: RegExpExecArray | null
+
+  while ((match = IMAGE_MARKER_RE.exec(text)) !== null) {
+    const full = match[0]
+    const rawPath = match[1]?.trim() ?? ''
+    if (match.index > lastIndex) {
+      const prefix = text.slice(lastIndex, match.index)
+      if (prefix) out.push({ type: 'text', text: prefix })
+    }
+    if (rawPath && !PLACEHOLDER_RE.test(rawPath)) {
+      out.push({ type: 'image', path: rawPath })
+    } else {
+      out.push({ type: 'text', text: full })
+    }
+    lastIndex = match.index + full.length
+  }
+
+  if (lastIndex < text.length) {
+    const suffix = text.slice(lastIndex)
+    if (suffix) out.push({ type: 'text', text: suffix })
+  }
+
+  if (out.length === 0) return text ? [{ type: 'text', text }] : []
+  return mergeAdjacentTextBlocks(out)
+}
+
+export async function loadImageBlock(block: ImageBlock): Promise<ImageBlock> {
+  if (block.dataBase64 && block.mimeType) return block
+  if (block.url) return block
+  const rawPath = block.path?.trim() ?? ''
+  if (!rawPath) throw new ImageLoadError(rawPath, 'image path is empty')
+  if (PLACEHOLDER_RE.test(rawPath)) {
+    throw new ImageLoadError(rawPath, `image path looks like a placeholder, not a real file: ${rawPath}`)
+  }
+  let file: Buffer
+  try {
+    file = await fs.readFile(rawPath)
+  } catch (err: unknown) {
+    const code = (err as NodeJS.ErrnoException).code
+    if (code === 'ENOENT') {
+      throw new ImageLoadError(rawPath, `image file not found: ${rawPath}`)
+    }
+    throw new ImageLoadError(rawPath, `could not read image at ${rawPath}: ${(err as Error).message}`)
+  }
+  const mimeType = block.mimeType ?? mimeTypeForPath(rawPath)
+  return {
+    ...block,
+    path: rawPath,
+    mimeType,
+    dataBase64: file.toString('base64'),
+  }
+}
+
+export function imagePlaceholder(pathValue: string): string {
+  return `[image: ${path.basename(pathValue)}]`
+}
+
+function mergeAdjacentTextBlocks(blocks: MessageContentBlock[]): MessageContentBlock[] {
+  const out: MessageContentBlock[] = []
+  for (const block of blocks) {
+    const prev = out[out.length - 1]
+    if (block.type === 'text' && prev?.type === 'text') {
+      prev.text += block.text
+      continue
+    }
+    out.push(block)
+  }
+  return out
+}
+
+function mimeTypeForPath(filePath: string): string {
+  switch (path.extname(filePath).toLowerCase()) {
+    case '.png': return 'image/png'
+    case '.jpg':
+    case '.jpeg': return 'image/jpeg'
+    case '.webp': return 'image/webp'
+    case '.gif': return 'image/gif'
+    case '.bmp': return 'image/bmp'
+    default: return 'application/octet-stream'
+  }
+}

package/src/utils/messages.ts

@@ -1,3 +1,4 @@
+import path from 'node:path'
 import type { Message, MessageContentBlock } from '../providers/contracts.js'
 
 export function systemMessage(content: string): Message {
@@ -20,6 +21,7 @@ export function blocksToText(blocks: MessageContentBlock[]): string {
   return blocks
     .map(block => {
       if (block.type === 'text') return block.text
+      if (block.type === 'image') return `[image attached: ${path.basename(block.path)}]`
       if (block.type === 'tool_use') return `[tool use: ${block.name}]`
       return block.isError
         ? `[tool error: ${block.content}]`

package/src/identity/continuity/localBackup.ts

@@ -1,249 +0,0 @@
-import { spawn } from 'node:child_process'
-import fs from 'node:fs'
-import fsp from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import type { EthagentIdentity } from '../../storage/config.js'
-import { continuityVaultRef } from './storage.js'
-import { buildZip, type ZipEntry } from './zipWriter.js'
-
-type LocalBackupResult =
-  | { ok: true; path: string; method: string }
-  | { ok: false; cancelled: boolean; error: string }
-
-type SaveDialogCommand = {
-  cmd: string
-  args: string[]
-  method: string
-}
-
-export async function exportLocalBackup(
-  identity: EthagentIdentity,
-  options: {
-    platform?: NodeJS.Platform
-    env?: NodeJS.ProcessEnv
-    timeoutMs?: number
-    spawnImpl?: typeof spawn
-    homeDir?: string
-  } = {},
-): Promise<LocalBackupResult> {
-  const platform = options.platform ?? process.platform
-  const env = options.env ?? process.env
-  const homeDir = options.homeDir ?? os.homedir()
-  const ref = continuityVaultRef(identity)
-
-  const entries: ZipEntry[] = []
-  for (const [name, file] of [
-    ['SOUL.md', ref.soulPath],
-    ['MEMORY.md', ref.memoryPath],
-    ['skills.json', ref.publicSkillsPath],
-  ] as const) {
-    try {
-      const data = await fsp.readFile(file)
-      entries.push({ name, data })
-    } catch (err: unknown) {
-      const code = (err as NodeJS.ErrnoException).code
-      if (code !== 'ENOENT') {
-        return { ok: false, cancelled: false, error: `read ${name} failed: ${(err as Error).message}` }
-      }
-    }
-  }
-  if (entries.length === 0) {
-    return { ok: false, cancelled: false, error: 'no local continuity files to back up' }
-  }
-
-  const archive = buildZip(entries)
-  const defaultName = defaultBackupFilename(identity)
-  const dialog = resolveSaveDialogCommand(platform, env, defaultName)
-
-  if (dialog) {
-    const chosen = await runSaveDialog(dialog, options.spawnImpl ?? spawn, options.timeoutMs ?? 120_000)
-    if (chosen.ok) {
-      const target = ensureZipExtension(chosen.file)
-      try {
-        await fsp.writeFile(target, archive)
-        return { ok: true, path: target, method: dialog.method }
-      } catch (err: unknown) {
-        return { ok: false, cancelled: false, error: `write failed: ${(err as Error).message}` }
-      }
-    }
-    if (!chosen.cancelled) {
-      const fallback = path.join(homeDir, defaultName)
-      try {
-        await fsp.writeFile(fallback, archive)
-        return { ok: true, path: fallback, method: 'home dir fallback' }
-      } catch (err: unknown) {
-        return { ok: false, cancelled: false, error: `write failed: ${(err as Error).message}` }
-      }
-    }
-    return chosen
-  }
-
-  const fallback = path.join(homeDir, defaultName)
-  try {
-    await fsp.writeFile(fallback, archive)
-    return { ok: true, path: fallback, method: 'home dir' }
-  } catch (err: unknown) {
-    return { ok: false, cancelled: false, error: `write failed: ${(err as Error).message}` }
-  }
-}
-
-function defaultBackupFilename(identity: EthagentIdentity): string {
-  const idPart = identity.agentId ? `agent-${identity.agentId}` : 'agent'
-  const stamp = timestampSlug(new Date())
-  return `ethagent-backup-${idPart}-${stamp}.zip`
-}
-
-function timestampSlug(date: Date): string {
-  const pad = (n: number): string => String(n).padStart(2, '0')
-  return `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}-${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`
-}
-
-function ensureZipExtension(file: string): string {
-  return /\.zip$/i.test(file) ? file : `${file}.zip`
-}
-
-function resolveSaveDialogCommand(platform: NodeJS.Platform, env: NodeJS.ProcessEnv, defaultName: string): SaveDialogCommand | null {
-  if (platform === 'win32') {
-    const powershell = findExecutable('powershell.exe', env, platform) ?? findExecutable('pwsh.exe', env, platform)
-    if (!powershell) return null
-    return {
-      cmd: powershell,
-      args: [
-        '-NoProfile',
-        '-STA',
-        '-ExecutionPolicy',
-        'Bypass',
-        '-Command',
-        [
-          '[Console]::OutputEncoding = [System.Text.Encoding]::UTF8',
-          'Add-Type -AssemblyName System.Windows.Forms',
-          '$dialog = New-Object System.Windows.Forms.SaveFileDialog',
-          '$dialog.Title = "Save Local Backup"',
-          '$dialog.Filter = "Zip archive (*.zip)|*.zip|All files (*.*)|*.*"',
-          '$dialog.DefaultExt = "zip"',
-          `$dialog.FileName = "${defaultName.replace(/"/g, '`"')}"`,
-          '$dialog.OverwritePrompt = $true',
-          'if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) { Write-Output $dialog.FileName }',
-        ].join('; '),
-      ],
-      method: 'windows save dialog',
-    }
-  }
-  if (platform === 'darwin') {
-    return {
-      cmd: 'osascript',
-      args: [
-        '-e',
-        `set chosen to choose file name with prompt "Save Local Backup" default name "${defaultName.replace(/"/g, '\\"')}"`,
-        '-e',
-        'POSIX path of chosen',
-      ],
-      method: 'macOS save dialog',
-    }
-  }
-  const zenity = findExecutable('zenity', env, platform)
-  if (zenity) {
-    return {
-      cmd: zenity,
-      args: [
-        '--file-selection',
-        '--save',
-        '--confirm-overwrite',
-        '--title=Save Local Backup',
-        `--filename=${path.join(env.HOME ?? '.', defaultName)}`,
-        '--file-filter=Zip archive | *.zip',
-      ],
-      method: 'zenity',
-    }
-  }
-  const kdialog = findExecutable('kdialog', env, platform)
-  if (kdialog) {
-    return {
-      cmd: kdialog,
-      args: ['--getsavefilename', path.join(env.HOME ?? '.', defaultName), 'Zip archive (*.zip)'],
-      method: 'kdialog',
-    }
-  }
-  return null
-}
-
-function runSaveDialog(
-  command: SaveDialogCommand,
-  spawnImpl: typeof spawn,
-  timeoutMs: number,
-): Promise<{ ok: true; file: string } | { ok: false; cancelled: boolean; error: string }> {
-  return new Promise(resolve => {
-    let stdout = ''
-    let stderr = ''
-    let settled = false
-    let child: ReturnType<typeof spawn>
-    try {
-      child = spawnImpl(command.cmd, command.args, {
-        stdio: ['ignore', 'pipe', 'pipe'],
-        windowsHide: true,
-      })
-    } catch (err: unknown) {
-      resolve({ ok: false, cancelled: false, error: (err as Error).message })
-      return
-    }
-    const timer = setTimeout(() => {
-      if (settled) return
-      settled = true
-      child.kill()
-      resolve({ ok: false, cancelled: false, error: 'save dialog timed out' })
-    }, timeoutMs)
-    child.stdout?.setEncoding('utf8')
-    child.stderr?.setEncoding('utf8')
-    child.stdout?.on('data', chunk => { stdout += String(chunk) })
-    child.stderr?.on('data', chunk => { stderr += String(chunk) })
-    child.on('error', err => {
-      if (settled) return
-      settled = true
-      clearTimeout(timer)
-      resolve({ ok: false, cancelled: false, error: err.message })
-    })
-    child.on('close', code => {
-      if (settled) return
-      settled = true
-      clearTimeout(timer)
-      const file = stdout.trim()
-      if (code === 0 && file) {
-        resolve({ ok: true, file })
-        return
-      }
-      const detail = stderr.trim()
-      const cancelled = code === 0 || /cancel/i.test(detail)
-      resolve({ ok: false, cancelled, error: cancelled ? 'save cancelled' : detail || `${command.method} exited ${code}` })
-    })
-  })
-}
-
-function findExecutable(command: string, env: NodeJS.ProcessEnv, platform: NodeJS.Platform): string | null {
-  const hasPathSeparator = command.includes('/') || command.includes('\\')
-  if (hasPathSeparator || path.isAbsolute(command)) return canAccessExecutable(command) ? command : null
-  const pathParts = (env.PATH ?? '').split(path.delimiter).filter(Boolean)
-  const extensions = platform === 'win32'
-    ? (env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM').split(';').filter(Boolean)
-    : ['']
-  for (const dir of pathParts) {
-    for (const ext of extensions) {
-      const candidate = path.join(dir, platform === 'win32' && path.extname(command) === '' ? `${command}${ext}` : command)
-      if (canAccessExecutable(candidate)) return candidate
-      if (platform === 'win32') {
-        const lower = path.join(dir, path.extname(command) === '' ? `${command}${ext.toLowerCase()}` : command)
-        if (canAccessExecutable(lower)) return lower
-      }
-    }
-  }
-  return null
-}
-
-function canAccessExecutable(file: string): boolean {
-  try {
-    fs.accessSync(file, fs.constants.X_OK)
-    return true
-  } catch {
-    return false
-  }
-}