ethagent 1.0.1 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ethagent",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "A privacy-first AI agent with a portable Ethereum identity",
   "type": "module",
   "main": "bin/ethagent.js",
@@ -47,6 +47,7 @@
     "ink": "^6.8.0",
     "react": "^19.2.4",
     "tsx": "^4.21.0",
+    "update-notifier": "^7.3.1",
     "viem": "^2.48.4",
     "zod": "^3.25.76"
   },

package/src/cli/main.tsx

@@ -12,8 +12,13 @@ import { AppInputProvider, useAppInput } from '../app/input/AppInputProvider.js'
 import { loadConfig, type EthagentConfig } from '../storage/config.js'
 import { runResetCommand } from './reset.js'
 import { runPreviewCommand } from './preview.js'
+import updateNotifier from 'update-notifier'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const pkgPath = path.resolve(__dirname, '..', '..', 'package.json')
+const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
+
+updateNotifier({ pkg }).notify()
 
 function readVersion(): string {
   try {

package/src/identity/hub/IdentityHub.tsx

@@ -24,9 +24,6 @@ import {
   runRebackupPreflight,
   runRebackupSigning,
   runRebackupStorageSubmit,
-  runPublicProfilePreflight,
-  runPublicProfileSigning,
-  runPublicProfileStorageSubmit,
   runRecoveryRefetch,
   isAgentTokenIdRequiredError,
   type EffectCallbacks,
@@ -190,16 +187,7 @@ export const IdentityHub: React.FC<IdentityHubProps> = ({ mode, config, initialA
       .catch((err: unknown) => errorStep(err, backStep))
   }
 
-  const triggerPublicProfilePublish = (backStep: Step, profileUpdates?: ProfileUpdates): void => {
-    if (!identity) return
-    const registry = resolveRegistryForIdentity(identity)
-    if (!registry) {
-      errorStep(new Error('no agent registry configured for this identity'), backStep)
-      return
-    }
-    runPublicProfilePreflight(identity, registry, callbacks, profileUpdates, backStep)
-      .catch((err: unknown) => errorStep(err, backStep))
-  }
+
 
   useEffect(() => {
     if (step.kind !== 'rebackup-start') return
@@ -639,7 +627,7 @@ export const IdentityHub: React.FC<IdentityHubProps> = ({ mode, config, initialA
         footer={footer}
         onEditProfile={() => openPublicProfileEdit({ kind: 'continuity-public' })}
         onOpenSkills={() => { void openContinuityFile('skills') }}
-        onPublish={() => triggerPublicProfilePublish({ kind: 'continuity-public' })}
+        onPublish={() => triggerRebackup({ kind: 'continuity-public' })}
         onBack={back}
       />
     )
@@ -689,8 +677,7 @@ export const IdentityHub: React.FC<IdentityHubProps> = ({ mode, config, initialA
         onImageSubmit={imagePath => {
           if (step.kind !== 'edit-profile-image') return
           const updates: ProfileUpdates = { name: step.name, description: step.description, ...(imagePath ? { imagePath } : {}) }
-          runPublicProfilePreflight(step.identity, step.registry, callbacks, updates, step.returnTo ?? { kind: 'continuity-public' })
-            .catch((err: unknown) => errorStep(err, step.returnTo ?? { kind: 'continuity-public' }))
+          triggerRebackup(step.returnTo ?? { kind: 'continuity-public' }, updates)
         }}
         onImagePick={() => {
           if (step.kind !== 'edit-profile-image') return
@@ -702,8 +689,7 @@ export const IdentityHub: React.FC<IdentityHubProps> = ({ mode, config, initialA
                 return
               }
               const updates: ProfileUpdates = { name: imageStep.name, description: imageStep.description, imagePath: result.file }
-              runPublicProfilePreflight(imageStep.identity, imageStep.registry, callbacks, updates, imageStep.returnTo ?? { kind: 'continuity-public' })
-                .catch((err: unknown) => errorStep(err, imageStep.returnTo ?? { kind: 'continuity-public' }))
+              triggerRebackup(imageStep.returnTo ?? { kind: 'continuity-public' }, updates)
             })
             .catch((err: unknown) => {
               setStep({ ...imageStep, error: `${(err as Error).message}. enter a path manually if needed.` })
@@ -727,17 +713,7 @@ export const IdentityHub: React.FC<IdentityHubProps> = ({ mode, config, initialA
     )
   }
 
-  if (step.kind === 'public-profile-signing') {
-    return (
-      <WalletApprovalScreen
-        title="Approve Public Profile"
-        subtitle="Pins skills.json and the Agent Card, then updates tokenURI. Private files are not read."
-        walletSession={walletSession}
-        label="waiting for wallet approval..."
-        onCancel={() => setStep(step.returnTo ?? { kind: 'continuity-public' })}
-      />
-    )
-  }
+
 
   if (step.kind === 'rebackup-start') {
     return (
@@ -752,18 +728,14 @@ export const IdentityHub: React.FC<IdentityHubProps> = ({ mode, config, initialA
 
 
 
-  if (step.kind === 'rebackup-storage' || step.kind === 'public-profile-storage') {
+  if (step.kind === 'rebackup-storage') {
     return (
       <RebackupStorageScreen
         step={step}
         footer={footer}
         onSubmit={async input => {
           try {
-            if (step.kind === 'rebackup-storage') {
-              await runRebackupStorageSubmit(input, step, callbacks)
-            } else {
-              await runPublicProfileStorageSubmit(input, step, callbacks)
-            }
+            await runRebackupStorageSubmit(input, step, callbacks)
           } catch (err: unknown) {
             setStep({ ...step, error: (err as Error).message })
           }

package/src/identity/hub/identityHubEffects.ts

@@ -751,85 +751,7 @@ export async function runRebackupStorageSubmit(
   callbacks.onStep({ kind: 'rebackup-signing', identity: step.identity, registry: step.registry, pinataJwt, profileUpdates: step.profileUpdates, returnTo: step.returnTo })
 }
 
-export async function runPublicProfilePreflight(
-  identity: EthagentIdentity,
-  registry: Erc8004RegistryConfig,
-  callbacks: EffectCallbacks,
-  profileUpdates?: ProfileUpdates,
-  returnTo: Step = { kind: 'continuity-public' },
-): Promise<void> {
-  const apiUrl = DEFAULT_IPFS_API_URL
-  let jwt: string | undefined
-  try {
-    jwt = isPinataUploadUrl(apiUrl) ? await resolveValidatedPinataJwt() : undefined
-  } catch (err: unknown) {
-    callbacks.onStep({ kind: 'public-profile-storage', identity, registry, error: (err as Error).message, profileUpdates, returnTo })
-    return
-  }
-  if (isPinataUploadUrl(apiUrl) && !jwt) {
-    callbacks.onStep({ kind: 'public-profile-storage', identity, registry, profileUpdates, returnTo })
-    return
-  }
-  callbacks.onStep({ kind: 'public-profile-signing', identity, registry, pinataJwt: jwt, profileUpdates, returnTo })
-}
 
-export async function runPublicProfileSigning(
-  step: Extract<Step, { kind: 'public-profile-signing' }>,
-  callbacks: EffectCallbacks,
-): Promise<void> {
-  const expectedOwner = getAddress(step.identity.ownerAddress ?? step.identity.address)
-  if (!step.identity.agentId) throw new Error('cannot publish public profile: identity is missing an agent token id')
-
-  const prepared = await preparePublicProfileTransaction(step, expectedOwner)
-  const agentId = BigInt(step.identity.agentId)
-  await preflightSetAgentUri({
-    ...step.registry,
-    account: expectedOwner,
-    agentId,
-    newUri: prepared.agentUri,
-  })
-
-  const tx = await sendBrowserWalletTransaction({
-    chainId: step.registry.chainId,
-    expectedAccount: expectedOwner,
-    to: step.registry.identityRegistryAddress,
-    data: encodeSetAgentUri({ agentId, newUri: prepared.agentUri }),
-    onReady: callbacks.onWalletReady,
-  })
-  const client = createErc8004PublicClient(step.registry)
-  await client.waitForTransactionReceipt({ hash: tx.txHash })
-
-  const nextIdentity: EthagentIdentity = {
-    ...prepared.identity,
-    source: 'erc8004',
-    address: getAddress(prepared.ownerAddress),
-    ownerAddress: getAddress(prepared.ownerAddress),
-    chainId: step.registry.chainId,
-    rpcUrl: step.registry.rpcUrl,
-    identityRegistryAddress: step.registry.identityRegistryAddress,
-    agentUri: prepared.agentUri,
-    metadataCid: prepared.metadataCid,
-    publicSkills: prepared.publicSkills,
-  }
-  await writePublicSkillsFile(nextIdentity, prepared.publicSkillsJson)
-  await callbacks.onIdentityComplete(nextIdentity, step.profileUpdates ? 'public profile updated' : 'public profile published')
-}
-
-export async function runPublicProfileStorageSubmit(
-  input: string,
-  step: Extract<Step, { kind: 'public-profile-storage' }>,
-  callbacks: EffectCallbacks,
-): Promise<void> {
-  const { jwt: pinataJwt } = await savePinataJwt(input)
-  callbacks.onStep({
-    kind: 'public-profile-signing',
-    identity: step.identity,
-    registry: step.registry,
-    pinataJwt,
-    profileUpdates: step.profileUpdates,
-    returnTo: step.returnTo,
-  })
-}
 
 
 export async function runRecoveryRefetch(
@@ -915,92 +837,7 @@ export async function runRecoveryRefetch(
 }
 
 
-async function preparePublicProfileTransaction(
-  step: Extract<Step, { kind: 'public-profile-signing' }>,
-  ownerAddress: Address,
-): Promise<PublicProfilePreparedTransaction> {
-  const baseState = (step.identity.state ?? {}) as Record<string, unknown>
-  const profile = step.profileUpdates ?? {}
-  const nextName = typeof profile.name === 'string' && profile.name.trim()
-    ? profile.name.trim()
-    : (typeof baseState.name === 'string' && baseState.name.trim() ? baseState.name.trim() : deriveAgentName(step.identity))
-  const nextDescription = profile.description !== undefined
-    ? profile.description.trim()
-    : (typeof baseState.description === 'string' ? baseState.description : '')
-  const uploadedImageUri = profile.imagePath === 'delete'
-    ? ''
-    : profile.imagePath
-      ? await uploadAgentImage(profile.imagePath, step.pinataJwt)
-      : typeof baseState.imageUrl === 'string' && baseState.imageUrl.trim()
-        ? baseState.imageUrl.trim()
-        : undefined
-  const updatedAt = new Date().toISOString()
-  const state: Record<string, unknown> = {
-    ...baseState,
-    name: nextName,
-    description: nextDescription,
-    publicProfileUpdatedAt: updatedAt,
-  }
-  if (uploadedImageUri === '') {
-    delete state.imageUrl
-  } else if (uploadedImageUri) {
-    state.imageUrl = uploadedImageUri
-  }
-  const nextIdentityForFiles: EthagentIdentity = { ...step.identity, state }
-  const publicSkillsJson = step.profileUpdates
-    ? await prepareSyncedPublicSkillsJson(nextIdentityForFiles)
-    : await ensurePublicSkillsFile(nextIdentityForFiles)
-  const publicSkillsPin = await addToIpfs(DEFAULT_IPFS_API_URL, publicSkillsJson, fetch, { pinataJwt: step.pinataJwt })
-  assertVerifiedPin(publicSkillsPin)
-  const agentCardPin = await addToIpfs(
-    DEFAULT_IPFS_API_URL,
-    serializeAgentCard(createAgentCard(defaultPublicSkillsProfile(nextIdentityForFiles))),
-    fetch,
-    { pinataJwt: step.pinataJwt },
-  )
-  assertVerifiedPin(agentCardPin)
-  const publicSkills: PublicSkillsMetadata = {
-    cid: publicSkillsPin.cid,
-    agentCardCid: agentCardPin.cid,
-    updatedAt,
-    status: 'pinned',
-  }
-  const backup = step.identity.backup
-  const registration = withEthagentPointers({
-    type: 'https://eips.ethereum.org/EIPS/eip-8004#registration-v1',
-    name: nextName,
-    ...(nextDescription ? { description: nextDescription } : {}),
-    ...(uploadedImageUri ? { image: uploadedImageUri } : {}),
-  }, {
-    ...(backup ? {
-      backup: {
-        cid: backup.cid,
-        envelopeVersion: backup.envelopeVersion,
-        createdAt: backup.createdAt,
-      },
-    } : {}),
-    publicDiscovery: {
-      skillsCid: publicSkills.cid,
-      agentCardCid: publicSkills.agentCardCid,
-      updatedAt,
-    },
-    registration: {
-      chainId: step.registry.chainId,
-      identityRegistryAddress: step.registry.identityRegistryAddress,
-      agentId: step.identity.agentId,
-    },
-  })
-  const metadataPin = await addToIpfs(DEFAULT_IPFS_API_URL, JSON.stringify(registration, null, 2), fetch, { pinataJwt: step.pinataJwt })
-  assertVerifiedPin(metadataPin)
-  return {
-    ownerAddress,
-    agentUri: `ipfs://${metadataPin.cid}`,
-    metadataCid: metadataPin.cid,
-    publicSkills,
-    identity: { ...step.identity, state },
-    publicSkillsJson,
-  }
-}
+
 
 function deriveAgentName(identity: EthagentIdentity): string {
   const state = (identity.state ?? {}) as Record<string, unknown>

package/src/identity/hub/screens/ContinuityDashboardScreen.tsx

@@ -45,8 +45,8 @@ export const PrivateContinuityScreen: React.FC<CommonProps & {
           { value: 'soul', role: 'section', prefix: '--', label: 'Open local files' },
           { value: 'soul', label: 'open SOUL.md', hint: 'edit persona and operating preferences', disabled: !ready },
           { value: 'memory', label: 'open MEMORY.md', hint: 'edit private working memory for this agent', disabled: !ready },
-          { value: 'backup', role: 'section', prefix: '--', label: 'Publish' },
-          { value: 'backup', label: 'save snapshot', hint: 'save editor changes first; then encrypt and pin', disabled: !ready || !canBackup },
+          { value: 'backup', role: 'section', prefix: '--', label: 'Recovery' },
+          { value: 'backup', label: 'publish snapshot now', hint: 'publishes SOUL.md, MEMORY.md, skills.json, and metadata', disabled: !ready || !canBackup },
           { value: 'back', role: 'section', prefix: '--', label: 'Navigation' },
           { value: 'back', label: 'back to identity hub', hint: 'return without changing private files', role: 'utility' },
         ]}
@@ -69,7 +69,7 @@ export const PublicSkillsScreen: React.FC<CommonProps & {
   onOpenSkills: () => void
   onPublish: () => void
 }> = ({ identity, config, notice, footer, canPublish, onEditProfile, onOpenSkills, onPublish, onBack }) => (
-  <Surface title="Public Profile" subtitle={notice ?? 'Public token metadata only. Private SOUL.md and MEMORY.md are not touched here.'} footer={footer}>
+  <Surface title="Public Profile" subtitle={notice ?? 'Manage public metadata, skills.json, and the agent card.'} footer={footer}>
     <IdentitySummary identity={identity} config={config} compact />
     <PublicProfileRows identity={identity} />
     <Box marginTop={1}>
@@ -79,8 +79,8 @@ export const PublicSkillsScreen: React.FC<CommonProps & {
           { value: 'edit', label: 'edit name, description, image', hint: 'upload a local image to IPFS automatically' },
           { value: 'skills', role: 'section', prefix: '--', label: 'Capabilities' },
           { value: 'skills', label: 'open skills.json', hint: 'edit public capabilities and notes' },
-          { value: 'publish', role: 'section', prefix: '--', label: 'Publish' },
-          { value: 'publish', label: 'publish public profile', hint: 'save skills.json first; pins metadata and updates tokenURI', disabled: !canPublish },
+          { value: 'publish', role: 'section', prefix: '--', label: 'Recovery' },
+          { value: 'publish', label: 'publish snapshot now', hint: 'publishes SOUL.md, MEMORY.md, skills.json, and metadata', disabled: !canPublish },
           { value: 'back', role: 'section', prefix: '--', label: 'Navigation' },
           { value: 'back', label: 'back to identity hub', hint: 'return without changing public metadata', role: 'utility' },
         ]}

package/src/identity/hub/screens/MenuScreen.tsx

@@ -69,7 +69,7 @@ export const MenuScreen: React.FC<MenuScreenProps> = ({
         { value: 'private-memory', role: 'section', prefix: '--', label: 'Private local files' },
         { value: 'private-memory', label: 'memory and persona', hint: 'SOUL.md and MEMORY.md only on this device' },
         { value: 'backup', role: 'section', prefix: '--', label: 'Recovery' },
-        { value: 'backup', label: 'publish snapshot now', hint: 'encrypts and publishes local SOUL.md and MEMORY.md changes', disabled: !canRebackup },
+        { value: 'backup', label: 'publish snapshot now', hint: 'publishes SOUL.md, MEMORY.md, skills.json, and metadata', disabled: !canRebackup },
         { value: 'refetch', label: 'refetch latest snapshot', hint: 'restore local files from the latest published snapshot', disabled: !canRefetch },
         { value: 'storage-credential', role: 'section', prefix: '--', label: 'Storage' },
         { value: 'storage-credential', label: 'IPFS credential', hint: 'save, replace, or forget Pinata JWT' },