ethagent 3.3.4 → 4.0.0

package/src/storage/factoryReset.ts

@@ -1,127 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { PROVIDERS, getConfigDir } from './config.js'
-import { rmSecret } from './secrets.js'
-
-const PRESERVED_LOCAL_MODEL_ENTRIES = new Set([
-  'local-models.json',
-  'local-runner.json',
-  'models',
-  'runners',
-])
-
-const SECRET_ACCOUNTS = [
-  'ethereum:default',
-  'pinata:jwt',
-  ...PROVIDERS,
-] as const
-
-export type FactoryResetPlan = {
-  configDir: string
-  deletePaths: string[]
-  preservedPaths: string[]
-  preservedDescriptions: string[]
-  remoteDescriptions: string[]
-}
-
-export type FactoryResetResult = {
-  deletedPaths: string[]
-  preservedPaths: string[]
-  clearedSecretAccounts: string[]
-}
-
-export async function createFactoryResetPlan(): Promise<FactoryResetPlan> {
-  const configDir = path.resolve(getConfigDir())
-  const entries = await readConfigEntries(configDir)
-  const deletePaths: string[] = []
-  const preservedPaths: string[] = []
-
-  for (const entry of entries) {
-    const target = path.join(configDir, entry)
-    assertInsideConfigDir(configDir, target)
-    if (PRESERVED_LOCAL_MODEL_ENTRIES.has(entry)) preservedPaths.push(target)
-    else deletePaths.push(target)
-  }
-
-  return {
-    configDir,
-    deletePaths,
-    preservedPaths,
-    preservedDescriptions: [
-      'Local GGUF models and metadata',
-      'llama.cpp runner assets',
-      'External package-installed runtimes',
-    ],
-    remoteDescriptions: [
-      'ERC-8004 tokens and onchain records',
-      'IPFS snapshots and public metadata',
-    ],
-  }
-}
-
-export async function runFactoryReset(options: { clearSecrets?: boolean } = {}): Promise<FactoryResetResult> {
-  const plan = await createFactoryResetPlan()
-  const clearedSecretAccounts: string[] = []
-  if (options.clearSecrets ?? true) {
-    for (const account of SECRET_ACCOUNTS) {
-      try {
-        await rmSecret(account)
-        clearedSecretAccounts.push(account)
-      } catch {
-        continue
-      }
-    }
-  }
-
-  const deletedPaths: string[] = []
-  for (const target of plan.deletePaths) {
-    assertInsideConfigDir(plan.configDir, target)
-    await fs.rm(target, { recursive: true, force: true })
-    deletedPaths.push(target)
-  }
-
-  return {
-    deletedPaths,
-    preservedPaths: plan.preservedPaths,
-    clearedSecretAccounts,
-  }
-}
-
-export function formatFactoryResetPlan(plan: FactoryResetPlan): string {
-  return [
-    'Ethagent Reset',
-    '',
-    'Deletes:',
-    ...formatDeleteSummary(plan.deletePaths.length),
-    '',
-    'Keeps:',
-    ...plan.preservedDescriptions.map(item => `  - ${item}`),
-    '',
-    'Not Touched:',
-    ...plan.remoteDescriptions.map(item => `  - ${item}`),
-  ].join('\n')
-}
-
-async function readConfigEntries(configDir: string): Promise<string[]> {
-  try {
-    return await fs.readdir(configDir)
-  } catch (err: unknown) {
-    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return []
-    throw err
-  }
-}
-
-function formatDeleteSummary(count: number): string[] {
-  if (count === 0) return ['  - No local ethagent data found']
-  return [
-    '  - Identity files, sessions, history, credentials',
-    `  - ${count} local path${count === 1 ? '' : 's'} under ~/.ethagent`,
-  ]
-}
-
-function assertInsideConfigDir(configDir: string, target: string): void {
-  const relative = path.relative(path.resolve(configDir), path.resolve(target))
-  if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
-    throw new Error(`refusing to reset path outside ethagent config: ${target}`)
-  }
-}

package/src/storage/history.ts

@@ -1,58 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { getConfigDir } from './config.js'
-
-const MAX_ENTRIES = 500
-
-export function getHistoryPath(): string {
-  return path.join(getConfigDir(), 'history.jsonl')
-}
-
-type Entry = { text: string; ts: number }
-
-export async function appendHistory(text: string): Promise<void> {
-  const clean = text.trim()
-  if (!clean) return
-  try {
-    await fs.mkdir(getConfigDir(), { recursive: true })
-  } catch {
-    return
-  }
-  const line = JSON.stringify({ text: clean, ts: Date.now() } satisfies Entry) + '\n'
-  try {
-    await fs.appendFile(getHistoryPath(), line, { mode: 0o600 })
-  } catch {
-    return
-  }
-}
-
-export async function readHistory(): Promise<string[]> {
-  let raw: string
-  try {
-    raw = await fs.readFile(getHistoryPath(), 'utf8')
-  } catch (err: unknown) {
-    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return []
-    throw err
-  }
-  const entries: Entry[] = []
-  for (const line of raw.split('\n')) {
-    const trimmed = line.trim()
-    if (!trimmed) continue
-    try {
-      entries.push(JSON.parse(trimmed) as Entry)
-    } catch {
-      continue
-    }
-  }
-  const seen = new Set<string>()
-  const out: string[] = []
-  for (let i = entries.length - 1; i >= 0; i--) {
-    const entry = entries[i]
-    if (!entry) continue
-    if (seen.has(entry.text)) continue
-    seen.add(entry.text)
-    out.unshift(entry.text)
-    if (out.length >= MAX_ENTRIES) break
-  }
-  return out
-}

package/src/storage/permissions.ts

@@ -1,76 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { z } from 'zod'
-import { ensureConfigDir, getConfigDir } from './config.js'
-import { SessionPermissionRuleSchema, type SessionPermissionRule } from '../tools/contracts.js'
-import { atomicWriteText } from './atomicWrite.js'
-
-const StoredPermissionRuleSchema = z.object({
-  workspaceRoot: z.string().min(1),
-  rule: SessionPermissionRuleSchema,
-})
-
-type StoredPermissionRule = z.infer<typeof StoredPermissionRuleSchema>
-
-function getPermissionsPath(): string {
-  return path.join(getConfigDir(), 'permissions.json')
-}
-
-export async function loadPermissionRules(workspaceRoot: string): Promise<SessionPermissionRule[]> {
-  const normalizedWorkspaceRoot = path.resolve(workspaceRoot)
-  const allRules = await loadAllPermissionRules()
-  return allRules
-    .filter(entry => path.resolve(entry.workspaceRoot) === normalizedWorkspaceRoot)
-    .map(entry => entry.rule)
-}
-
-export async function deletePermissionRule(workspaceRoot: string, rule: SessionPermissionRule): Promise<void> {
-  const normalizedWorkspaceRoot = path.resolve(workspaceRoot)
-  const allRules = await loadAllPermissionRules()
-  const next = allRules.filter(entry =>
-    !(path.resolve(entry.workspaceRoot) === normalizedWorkspaceRoot && JSON.stringify(entry.rule) === JSON.stringify(rule)),
-  )
-  await writeAllPermissionRules(next)
-}
-
-export async function clearPermissionRules(workspaceRoot: string): Promise<void> {
-  const normalizedWorkspaceRoot = path.resolve(workspaceRoot)
-  const allRules = await loadAllPermissionRules()
-  const next = allRules.filter(entry => path.resolve(entry.workspaceRoot) !== normalizedWorkspaceRoot)
-  await writeAllPermissionRules(next)
-}
-
-export async function savePermissionRule(workspaceRoot: string, rule: SessionPermissionRule): Promise<void> {
-  const allRules = await loadAllPermissionRules()
-  const normalizedWorkspaceRoot = path.resolve(workspaceRoot)
-  const nextEntry: StoredPermissionRule = { workspaceRoot: normalizedWorkspaceRoot, rule }
-  const deduped = [...allRules.filter(entry => !sameStoredRule(entry, nextEntry)), nextEntry]
-  await writeAllPermissionRules(deduped)
-}
-
-async function loadAllPermissionRules(): Promise<StoredPermissionRule[]> {
-  let raw: string
-  try {
-    raw = await fs.readFile(getPermissionsPath(), 'utf8')
-  } catch (error: unknown) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return []
-    throw error
-  }
-
-  try {
-    const parsed = JSON.parse(raw)
-    return z.array(StoredPermissionRuleSchema).parse(parsed)
-  } catch {
-    return []
-  }
-}
-
-async function writeAllPermissionRules(rules: StoredPermissionRule[]): Promise<void> {
-  await ensureConfigDir()
-  const file = getPermissionsPath()
-  await atomicWriteText(file, JSON.stringify(rules, null, 2) + '\n')
-}
-
-function sameStoredRule(left: StoredPermissionRule, right: StoredPermissionRule): boolean {
-  return left.workspaceRoot === right.workspaceRoot && JSON.stringify(left.rule) === JSON.stringify(right.rule)
-}

package/src/storage/rewind.ts

@@ -1,266 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { z } from 'zod'
-import { ensureConfigDir, getConfigDir } from './config.js'
-import { atomicWriteText } from './atomicWrite.js'
-
-const RewindSnapshotSchema = z.object({
-  id: z.string().optional(),
-  workspaceRoot: z.string().min(1),
-  filePath: z.string().min(1),
-  relativePath: z.string().optional(),
-  existedBefore: z.boolean(),
-  previousContent: z.string(),
-  changeSummary: z.string().optional(),
-  createdAt: z.string(),
-  sessionId: z.string().optional(),
-  turnId: z.string().optional(),
-  messageRole: z.literal('user').optional(),
-  promptSnippet: z.string().optional(),
-  checkpointLabel: z.string().optional(),
-})
-
-type RewindSnapshot = z.infer<typeof RewindSnapshotSchema>
-export type RewindEntry = {
-  id: string
-  workspaceRoot: string
-  filePath: string
-  relativePath: string
-  existedBefore: boolean
-  previousContent: string
-  changeSummary: string
-  createdAt: string
-  sessionId?: string
-  turnId?: string
-  messageRole?: 'user'
-  promptSnippet: string
-  checkpointLabel: string
-}
-
-export type ListRewindEntriesOptions = {
-  limit?: number
-  offset?: number
-}
-
-function getRewindPath(): string {
-  return path.join(getConfigDir(), 'rewind.jsonl')
-}
-
-export async function recordRewindSnapshot(snapshot: RewindSnapshot): Promise<void> {
-  await ensureConfigDir()
-  const normalized = normalizeSnapshot(snapshot)
-  if (isIdentityMarkdownSnapshot(normalized)) return
-  await fs.appendFile(getRewindPath(), `${JSON.stringify(normalized)}\n`, { encoding: 'utf8', mode: 0o600 })
-}
-
-export async function rewindWorkspaceEdits(
-  workspaceRoot: string,
-  steps = 1,
-): Promise<{ reverted: number; files: string[] }> {
-  const normalizedWorkspaceRoot = path.resolve(workspaceRoot)
-  const snapshots = await loadSnapshots()
-  const candidates = snapshots
-    .map((snapshot, index) => ({ snapshot, index }))
-    .filter(entry =>
-      path.resolve(entry.snapshot.workspaceRoot) === normalizedWorkspaceRoot &&
-      !isIdentityMarkdownSnapshot(entry.snapshot),
-    )
-
-  if (candidates.length === 0) return { reverted: 0, files: [] }
-
-  const selected = candidates.slice(Math.max(0, candidates.length - steps))
-  const revertedFiles: string[] = []
-
-  for (let index = selected.length - 1; index >= 0; index -= 1) {
-    const snapshot = selected[index]!.snapshot
-    if (snapshot.existedBefore) {
-      await fs.mkdir(path.dirname(snapshot.filePath), { recursive: true })
-      await fs.writeFile(snapshot.filePath, snapshot.previousContent, 'utf8')
-    } else {
-      try {
-        await fs.unlink(snapshot.filePath)
-      } catch (error: unknown) {
-        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error
-      }
-    }
-    revertedFiles.push(snapshot.filePath)
-  }
-
-  const selectedIndexes = new Set(selected.map(entry => entry.index))
-  const remaining = snapshots.filter((_snapshot, index) => !selectedIndexes.has(index))
-  await writeSnapshots(remaining)
-
-  return { reverted: selected.length, files: revertedFiles }
-}
-
-async function loadSnapshots(): Promise<RewindSnapshot[]> {
-  let raw: string
-  try {
-    raw = await fs.readFile(getRewindPath(), 'utf8')
-  } catch (error: unknown) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return []
-    throw error
-  }
-
-  const out: RewindSnapshot[] = []
-  for (const line of raw.split('\n')) {
-    const trimmed = line.trim()
-    if (!trimmed) continue
-    try {
-      out.push(normalizeSnapshot(RewindSnapshotSchema.parse(JSON.parse(trimmed))))
-    } catch {
-      continue
-    }
-  }
-  return out
-}
-
-export async function listRewindEntries(
-  workspaceRoot: string,
-  options: ListRewindEntriesOptions = {},
-): Promise<RewindEntry[]> {
-  const normalizedWorkspaceRoot = path.resolve(workspaceRoot)
-  const limit = options.limit ?? 30
-  const offset = options.offset ?? 0
-  const snapshots = await loadSnapshots()
-  return snapshots
-    .filter(snapshot => !isIdentityMarkdownSnapshot(snapshot))
-    .filter(snapshot => isSnapshotWithinScope(snapshot, normalizedWorkspaceRoot))
-    .map(snapshot => toEntry(snapshot))
-    .reverse()
-    .slice(offset, offset + limit)
-}
-
-export async function groupRewindEntriesByTurn(
-  workspaceRoot: string,
-  sessionId: string,
-): Promise<Map<string, RewindEntry[]>> {
-  const normalizedWorkspaceRoot = path.resolve(workspaceRoot)
-  const snapshots = await loadSnapshots()
-  const grouped = new Map<string, RewindEntry[]>()
-  for (const snapshot of snapshots) {
-    if (isIdentityMarkdownSnapshot(snapshot)) continue
-    if (!isSnapshotWithinScope(snapshot, normalizedWorkspaceRoot)) continue
-    if (snapshot.sessionId !== sessionId) continue
-    if (!snapshot.turnId) continue
-    const entry = toEntry(snapshot)
-    const bucket = grouped.get(snapshot.turnId)
-    if (bucket) bucket.push(entry)
-    else grouped.set(snapshot.turnId, [entry])
-  }
-  return grouped
-}
-
-export async function rewindWorkspaceEditsByEntryIds(
-  workspaceRoot: string,
-  entryIds: string[],
-): Promise<{ reverted: number; files: string[] }> {
-  const normalizedWorkspaceRoot = path.resolve(workspaceRoot)
-  const selectedIds = new Set(entryIds)
-  const snapshots = await loadSnapshots()
-  const selected = snapshots
-    .map((snapshot, index) => ({ snapshot, index }))
-    .filter(entry =>
-      path.resolve(entry.snapshot.workspaceRoot) === normalizedWorkspaceRoot &&
-      !isIdentityMarkdownSnapshot(entry.snapshot) &&
-      selectedIds.has(entry.snapshot.id!),
-    )
-
-  if (selected.length === 0) return { reverted: 0, files: [] }
-
-  const revertedFiles: string[] = []
-  for (let index = selected.length - 1; index >= 0; index -= 1) {
-    const snapshot = selected[index]!.snapshot
-    if (snapshot.existedBefore) {
-      await fs.mkdir(path.dirname(snapshot.filePath), { recursive: true })
-      await fs.writeFile(snapshot.filePath, snapshot.previousContent, 'utf8')
-    } else {
-      try {
-        await fs.unlink(snapshot.filePath)
-      } catch (error: unknown) {
-        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error
-      }
-    }
-    revertedFiles.push(snapshot.filePath)
-  }
-
-  const selectedIndexes = new Set(selected.map(entry => entry.index))
-  const remaining = snapshots.filter((_snapshot, index) => !selectedIndexes.has(index))
-  await writeSnapshots(remaining)
-
-  return { reverted: selected.length, files: revertedFiles }
-}
-
-async function writeSnapshots(snapshots: RewindSnapshot[]): Promise<void> {
-  await ensureConfigDir()
-  const file = getRewindPath()
-  const body = snapshots.map(snapshot => JSON.stringify(snapshot)).join('\n')
-  await atomicWriteText(file, body ? `${body}\n` : '')
-}
-
-function normalizeSnapshot(snapshot: RewindSnapshot): RewindSnapshot {
-  const workspaceRoot = path.resolve(snapshot.workspaceRoot)
-  const filePath = path.resolve(snapshot.filePath)
-  return {
-    ...snapshot,
-    id: snapshot.id ?? stableSnapshotId(workspaceRoot, filePath, snapshot.createdAt),
-    workspaceRoot,
-    filePath,
-    relativePath: snapshot.relativePath ?? (path.relative(workspaceRoot, filePath) || path.basename(filePath)),
-    changeSummary: snapshot.changeSummary ?? (snapshot.existedBefore ? 'restore previous file contents' : 'remove created file'),
-    promptSnippet: normalizeSnippet(snapshot.promptSnippet),
-    checkpointLabel: normalizeSnippet(snapshot.checkpointLabel) || normalizeSnippet(snapshot.promptSnippet),
-  }
-}
-
-function toEntry(snapshot: RewindSnapshot): RewindEntry {
-  return {
-    id: snapshot.id!,
-    workspaceRoot: snapshot.workspaceRoot,
-    filePath: snapshot.filePath,
-    relativePath: snapshot.relativePath!,
-    existedBefore: snapshot.existedBefore,
-    previousContent: snapshot.previousContent,
-    changeSummary: snapshot.changeSummary!,
-    createdAt: snapshot.createdAt,
-    sessionId: snapshot.sessionId,
-    turnId: snapshot.turnId,
-    messageRole: snapshot.messageRole,
-    promptSnippet: snapshot.promptSnippet ?? '',
-    checkpointLabel: snapshot.checkpointLabel ?? snapshot.promptSnippet ?? 'Untitled checkpoint',
-  }
-}
-
-function stableSnapshotId(workspaceRoot: string, filePath: string, createdAt: string): string {
-  const rel = path.relative(workspaceRoot, filePath) || path.basename(filePath)
-  return `${createdAt}:${rel}`.replaceAll('\\', '/')
-}
-
-function isSnapshotWithinScope(snapshot: RewindSnapshot, scopeRoot: string): boolean {
-  if (path.resolve(snapshot.workspaceRoot) === scopeRoot) return true
-  const relative = path.relative(scopeRoot, path.resolve(snapshot.filePath))
-  return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative)
-}
-
-function isIdentityMarkdownSnapshot(snapshot: RewindSnapshot): boolean {
-  const relativePath = (snapshot.relativePath ?? '').replaceAll('\\', '/').toLowerCase()
-  const basename = path.basename(snapshot.filePath).toLowerCase()
-  if (relativePath.startsWith('identity-vault/') && IDENTITY_MARKDOWN_FILES.has(basename)) return true
-
-  const continuityRoot = path.resolve(getConfigDir(), 'continuity')
-  const relativeToContinuity = path.relative(continuityRoot, path.resolve(snapshot.filePath))
-  return (
-    relativeToContinuity !== '' &&
-    !relativeToContinuity.startsWith('..') &&
-    !path.isAbsolute(relativeToContinuity) &&
-    IDENTITY_MARKDOWN_FILES.has(basename)
-  )
-}
-
-const IDENTITY_MARKDOWN_FILES = new Set(['soul.md', 'memory.md', 'agent-card.json'])
-
-function normalizeSnippet(input?: string): string {
-  const normalized = (input ?? '').replace(/\s+/g, ' ').trim()
-  if (!normalized) return ''
-  return normalized.length <= 120 ? normalized : `${normalized.slice(0, 117)}...`
-}

package/src/storage/sessionExport.ts

@@ -1,49 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { getConfigDir } from './config.js'
-import type { SessionMessage } from './sessions.js'
-
-export function getExportsDir(): string {
-  return path.join(getConfigDir(), 'exports')
-}
-
-export async function exportSessionMarkdown(
-  id: string,
-  messages: SessionMessage[],
-  meta: { model: string; provider: string },
-): Promise<string> {
-  await fs.mkdir(getExportsDir(), { recursive: true })
-  const file = path.join(getExportsDir(), `${id}.md`)
-
-  const userTurns = messages.filter(m => m.role === 'user').length
-  const lines: string[] = []
-  lines.push('---')
-  lines.push(`session: ${id}`)
-  lines.push(`provider: ${meta.provider}`)
-  lines.push(`model: ${meta.model}`)
-  lines.push(`turns: ${userTurns}`)
-  lines.push(`exportedAt: ${new Date().toISOString()}`)
-  lines.push('---')
-  lines.push('')
-  for (const m of messages) {
-    if (m.role === 'system') continue
-    const header =
-      m.role === 'user'
-        ? '## user'
-        : m.role === 'assistant'
-          ? '## assistant'
-          : m.role === 'tool_use'
-            ? `## tool use · ${m.name}`
-            : `## tool result · ${m.name}`
-    lines.push(`${header}  <sub>${m.createdAt}</sub>`)
-    lines.push('')
-    if (m.role === 'tool_use') {
-      lines.push(JSON.stringify(m.input, null, 2))
-    } else {
-      lines.push(m.content)
-    }
-    lines.push('')
-  }
-  await fs.writeFile(file, lines.join('\n'), { mode: 0o600 })
-  return file
-}