ethagent 2.4.0 → 3.0.1

package/src/tools/listSkillsTool.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod'
+import {
+  continuityVaultRef,
+} from '../identity/continuity/storage.js'
+import { listSkillsTree } from '../identity/continuity/skills/loadSkills.js'
+import type { Tool } from './contracts.js'
+
+const schema = z.object({})
+
+export const listSkillsTool: Tool<typeof schema> = {
+  name: 'list_private_skills',
+  kind: 'private-continuity-read',
+  readOnly: true,
+  description: [
+    'List private skills available in the owner-authored skills tree for the active identity.',
+    'Returns each skill folder name with its one-line description; bodies are loaded separately via read_private_skill.',
+    'When a skill has supporting files beyond SKILL.md, the entry is annotated with (+N supporting files) so you know to call list_private_skill_files.',
+    'Use this when the user mentions a skill not in the injected skill index, or to discover what skills exist.',
+  ].join(' '),
+  inputSchema: schema,
+  inputSchemaJson: {
+    type: 'object',
+    properties: {},
+    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 listing private skills')
+    const ref = continuityVaultRef(identity)
+    return {
+      kind: 'private-skill-read',
+      path: ref.skillsDir,
+      relativePath: 'identity-vault/skills',
+      directoryPath: ref.skillsDir,
+      title: 'Allow private skills index read?',
+      subtitle: 'List skill names and descriptions from the private skills tree',
+      skillName: '*',
+      mode: 'list',
+    }
+  },
+  async execute(_input, context) {
+    const identity = context.config?.identity
+    if (!identity) {
+      return { ok: false, summary: 'no active identity', content: 'No active identity; cannot list private skills.' }
+    }
+    const { skills, supportingCounts } = await listSkillsTree(identity)
+    if (skills.length === 0) {
+      return { ok: true, summary: 'no private skills', content: 'The private skills tree is empty.' }
+    }
+    const lines = skills.map(entry => {
+      const display = entry.displayName ?? entry.name
+      const desc = entry.description ? ` — ${entry.description}` : ''
+      const when = entry.whenToUse ? ` (when: ${entry.whenToUse})` : ''
+      const vis = entry.visibility !== 'private' ? ` [visibility: ${entry.visibility}]` : ''
+      const supporting = supportingCounts[entry.name] ?? 0
+      const trailer = supporting > 0 ? ` (+${supporting} supporting file${supporting === 1 ? '' : 's'})` : ''
+      return `- ${display}${desc}${when}${vis}${trailer}`
+    })
+    return {
+      ok: true,
+      summary: `listed ${skills.length} private skill${skills.length === 1 ? '' : 's'}`,
+      content: lines.join('\n'),
+    }
+  },
+}

package/src/tools/mcpResourceTools.ts

@@ -30,7 +30,7 @@ export const listMcpResourcesTool: Tool<typeof ListMcpResourcesInput> = {
     const serverName = input.server ?? '*'
     return {
       kind: 'mcp',
-      title: 'allow MCP resource listing?',
+      title: 'Allow MCP resource listing?',
       subtitle: input.server ? `list resources from ${input.server}` : 'list resources from all connected MCP servers',
       serverName,
       normalizedServerName: normalizeNameForMcp(serverName),
@@ -72,7 +72,7 @@ export const readMcpResourceTool: Tool<typeof ReadMcpResourceInput> = {
   async buildPermissionRequest(input) {
     return {
       kind: 'mcp',
-      title: 'allow MCP resource read?',
+      title: 'Allow MCP resource read?',
       subtitle: `${input.server} / ${input.uri}`,
       serverName: input.server,
       normalizedServerName: normalizeNameForMcp(input.server),

package/src/tools/privateContinuityReadTool.ts

@@ -43,7 +43,7 @@ export const privateContinuityReadTool: Tool<typeof schema> = {
       path: prepared.fullPath,
       relativePath: prepared.relativePath,
       directoryPath: prepared.directoryPath,
-      title: 'allow private continuity read?',
+      title: 'Allow private continuity read?',
       subtitle: input.startLine || input.endLine
         ? `${prepared.fullPath} · lines ${input.startLine ?? 1}-${input.endLine ?? 'end'}`
         : prepared.fullPath,

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

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
-  }
-}

package/src/identity/continuity/zipWriter.ts

@@ -1,95 +0,0 @@
-export type ZipEntry = {
-  name: string
-  data: Buffer
-}
-
-const crcTable = (() => {
-  const table = new Uint32Array(256)
-  for (let i = 0; i < 256; i++) {
-    let c = i
-    for (let k = 0; k < 8; k++) c = (c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1)
-    table[i] = c
-  }
-  return table
-})()
-
-export function crc32(buf: Buffer): number {
-  let c = 0xFFFFFFFF
-  for (let i = 0; i < buf.length; i++) {
-    const byte = buf[i] as number
-    c = (crcTable[(c ^ byte) & 0xff] as number) ^ (c >>> 8)
-  }
-  return (c ^ 0xFFFFFFFF) >>> 0
-}
-
-export function buildZip(entries: ZipEntry[], modifiedAt: Date = new Date()): Buffer {
-  const dosTime = toDosTime(modifiedAt)
-  const dosDate = toDosDate(modifiedAt)
-  const localParts: Buffer[] = []
-  const centralParts: Buffer[] = []
-  let offset = 0
-  for (const entry of entries) {
-    const nameBuf = Buffer.from(entry.name, 'utf8')
-    const crc = crc32(entry.data)
-    const size = entry.data.length
-
-    const localHeader = Buffer.alloc(30)
-    localHeader.writeUInt32LE(0x04034b50, 0)
-    localHeader.writeUInt16LE(20, 4)
-    localHeader.writeUInt16LE(0x0800, 6)
-    localHeader.writeUInt16LE(0, 8)
-    localHeader.writeUInt16LE(dosTime, 10)
-    localHeader.writeUInt16LE(dosDate, 12)
-    localHeader.writeUInt32LE(crc, 14)
-    localHeader.writeUInt32LE(size, 18)
-    localHeader.writeUInt32LE(size, 22)
-    localHeader.writeUInt16LE(nameBuf.length, 26)
-    localHeader.writeUInt16LE(0, 28)
-    localParts.push(localHeader, nameBuf, entry.data)
-
-    const centralHeader = Buffer.alloc(46)
-    centralHeader.writeUInt32LE(0x02014b50, 0)
-    centralHeader.writeUInt16LE(20, 4)
-    centralHeader.writeUInt16LE(20, 6)
-    centralHeader.writeUInt16LE(0x0800, 8)
-    centralHeader.writeUInt16LE(0, 10)
-    centralHeader.writeUInt16LE(dosTime, 12)
-    centralHeader.writeUInt16LE(dosDate, 14)
-    centralHeader.writeUInt32LE(crc, 16)
-    centralHeader.writeUInt32LE(size, 20)
-    centralHeader.writeUInt32LE(size, 24)
-    centralHeader.writeUInt16LE(nameBuf.length, 28)
-    centralHeader.writeUInt16LE(0, 30)
-    centralHeader.writeUInt16LE(0, 32)
-    centralHeader.writeUInt16LE(0, 34)
-    centralHeader.writeUInt16LE(0, 36)
-    centralHeader.writeUInt32LE(0, 38)
-    centralHeader.writeUInt32LE(offset, 42)
-    centralParts.push(centralHeader, nameBuf)
-
-    offset += localHeader.length + nameBuf.length + entry.data.length
-  }
-
-  const centralBuf = Buffer.concat(centralParts)
-  const localBuf = Buffer.concat(localParts)
-  const eocd = Buffer.alloc(22)
-  eocd.writeUInt32LE(0x06054b50, 0)
-  eocd.writeUInt16LE(0, 4)
-  eocd.writeUInt16LE(0, 6)
-  eocd.writeUInt16LE(entries.length, 8)
-  eocd.writeUInt16LE(entries.length, 10)
-  eocd.writeUInt32LE(centralBuf.length, 12)
-  eocd.writeUInt32LE(localBuf.length, 16)
-  eocd.writeUInt16LE(0, 20)
-
-  return Buffer.concat([localBuf, centralBuf, eocd])
-}
-
-function toDosTime(date: Date): number {
-  return ((date.getHours() & 0x1f) << 11) | ((date.getMinutes() & 0x3f) << 5) | ((date.getSeconds() / 2) & 0x1f)
-}
-
-function toDosDate(date: Date): number {
-  const year = Math.max(1980, date.getFullYear()) - 1980
-  return ((year & 0x7f) << 9) | (((date.getMonth() + 1) & 0x0f) << 5) | (date.getDate() & 0x1f)
-}

package/src/identity/hub/continuity/index.ts

@@ -1,7 +0,0 @@
-export {
-  rebackupCompletionMessage,
-  runRebackupPreflight,
-  runRebackupSigning,
-  runRebackupSigningInSession,
-  runRebackupStorageSubmit,
-} from './effects.js'

package/src/identity/hub/ens/index.ts

@@ -1,11 +0,0 @@
-export {
-  runEnsLinkFlow,
-  runEnsUnlinkFlow,
-  runEnsUpdateFlow,
-} from './effects.js'
-export {
-  ensRecordWritesForUpdate,
-  runEnsSetupRecordsTransaction,
-  runEnsSetupRegistryTransaction,
-  runUpdateEnsRecords,
-} from './transactions.js'

package/src/identity/hub/restore/index.ts

@@ -1,22 +0,0 @@
-export {
-  runRestoreAuthorize,
-} from './apply.js'
-export {
-  restoreSignatureRequestForStep,
-  runRestoreConnectWallet,
-} from './auth.js'
-export {
-  canRestoreCandidate,
-  restoreTokenSelectionStep,
-  runRestoreDiscover,
-} from './discover.js'
-export {
-  runRestoreFetch,
-} from './fetch.js'
-export {
-  runRecoveryRefetch,
-} from './recovery.js'
-export {
-  resolveAgentEnsToCandidate,
-  resolveAgentTokenIdToCandidate,
-} from './resolve.js'