WhatsApp Agent Profile Management

[edualbercas]

Hi everyone!

I'd like to suggest adding WhatsApp profile management capabilities to Nanobot, allowing the agent to manage its own WhatsApp identity.

For example, users could ask the agent to:

Change its own profile picture.

Change its display name.

Update its About information.

Retrieve its current profile picture.

Check its status privacy settings.

Neonize already provides the following methods:

set_profile_photo()

set_profile_name()

set_status_message()

get_profile_picture()

get_status_privacy()

I've already tested and implemented the first three methods in a working Python script using NewAClient and Nanobot's existing neonize.db authentication database.

I believe exposing these methods as native agent tools would allow Nanobot to manage its own WhatsApp identity through natural language instructions.

For example:

"Change your profile picture to this image."

"Set your name to Nanobot Assistant."

"Update your About information to: AI Assistant."

I can share my working implementation as a reference.

What do you think about adding this capability?

P.S.

I'm already implementing this functionality using a custom Nanobot skill and a Python script.

This allows the agent to generate its own profile images using AI image generation and then update its WhatsApp profile picture automatically.

The idea is to give Nanobot the ability to create and manage its own visual identity, including its profile picture, name and About information, using Neonize.

It's already working on my setup!

example

import sys
import os
import asyncio
from contextlib import suppress
from neonize.aioze.client import NewAClient
from neonize.aioze.events import ConnectedEv
from neonize.utils.jid import build_jid

DB_PATH = "/home/eduardo/.nanobot/whatsapp-auth/neonize.db"

async def run_action(action, *args):
    # Creamos un cliente asíncrono apuntando a la base de datos de nanobot
    client = NewAClient(DB_PATH)
    connected_event = asyncio.Event()

    @client.event(ConnectedEv)
    async def on_connected(cli: NewAClient, event: ConnectedEv):
        connected_event.set()

    # Iniciamos la conexión en segundo plano
    task = asyncio.create_task(client.connect())

    # Esperamos a que se conecte (timeout de 15 segundos)
    try:
        await asyncio.wait_for(connected_event.wait(), timeout=15.0)
    except asyncio.TimeoutError:
        print("ERROR: No se pudo conectar a WhatsApp (Timeout). ¿Está nanobot en línea?")
        await client.disconnect()
        return False

    # Ejecutamos la acción
    try:
        if action == "set-photo":
            path = args[0]
            if not os.path.exists(path):
                print(f"ERROR: El archivo {path} no existe.")
                return False
            # Preprocesar imagen usando Pillow para hacerla cuadrada y de 640x640
            from PIL import Image
            import io
            with Image.open(path) as img:
                if img.mode != "RGB":
                    img = img.convert("RGB")
                width, height = img.size
                size = min(width, height)
                left = (width - size) / 2
                top = (height - size) / 2
                right = (width + size) / 2
                bottom = (height + size) / 2
                img_cropped = img.crop((left, top, right, bottom))
                img_resized = img_cropped.resize((640, 640), Image.Resampling.LANCZOS)
                buf = io.BytesIO()
                img_resized.save(buf, format="JPEG")
                img_bytes = buf.getvalue()
            res = await client.set_profile_photo(img_bytes)
            print(f"SUCCESS: Foto de perfil actualizada. {res}")
        elif action == "set-status":
            msg = args[0]
            await client.set_status_message(msg)
            print(f"SUCCESS: Mensaje de info/estado actualizado a: '{msg}'")
        elif action == "set-name":
            name = args[0]
            await client.set_profile_name(name)
            print(f"SUCCESS: Nombre de perfil actualizado a: '{name}'")
        else:
            print(f"ERROR: Acción desconocida: '{action}'")
            return False
    except Exception as e:
        print(f"ERROR: Error al ejecutar la acción: {e}")
        return False
    finally:
        # Siempre nos desconectamos limpiamente para no dejar colgada la conexión
        await client.disconnect()
        # Cancelamos la tarea de conexión
        task.cancel()
        with suppress(asyncio.CancelledError):
            await task
    return True

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Uso: whatsapp_admin.py <action> [args...]")
        print("Acciones:")
        print("  set-photo <ruta_imagen>")
        print("  set-status <mensaje_info>")
        print("  set-name <nuevo_nombre>")
        sys.exit(1)

    action = sys.argv[1]
    args = sys.argv[2:]
    
    # Ejecutamos el loop asincrónico
    success = asyncio.run(run_action(action, *args))
    sys.exit(0 if success else 1)