Add Hugging Face Spaces deployment configuration (Dockerfile, supervisord, watcher)

Dockerfile

@@ -0,0 +1,57 @@
+# Use the pre-built base image
+FROM agent0ai/agent-zero-base:latest
+
+# Set BRANCH to "local" if not provided
+ARG BRANCH=local
+ENV BRANCH=$BRANCH
+
+# Copy filesystem files to root
+COPY ./docker/run/fs/ /
+
+# Overwrite supervisord conf with HF version
+COPY ./docker/run/fs/etc/supervisor/conf.d/supervisord_hf.conf /etc/supervisor/conf.d/supervisord.conf
+
+# Copy current development files to git
+COPY ./ /git/agent-zero
+
+# Create directory for data linking (HF Spaces usually mount /data if persistent storage is enabled, or we use a local folder)
+RUN mkdir -p /knowledge_data
+
+# Install A0
+# We assume the base image has most things. We run the install scripts.
+# Note: In HF Spaces, we might be user 1000. 
+# For now, let's try to run as root during build to set permissions, then switch user if needed.
+# However, standard Agent Zero runs as root (internal to container). HF Spaces allows root in Docker spaces usually.
+
+# Run pre-install steps
+RUN bash /ins/pre_install.sh $BRANCH
+
+# Install A0
+RUN bash /ins/install_A0.sh $BRANCH
+
+# Install watchdog for knowledge watcher
+RUN uv pip install --python /opt/venv-a0/bin/python watchdog
+
+# Install additional software
+RUN bash /ins/install_additional.sh $BRANCH
+
+# Cleanup and install A02
+ARG CACHE_DATE=none
+RUN echo "cache buster $CACHE_DATE" && bash /ins/install_A02.sh $BRANCH
+
+# Post install
+RUN bash /ins/post_install.sh $BRANCH
+
+# Expose HF Spaces port
+EXPOSE 7860
+
+# We need to modify run_A0.sh or the app config to listen on 7860 instead of 80/50001
+# Or we map 7860 to 80.
+# Agent Zero likely listens on port 80 inside the container (from DockerfileLocal EXPOSE 80).
+# We will use an environment variable or sed to change the port if needed.
+# For now, let's assume we can map it or change it in the start script.
+
+RUN chmod +x /exe/initialize.sh /exe/run_A0.sh /exe/run_A0_hf.sh /exe/run_searxng.sh /exe/run_tunnel_api.sh
+
+# Initialize
+CMD ["/exe/initialize.sh", "local"]

docker/run/fs/etc/supervisor/conf.d/supervisord_hf.conf

@@ -0,0 +1,69 @@
+[supervisord]
+nodaemon=true
+user=root
+logfile=/dev/stdout
+logfile_maxbytes=0
+pidfile=/var/run/supervisord.pid
+exitcodes=0,2
+directory=/
+
+[unix_http_server]
+file=/var/run/supervisor.sock
+chmod=0777
+
+[rpcinterface:supervisor]
+supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
+
+[supervisorctl]
+serverurl=unix:///var/run/supervisor.sock
+
+[program:run_searxng]
+command=/exe/run_searxng.sh
+environment=SEARXNG_SETTINGS_PATH=/etc/searxng/settings.yml
+user=searxng
+directory=/usr/local/searxng/searxng-src
+stopwaitsecs=1
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+autorestart=true
+startretries=3
+stopasgroup=true
+killasgroup=true
+
+[program:run_ui]
+command=/bin/bash /exe/run_A0_hf.sh
+environment=
+user=root
+stopwaitsecs=60
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+autorestart=true
+startretries=3
+stopasgroup=true
+killasgroup=true
+
+[program:watch_knowledge]
+command=/opt/venv-a0/bin/python /git/agent-zero/python/tools/watch_knowledge.py
+environment=
+user=root
+stopwaitsecs=10
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+autorestart=true
+startretries=3
+stopasgroup=true
+killasgroup=true
+
+[eventlistener:the_listener]
+command=python3 /exe/supervisor_event_listener.py
+events=PROCESS_STATE_FATAL
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0

docker/run/fs/exe/run_A0_hf.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+# Source setup scripts
+. "/ins/setup_venv.sh" "$@"
+. "/ins/copy_A0.sh" "$@"
+
+# Run cleanups/preps
+python /a0/prepare.py --dockerized=true
+
+echo "Starting A0 on HF Port 7860..."
+# Exec into python to run the UI
+exec python /a0/run_ui.py \
+    --dockerized=true \
+    --port=7860 \
+    --host="0.0.0.0"

python/tools/watch_knowledge.py

@@ -0,0 +1,68 @@
+import time
+import os
+import shutil
+import logging
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+
+# Configuration
+WATCH_DIR = os.getenv("KNOWLEDGE_WATCH_DIR", "/knowledge_data")
+# Agent Zero internal knowledge directory
+TARGET_DIR = "/a0/knowledge/default" # 'default' knowledge base
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class KnowledgeHandler(FileSystemEventHandler):
+    def on_created(self, event):
+        if event.is_directory:
+            return
+        
+        filename = os.path.basename(event.src_path)
+        # unexpected files filter
+        if filename.startswith(".") or filename.endswith(".tmp"):
+            return
+
+        logger.info(f"New file detected: {event.src_path}")
+        
+        # We wait a bit to ensure file write is complete
+        time.sleep(1)
+        
+        try:
+            # Copy to Agent Zero knowledge directory
+            # This triggers Agent Zero's internal mechanisms if it has any auto-ingest,
+            # OR we simply place it there so it's available for the 'knowledge' tool.
+            # Agent Zero 0.9.7+ might need explicit embedding or indexing.
+            # However, simply having it in the folder makes it accessible to 'knowledge' tool usually.
+            
+            target_path = os.path.join(TARGET_DIR, filename)
+            if os.path.exists(target_path):
+                 logger.info(f"File already exists in knowledge base: {filename}")
+                 return
+
+            shutil.copy2(event.src_path, target_path)
+            logger.info(f"Ingested {filename} into {target_path}")
+            
+            # TODO: If explicit API call is needed to trigger embedding, do it here.
+            # For now, we assume A0 indexes on access or via background jobs.
+
+        except Exception as e:
+            logger.error(f"Error processing file {event.src_path}: {e}")
+
+if __name__ == "__main__":
+    # Ensure directories exist
+    os.makedirs(WATCH_DIR, exist_ok=True)
+    os.makedirs(TARGET_DIR, exist_ok=True)
+
+    event_handler = KnowledgeHandler()
+    observer = Observer()
+    observer.schedule(event_handler, WATCH_DIR, recursive=False)
+    
+    logger.info(f"Starting Knowledge Watcher on {WATCH_DIR} -> {TARGET_DIR}")
+    observer.start()
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        observer.stop()
+    observer.join()