Upload 181 files

.gitattributes

@@ -34,3 +34,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 diagram.png filter=lfs diff=lfs merge=lfs -text
+python3.11 filter=lfs diff=lfs merge=lfs -text
+python3.9 filter=lfs diff=lfs merge=lfs -text

Activate.ps1

@@ -0,0 +1,241 @@
+<#
+.Synopsis
+Activate a Python virtual environment for the current PowerShell session.
+
+.Description
+Pushes the python executable for a virtual environment to the front of the
+$Env:PATH environment variable and sets the prompt to signify that you are
+in a Python virtual environment. Makes use of the command line switches as
+well as the `pyvenv.cfg` file values present in the virtual environment.
+
+.Parameter VenvDir
+Path to the directory that contains the virtual environment to activate. The
+default value for this is the parent of the directory that the Activate.ps1
+script is located within.
+
+.Parameter Prompt
+The prompt prefix to display when this virtual environment is activated. By
+default, this prompt is the name of the virtual environment folder (VenvDir)
+surrounded by parentheses and followed by a single space (ie. '(.venv) ').
+
+.Example
+Activate.ps1
+Activates the Python virtual environment that contains the Activate.ps1 script.
+
+.Example
+Activate.ps1 -Verbose
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and shows extra information about the activation as it executes.
+
+.Example
+Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
+Activates the Python virtual environment located in the specified location.
+
+.Example
+Activate.ps1 -Prompt "MyPython"
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and prefixes the current prompt with the specified string (surrounded in
+parentheses) while the virtual environment is active.
+
+.Notes
+On Windows, it may be required to enable this Activate.ps1 script by setting the
+execution policy for the user. You can do this by issuing the following PowerShell
+command:
+
+PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+For more information on Execution Policies: 
+https://go.microsoft.com/fwlink/?LinkID=135170
+
+#>
+Param(
+    [Parameter(Mandatory = $false)]
+    [String]
+    $VenvDir,
+    [Parameter(Mandatory = $false)]
+    [String]
+    $Prompt
+)
+
+<# Function declarations --------------------------------------------------- #>
+
+<#
+.Synopsis
+Remove all shell session elements added by the Activate script, including the
+addition of the virtual environment's Python executable from the beginning of
+the PATH variable.
+
+.Parameter NonDestructive
+If present, do not remove this function from the global namespace for the
+session.
+
+#>
+function global:deactivate ([switch]$NonDestructive) {
+    # Revert to original values
+
+    # The prior prompt:
+    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
+        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
+        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
+    }
+
+    # The prior PYTHONHOME:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
+        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
+    }
+
+    # The prior PATH:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
+        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
+    }
+
+    # Just remove the VIRTUAL_ENV altogether:
+    if (Test-Path -Path Env:VIRTUAL_ENV) {
+        Remove-Item -Path env:VIRTUAL_ENV
+    }
+
+    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
+    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
+        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
+    }
+
+    # Leave deactivate function in the global namespace if requested:
+    if (-not $NonDestructive) {
+        Remove-Item -Path function:deactivate
+    }
+}
+
+<#
+.Description
+Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
+given folder, and returns them in a map.
+
+For each line in the pyvenv.cfg file, if that line can be parsed into exactly
+two strings separated by `=` (with any amount of whitespace surrounding the =)
+then it is considered a `key = value` line. The left hand string is the key,
+the right hand is the value.
+
+If the value starts with a `'` or a `"` then the first and last character is
+stripped from the value before being captured.
+
+.Parameter ConfigDir
+Path to the directory that contains the `pyvenv.cfg` file.
+#>
+function Get-PyVenvConfig(
+    [String]
+    $ConfigDir
+) {
+    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
+
+    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
+    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
+
+    # An empty map will be returned if no config file is found.
+    $pyvenvConfig = @{ }
+
+    if ($pyvenvConfigPath) {
+
+        Write-Verbose "File exists, parse `key = value` lines"
+        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
+
+        $pyvenvConfigContent | ForEach-Object {
+            $keyval = $PSItem -split "\s*=\s*", 2
+            if ($keyval[0] -and $keyval[1]) {
+                $val = $keyval[1]
+
+                # Remove extraneous quotations around a string value.
+                if ("'""".Contains($val.Substring(0, 1))) {
+                    $val = $val.Substring(1, $val.Length - 2)
+                }
+
+                $pyvenvConfig[$keyval[0]] = $val
+                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
+            }
+        }
+    }
+    return $pyvenvConfig
+}
+
+
+<# Begin Activate script --------------------------------------------------- #>
+
+# Determine the containing directory of this script
+$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$VenvExecDir = Get-Item -Path $VenvExecPath
+
+Write-Verbose "Activation script is located in path: '$VenvExecPath'"
+Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
+Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
+
+# Set values required in priority: CmdLine, ConfigFile, Default
+# First, get the location of the virtual environment, it might not be
+# VenvExecDir if specified on the command line.
+if ($VenvDir) {
+    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
+}
+else {
+    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
+    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
+    Write-Verbose "VenvDir=$VenvDir"
+}
+
+# Next, read the `pyvenv.cfg` file to determine any required value such
+# as `prompt`.
+$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
+
+# Next, set the prompt from the command line, or the config file, or
+# just use the name of the virtual environment folder.
+if ($Prompt) {
+    Write-Verbose "Prompt specified as argument, using '$Prompt'"
+}
+else {
+    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
+    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
+        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
+        $Prompt = $pyvenvCfg['prompt'];
+    }
+    else {
+        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virutal environment)"
+        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
+        $Prompt = Split-Path -Path $venvDir -Leaf
+    }
+}
+
+Write-Verbose "Prompt = '$Prompt'"
+Write-Verbose "VenvDir='$VenvDir'"
+
+# Deactivate any currently active virtual environment, but leave the
+# deactivate function in place.
+deactivate -nondestructive
+
+# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
+# that there is an activated venv.
+$env:VIRTUAL_ENV = $VenvDir
+
+if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
+
+    Write-Verbose "Setting prompt to '$Prompt'"
+
+    # Set the prompt to include the env name
+    # Make sure _OLD_VIRTUAL_PROMPT is global
+    function global:_OLD_VIRTUAL_PROMPT { "" }
+    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
+    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
+
+    function global:prompt {
+        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
+        _OLD_VIRTUAL_PROMPT
+    }
+}
+
+# Clear PYTHONHOME
+if (Test-Path -Path Env:PYTHONHOME) {
+    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
+    Remove-Item -Path Env:PYTHONHOME
+}
+
+# Add the venv to the PATH
+Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
+$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"

README.md

@@ -1,9 +1,36 @@
----
-license: mit
-title: vision2.0
-sdk: streamlit
-emoji: 📊
-colorFrom: green
-colorTo: gray
-pinned: true
----
+This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app).
+
+## Getting Started
+
+First, run the development server:
+
+```bash
+npm run dev
+# or
+yarn dev
+# or
+pnpm dev
+# or
+bun dev
+```
+
+Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
+
+You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.
+
+This project uses [`next/font`](https://nextjs.org/docs/app/building-your-application/optimizing/fonts) to automatically optimize and load [Geist](https://vercel.com/font), a new font family for Vercel.
+
+## Learn More
+
+To learn more about Next.js, take a look at the following resources:
+
+- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
+- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
+
+You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js) - your feedback and contributions are welcome!
+
+## Deploy on Vercel
+
+The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
+
+Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.

activate

@@ -0,0 +1,66 @@
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+deactivate () {
+    # reset old environment variables
+    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
+        PATH="${_OLD_VIRTUAL_PATH:-}"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
+        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # This should detect bash and zsh, which have a hash command that must
+    # be called to get it to forget past commands.  Without forgetting
+    # past commands the $PATH changes we made may not be respected
+    if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+        hash -r 2> /dev/null
+    fi
+
+    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
+        PS1="${_OLD_VIRTUAL_PS1:-}"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    if [ ! "${1:-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+VIRTUAL_ENV="/Users/lattm/Downloads/home/visionos_venv"
+export VIRTUAL_ENV
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/bin:$PATH"
+export PATH
+
+# unset PYTHONHOME if set
+# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
+# could use `if (set -u; : $PYTHONHOME) ;` in bash
+if [ -n "${PYTHONHOME:-}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1:-}"
+    PS1="(visionos_venv) ${PS1:-}"
+    export PS1
+fi
+
+# This should detect bash and zsh, which have a hash command that must
+# be called to get it to forget past commands.  Without forgetting
+# past commands the $PATH changes we made may not be respected
+if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+    hash -r 2> /dev/null
+fi

activate.csh

@@ -0,0 +1,25 @@
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+# Created by Davide Di Blasi <[email protected]>.
+# Ported to Python 3.3 venv by Andrew Svetlov <[email protected]>
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; test "\!:*" != "nondestructive" && unalias deactivate'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV "/Users/lattm/Downloads/home/visionos_venv"
+
+set _OLD_VIRTUAL_PATH="$PATH"
+setenv PATH "$VIRTUAL_ENV/bin:$PATH"
+
+
+set _OLD_VIRTUAL_PROMPT="$prompt"
+
+if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
+    set prompt = "(visionos_venv) $prompt"
+endif
+
+alias pydoc python -m pydoc
+
+rehash

activate.fish

@@ -0,0 +1,64 @@
+# This file must be used with "source <venv>/bin/activate.fish" *from fish*
+# (https://fishshell.com/); you cannot run it directly.
+
+function deactivate  -d "Exit virtual environment and return to normal shell environment"
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        set -gx PATH $_OLD_VIRTUAL_PATH
+        set -e _OLD_VIRTUAL_PATH
+    end
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+        functions -e fish_prompt
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+        functions -c _old_fish_prompt fish_prompt
+        functions -e _old_fish_prompt
+    end
+
+    set -e VIRTUAL_ENV
+    if test "$argv[1]" != "nondestructive"
+        # Self-destruct!
+        functions -e deactivate
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV "/Users/lattm/Downloads/home/visionos_venv"
+
+set -gx _OLD_VIRTUAL_PATH $PATH
+set -gx PATH "$VIRTUAL_ENV/bin" $PATH
+
+# Unset PYTHONHOME if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # fish uses a function instead of an env var to generate the prompt.
+
+    # Save the current fish_prompt function as the function _old_fish_prompt.
+    functions -c fish_prompt _old_fish_prompt
+
+    # With the original prompt function renamed, we can override with our own.
+    function fish_prompt
+        # Save the return status of the last command.
+        set -l old_status $status
+
+        # Output the venv prompt; color taken from the blue of the Python logo.
+        printf "%s%s%s" (set_color 4B8BBE) "(visionos_venv) " (set_color normal)
+
+        # Restore the return status of the previous command.
+        echo "exit $old_status" | .
+        # Output the original/"old" prompt.
+        _old_fish_prompt
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+end

agent_logic.py

@@ -0,0 +1,250 @@
+# /home/ubuntu/visionos_farm/agents/coding_agent/agent_logic.py
+
+import asyncio
+import json
+import logging
+import ollama
+import redis.asyncio as redis
+from typing import Dict, Any, List, Optional
+import uuid
+import datetime
+
+# Assuming shared schemas are importable (adjust path if needed)
+# In a real setup, this would likely be a proper package install
+import sys
+sys.path.append("/home/ubuntu/visionos_farm/shared")
+from schemas import Task, TaskStatus, AgentHeartbeat, AgentStatus, AgentType, RedisTaskMessage, RedisResultMessage, RedisHeartbeatMessage, ToolCall, ToolResult
+
+from config import settings
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+# --- Ollama Client Setup ---
+# TODO: Make default model configurable via settings
+DEFAULT_OLLAMA_MODEL = "llama3"
+ollama_client = ollama.AsyncClient()
+
+# --- Redis Connection Setup ---
+# TODO: Centralize Redis connection management (e.g., using a connection pool)
+async def get_redis_connection():
+    # Consider adding error handling for connection creation
+    return await redis.from_url(f"redis://{settings.REDIS_HOST}:{settings.REDIS_PORT}", decode_responses=True)
+
+# --- Agent State ---
+agent_id = f"{settings.AGENT_TYPE.lower()}-{uuid.uuid4()}" # Generate a unique ID for this instance
+current_status = AgentStatus.IDLE
+agent_capabilities = ["ollama_chat", "ui_design_principles"] # Base capability for UI Agent
+
+# --- Helper Functions ---
+
+async def log_reasoning(task_id: str, step: str, details: Dict[str, Any]):
+    """Placeholder for logging reasoning steps ('think mode')."""
+    # TODO: Implement actual logging to Redis stream or DB for UI display
+    logger.info(f"[Task {task_id}][Think] {step}: {json.dumps(details)}")
+
+async def execute_tool(tool_call: ToolCall) -> ToolResult:
+    """Placeholder for dynamically loading and executing tools."""
+    await log_reasoning(task_id="N/A", step="Tool Execution Start", details=tool_call.model_dump())
+    # TODO: Implement dynamic tool loading based on extensibility framework
+    # TODO: Add security sandboxing for tool execution
+    # TODO: Integrate local agent communication for local tools (VS Code, terminal, files)
+    logger.warning(f"Tool execution not yet implemented for: {tool_call.tool_name}")
+    return ToolResult(
+        tool_name=tool_call.tool_name,
+        status="FAILURE",
+        error="Tool execution not implemented."
+    )
+
+async def perform_deep_search(query: str, config: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """Placeholder for deep search functionality."""
+    await log_reasoning(task_id="N/A", step="Deep Search Start", details={"query": query, "config": config})
+    # TODO: Implement search across configured sources (web, knowledge base, files)
+    logger.warning(f"Deep search not yet implemented for query: {query}")
+    return []
+
+async def manage_artifacts(action: str, paths: List[str], config: Dict[str, Any]) -> Dict[str, Any]:
+    """Placeholder for artifact management (upload/download/list)."""
+    await log_reasoning(task_id="N/A", step="Artifact Management", details={"action": action, "paths": paths, "config": config})
+    # TODO: Implement artifact handling (e.g., interaction with S3, local storage via local agent)
+    logger.warning(f"Artifact management not yet implemented for action: {action}")
+    return {"status": "not_implemented"}
+
+# --- Core Agent Logic ---
+
+async def process_task(task: Task):
+    """Processes a single task based on parameters and configuration."""
+    global current_status
+    current_status = AgentStatus.BUSY
+    logger.info(f"Agent {agent_id} starting task {task.task_id}")
+    redis_conn = await get_redis_connection()
+    results = {}
+    final_status = TaskStatus.COMPLETED
+    error_message = None
+
+    try:
+        await log_reasoning(task.task_id, "Task Received", task.model_dump(exclude={"parameters": "..."}))
+
+        # --- Configuration Extraction (Example) ---
+        # These would ideally come from task.parameters or a config fetched based on task/user
+        task_config = task.parameters.get("config", {})
+        llm_model = task_config.get("llm_model", DEFAULT_OLLAMA_MODEL)
+        prompt = task.parameters.get("prompt", "Perform the requested action.")
+        tool_calls_config = task_config.get("tool_calls", [])
+        search_config = task_config.get("search", None)
+        artifact_config = task_config.get("artifacts", None)
+        reasoning_level = task_config.get("reasoning_level", "basic") # Example: basic, detailed
+
+        await log_reasoning(task.task_id, "Configuration Parsed", {"llm_model": llm_model, "reasoning_level": reasoning_level})
+
+        # --- Artifact Handling (Input) ---
+        if artifact_config and artifact_config.get("inputs"): 
+            await manage_artifacts("download", artifact_config["inputs"], task_config)
+            # TODO: Handle downloaded artifact paths
+
+        # --- Deep Search (If configured) ---
+        search_results = []
+        if search_config and search_config.get("query"): 
+            search_results = await perform_deep_search(search_config["query"], task_config)
+            # TODO: Incorporate search_results into context/prompt
+
+        # --- Core LLM Interaction (Example) ---
+        await log_reasoning(task.task_id, "LLM Interaction Start", {"model": llm_model, "prompt_length": len(prompt)})
+        # TODO: Build more sophisticated context including search results, artifact info
+        llm_response = await ollama_client.chat(
+            model=llm_model,
+            messages=[{"role": "user", "content": prompt}]
+        )
+        llm_output = llm_response["message"]["content"]
+        results["llm_output"] = llm_output
+        await log_reasoning(task.task_id, "LLM Interaction Complete", {"response_length": len(llm_output)})
+
+        # --- Tool Execution (If configured) ---
+        tool_results = []
+        if tool_calls_config:
+            for tool_call_data in tool_calls_config:
+                # TODO: Validate tool_call_data against ToolCall schema
+                tool_call = ToolCall(**tool_call_data)
+                tool_result = await execute_tool(tool_call)
+                tool_results.append(tool_result.model_dump())
+            results["tool_results"] = tool_results
+            # TODO: Potentially feed tool results back to LLM for final response
+
+        # --- Artifact Handling (Output) ---
+        if artifact_config and artifact_config.get("outputs"): 
+            # TODO: Determine which files need uploading based on results/LLM output
+            await manage_artifacts("upload", artifact_config["outputs"], task_config)
+
+        # --- Final Result Aggregation ---
+        # Combine results from LLM, tools, etc. into the final output structure
+        # This structure should be flexible and defined by the task type/config
+        results["final_summary"] = results.get("llm_output", "Task completed.") # Simple example
+
+    except Exception as e:
+        logger.error(f"Agent {agent_id} failed task {task.task_id}: {e}", exc_info=True)
+        final_status = TaskStatus.FAILED
+        error_message = str(e)
+        results = None # Clear partial results on failure
+
+    finally:
+        # --- Publish Result ---
+        task_result_payload = {
+            "task_id": task.task_id,
+            "agent_id": agent_id,
+            "status": final_status,
+            "output": results,
+            "error_message": error_message
+        }
+        # Ensure datetime fields are handled if added to schema
+        result_message = RedisResultMessage(result=task_result_payload)
+        try:
+            await redis_conn.publish(settings.REDIS_RESULTS_CHANNEL, result_message.model_dump_json())
+            logger.info(f"Agent {agent_id} {final_status.lower()} task {task.task_id}")
+        except Exception as pub_e:
+            logger.error(f"Failed to publish result for task {task.task_id}: {pub_e}")
+        
+        current_status = AgentStatus.IDLE
+        await redis_conn.close()
+
+async def listen_for_tasks():
+    """Listens for tasks assigned to this agent type on Redis."""
+    redis_conn = await get_redis_connection()
+    pubsub = redis_conn.pubsub()
+    task_channel = f"{settings.REDIS_TASK_CHANNEL_PREFIX}:{settings.AGENT_TYPE}"
+    await pubsub.subscribe(task_channel)
+    logger.info(f"Agent {agent_id} listening for tasks on {task_channel}")
+
+    while True:
+        try:
+            message = await pubsub.get_message(ignore_subscribe_messages=True, timeout=1.0)
+            if message and message["type"] == "message":
+                logger.info(f"Received task message on {task_channel}")
+                try:
+                    task_data = json.loads(message["data"])
+                    task_message = RedisTaskMessage.model_validate(task_data)
+                    if current_status == AgentStatus.IDLE:
+                        asyncio.create_task(process_task(task_message.task))
+                    else:
+                        logger.warning(f"Agent {agent_id} is BUSY, skipping task {task_message.task.task_id}")
+                        # TODO: Implement task queuing or NACK mechanism
+                except (json.JSONDecodeError, Exception) as e:
+                    logger.error(f"Failed to parse or validate task message: {e}")
+            await asyncio.sleep(0.1)
+        except redis.ConnectionError as e:
+            logger.error(f"Redis connection error while listening: {e}. Reconnecting...")
+            await asyncio.sleep(5)
+            try:
+                await pubsub.unsubscribe(task_channel)
+                await redis_conn.close()
+            except: pass
+            redis_conn = await get_redis_connection()
+            pubsub = redis_conn.pubsub()
+            await pubsub.subscribe(task_channel)
+            logger.info(f"Re-subscribed to {task_channel} after connection error.")
+        except Exception as e:
+            logger.error(f"Unexpected error in task listener: {e}", exc_info=True)
+            await asyncio.sleep(5)
+
+async def send_heartbeat():
+    """Periodically sends a heartbeat signal to Redis."""
+    redis_conn = await get_redis_connection()
+    while True:
+        try:
+            # TODO: Dynamically determine capabilities based on loaded tools/config
+            current_capabilities = agent_capabilities # Use current state
+            heartbeat_msg = RedisHeartbeatMessage(
+                heartbeat={
+                    "agent_id": agent_id,
+                    "agent_type": settings.AGENT_TYPE,
+                    "status": current_status,
+                    "capabilities": current_capabilities
+                }
+            )
+            await redis_conn.publish(settings.REDIS_HEARTBEAT_CHANNEL, heartbeat_msg.model_dump_json())
+            await asyncio.sleep(settings.HEARTBEAT_INTERVAL)
+        except redis.ConnectionError as e:
+            logger.error(f"Redis connection error during heartbeat: {e}. Reconnecting...")
+            await asyncio.sleep(5)
+            try:
+                await redis_conn.close()
+            except: pass
+            redis_conn = await get_redis_connection()
+            logger.info("Reconnected to Redis for heartbeat.")
+        except Exception as e:
+            logger.error(f"Unexpected error in heartbeat loop: {e}", exc_info=True)
+            await asyncio.sleep(settings.HEARTBEAT_INTERVAL)
+
+# --- Main Execution ---
+async def run_agent():
+    logger.info(f"Starting agent {agent_id} of type {settings.AGENT_TYPE}")
+    heartbeat_task = asyncio.create_task(send_heartbeat())
+    listener_task = asyncio.create_task(listen_for_tasks())
+    await asyncio.gather(heartbeat_task, listener_task)
+
+# Example of how to run (usually triggered from main.py)
+# if __name__ == "__main__":
+#     try:
+#         asyncio.run(run_agent())
+#     except KeyboardInterrupt:
+#         logger.info("Agent shutdown requested.")
+

alembic

@@ -0,0 +1,8 @@
+#!/Users/lattm/Downloads/home/visionos_venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from alembic.config import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

api.py

@@ -1,311 +1,20 @@
-import os
-from typing import List, Optional
+# /home/ubuntu/visionos_farm/daedalus/api/v1/api.py
 
-from fastapi import FastAPI, UploadFile, File, HTTPException, APIRouter, Form, Depends, Request
-from fastapi.responses import Response, JSONResponse
-from pydantic import BaseModel
+from fastapi import APIRouter
 
-from utils.logger import logger
-from utils.auth_utils import get_current_user_id, get_user_id_from_stream_auth, get_optional_user_id
-from sandbox.sandbox import get_or_start_sandbox
-from services.supabase import DBConnection
-from agent.api import get_or_create_project_sandbox
+# Import endpoint routers
+from .endpoints import tasks, configurations, tool_sources, api_keys # Added api_keys
+# Import other routers like agents when created
+# from .endpoints import agents
 
+api_router = APIRouter()
 
-# Initialize shared resources
-router = APIRouter(tags=["sandbox"])
-db = None
+# Include endpoint routers
+api_router.include_router(tasks.router, prefix="/tasks", tags=["Tasks"])
+api_router.include_router(configurations.router, prefix="/configurations", tags=["Configurations"])
+api_router.include_router(tool_sources.router, prefix="/tool-sources", tags=["Tool Sources"])
+api_router.include_router(api_keys.router, prefix="/api-keys", tags=["API Keys"]) # Added api_keys router
+# api_router.include_router(agents.router, prefix="/agents", tags=["Agents"])
 
-def initialize(_db: DBConnection):
-    """Initialize the sandbox API with resources from the main API."""
-    global db
-    db = _db
-    logger.info("Initialized sandbox API with database connection")
+# Add more routers as needed
 
-class FileInfo(BaseModel):
-    """Model for file information"""
-    name: str
-    path: str
-    is_dir: bool
-    size: int
-    mod_time: str
-    permissions: Optional[str] = None
-
-async def verify_sandbox_access(client, sandbox_id: str, user_id: Optional[str] = None):
-    """
-    Verify that a user has access to a specific sandbox based on account membership.
-    
-    Args:
-        client: The Supabase client
-        sandbox_id: The sandbox ID to check access for
-        user_id: The user ID to check permissions for. Can be None for public resource access.
-        
-    Returns:
-        dict: Project data containing sandbox information
-        
-    Raises:
-        HTTPException: If the user doesn't have access to the sandbox or sandbox doesn't exist
-    """
-    # Find the project that owns this sandbox
-    project_result = await client.table('projects').select('*').filter('sandbox->>id', 'eq', sandbox_id).execute()
-    
-    if not project_result.data or len(project_result.data) == 0:
-        raise HTTPException(status_code=404, detail="Sandbox not found")
-    
-    project_data = project_result.data[0]
-
-    if project_data.get('is_public'):
-        return project_data
-    
-    # For private projects, we must have a user_id
-    if not user_id:
-        raise HTTPException(status_code=401, detail="Authentication required for this resource")
-    
-    account_id = project_data.get('account_id')
-    
-    # Verify account membership
-    if account_id:
-        account_user_result = await client.schema('basejump').from_('account_user').select('account_role').eq('user_id', user_id).eq('account_id', account_id).execute()
-        if account_user_result.data and len(account_user_result.data) > 0:
-            return project_data
-    
-    raise HTTPException(status_code=403, detail="Not authorized to access this sandbox")
-
-async def get_sandbox_by_id_safely(client, sandbox_id: str):
-    """
-    Safely retrieve a sandbox object by its ID, using the project that owns it.
-    
-    Args:
-        client: The Supabase client
-        sandbox_id: The sandbox ID to retrieve
-    
-    Returns:
-        Sandbox: The sandbox object
-        
-    Raises:
-        HTTPException: If the sandbox doesn't exist or can't be retrieved
-    """
-    # Find the project that owns this sandbox
-    project_result = await client.table('projects').select('project_id').filter('sandbox->>id', 'eq', sandbox_id).execute()
-    
-    if not project_result.data or len(project_result.data) == 0:
-        logger.error(f"No project found for sandbox ID: {sandbox_id}")
-        raise HTTPException(status_code=404, detail="Sandbox not found - no project owns this sandbox ID")
-    
-    project_id = project_result.data[0]['project_id']
-    logger.debug(f"Found project {project_id} for sandbox {sandbox_id}")
-    
-    try:
-        # Get the sandbox
-        sandbox, retrieved_sandbox_id, sandbox_pass = await get_or_create_project_sandbox(client, project_id)
-        
-        # Verify we got the right sandbox
-        if retrieved_sandbox_id != sandbox_id:
-            logger.warning(f"Retrieved sandbox ID {retrieved_sandbox_id} doesn't match requested ID {sandbox_id} for project {project_id}")
-            # Fall back to the direct method if IDs don't match (shouldn't happen but just in case)
-            sandbox = await get_or_start_sandbox(sandbox_id)
-        
-        return sandbox
-    except Exception as e:
-        logger.error(f"Error retrieving sandbox {sandbox_id}: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Failed to retrieve sandbox: {str(e)}")
-
-@router.post("/sandboxes/{sandbox_id}/files")
-async def create_file(
-    sandbox_id: str, 
-    path: str = Form(...),
-    file: UploadFile = File(...),
-    request: Request = None,
-    user_id: Optional[str] = Depends(get_optional_user_id)
-):
-    """Create a file in the sandbox using direct file upload"""
-    logger.info(f"Received file upload request for sandbox {sandbox_id}, path: {path}, user_id: {user_id}")
-    client = await db.client
-    
-    # Verify the user has access to this sandbox
-    await verify_sandbox_access(client, sandbox_id, user_id)
-    
-    try:
-        # Get sandbox using the safer method
-        sandbox = await get_sandbox_by_id_safely(client, sandbox_id)
-        
-        # Read file content directly from the uploaded file
-        content = await file.read()
-        
-        # Create file using raw binary content
-        sandbox.fs.upload_file(path, content)
-        logger.info(f"File created at {path} in sandbox {sandbox_id}")
-        
-        return {"status": "success", "created": True, "path": path}
-    except Exception as e:
-        logger.error(f"Error creating file in sandbox {sandbox_id}: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-# For backward compatibility, keep the JSON version too
-@router.post("/sandboxes/{sandbox_id}/files/json")
-async def create_file_json(
-    sandbox_id: str, 
-    file_request: dict,
-    request: Request = None,
-    user_id: Optional[str] = Depends(get_optional_user_id)
-):
-    """Create a file in the sandbox using JSON (legacy support)"""
-    logger.info(f"Received JSON file creation request for sandbox {sandbox_id}, user_id: {user_id}")
-    client = await db.client
-    
-    # Verify the user has access to this sandbox
-    await verify_sandbox_access(client, sandbox_id, user_id)
-    
-    try:
-        # Get sandbox using the safer method
-        sandbox = await get_sandbox_by_id_safely(client, sandbox_id)
-        
-        # Get file path and content
-        path = file_request.get("path")
-        content = file_request.get("content", "")
-        
-        if not path:
-            logger.error(f"Missing file path in request for sandbox {sandbox_id}")
-            raise HTTPException(status_code=400, detail="File path is required")
-        
-        # Convert string content to bytes
-        if isinstance(content, str):
-            content = content.encode('utf-8')
-        
-        # Create file
-        sandbox.fs.upload_file(path, content)
-        logger.info(f"File created at {path} in sandbox {sandbox_id}")
-        
-        return {"status": "success", "created": True, "path": path}
-    except Exception as e:
-        logger.error(f"Error creating file in sandbox {sandbox_id}: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@router.get("/sandboxes/{sandbox_id}/files")
-async def list_files(
-    sandbox_id: str, 
-    path: str,
-    request: Request = None,
-    user_id: Optional[str] = Depends(get_optional_user_id)
-):
-    """List files and directories at the specified path"""
-    logger.info(f"Received list files request for sandbox {sandbox_id}, path: {path}, user_id: {user_id}")
-    client = await db.client
-    
-    # Verify the user has access to this sandbox
-    await verify_sandbox_access(client, sandbox_id, user_id)
-    
-    try:
-        # Get sandbox using the safer method
-        sandbox = await get_sandbox_by_id_safely(client, sandbox_id)
-        
-        # List files
-        files = sandbox.fs.list_files(path)
-        result = []
-        
-        for file in files:
-            # Convert file information to our model
-            # Ensure forward slashes are used for paths, regardless of OS
-            full_path = f"{path.rstrip('/')}/{file.name}" if path != '/' else f"/{file.name}"
-            file_info = FileInfo(
-                name=file.name,
-                path=full_path, # Use the constructed path
-                is_dir=file.is_dir,
-                size=file.size,
-                mod_time=str(file.mod_time),
-                permissions=getattr(file, 'permissions', None)
-            )
-            result.append(file_info)
-        
-        logger.info(f"Successfully listed {len(result)} files in sandbox {sandbox_id}")
-        return {"files": [file.dict() for file in result]}
-    except Exception as e:
-        logger.error(f"Error listing files in sandbox {sandbox_id}: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@router.get("/sandboxes/{sandbox_id}/files/content")
-async def read_file(
-    sandbox_id: str, 
-    path: str,
-    request: Request = None,
-    user_id: Optional[str] = Depends(get_optional_user_id)
-):
-    """Read a file from the sandbox"""
-    logger.info(f"Received file read request for sandbox {sandbox_id}, path: {path}, user_id: {user_id}")
-    client = await db.client
-    
-    # Verify the user has access to this sandbox
-    await verify_sandbox_access(client, sandbox_id, user_id)
-    
-    try:
-        # Get sandbox using the safer method
-        sandbox = await get_sandbox_by_id_safely(client, sandbox_id)
-        
-        # Read file
-        content = sandbox.fs.download_file(path)
-        
-        # Return a Response object with the content directly
-        filename = os.path.basename(path)
-        logger.info(f"Successfully read file {filename} from sandbox {sandbox_id}")
-        return Response(
-            content=content,
-            media_type="application/octet-stream",
-            headers={"Content-Disposition": f"attachment; filename={filename}"}
-        )
-    except Exception as e:
-        logger.error(f"Error reading file in sandbox {sandbox_id}: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@router.post("/project/{project_id}/sandbox/ensure-active")
-async def ensure_project_sandbox_active(
-    project_id: str,
-    request: Request = None,
-    user_id: Optional[str] = Depends(get_optional_user_id)
-):
-    """
-    Ensure that a project's sandbox is active and running.
-    Checks the sandbox status and starts it if it's not running.
-    """
-    logger.info(f"Received ensure sandbox active request for project {project_id}, user_id: {user_id}")
-    client = await db.client
-    
-    # Find the project and sandbox information
-    project_result = await client.table('projects').select('*').eq('project_id', project_id).execute()
-    
-    if not project_result.data or len(project_result.data) == 0:
-        logger.error(f"Project not found: {project_id}")
-        raise HTTPException(status_code=404, detail="Project not found")
-    
-    project_data = project_result.data[0]
-    
-    # For public projects, no authentication is needed
-    if not project_data.get('is_public'):
-        # For private projects, we must have a user_id
-        if not user_id:
-            logger.error(f"Authentication required for private project {project_id}")
-            raise HTTPException(status_code=401, detail="Authentication required for this resource")
-            
-        account_id = project_data.get('account_id')
-        
-        # Verify account membership
-        if account_id:
-            account_user_result = await client.schema('basejump').from_('account_user').select('account_role').eq('user_id', user_id).eq('account_id', account_id).execute()
-            if not (account_user_result.data and len(account_user_result.data) > 0):
-                logger.error(f"User {user_id} not authorized to access project {project_id}")
-                raise HTTPException(status_code=403, detail="Not authorized to access this project")
-    
-    try:
-        # Get or create the sandbox
-        logger.info(f"Ensuring sandbox is active for project {project_id}")
-        sandbox, sandbox_id, sandbox_pass = await get_or_create_project_sandbox(client, project_id)
-        
-        logger.info(f"Successfully ensured sandbox {sandbox_id} is active for project {project_id}")
-        
-        return {
-            "status": "success", 
-            "sandbox_id": sandbox_id,
-            "message": "Sandbox is active"
-        }
-    except Exception as e:
-        logger.error(f"Error ensuring sandbox is active for project {project_id}: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))

api_keys.py

@@ -7,8 +7,8 @@ from fastapi import APIRouter, Depends, HTTPException, status, Security
 from sqlalchemy.orm import Session
 
 from shared import schemas
-from database import models, session
-from crud import crud_api_key
+from daedalus.database import models, session
+from daedalus.crud import crud_api_key
 from . import dependencies # Assuming dependencies.py for auth
 
 router = APIRouter()

architecture_overview.md

@@ -0,0 +1,89 @@
+# VisionOS SaaS - Architecture Overview (Refined)
+
+## 1. Introduction
+
+This document outlines the high-level architecture for the VisionOS SaaS platform, refined based on detailed requirements analysis. VisionOS aims to be a comprehensive, AI-driven system capable of software development, automation (browser/computer), and potentially replacing other software stacks, built primarily using Free and Open Source Software (FOSS). It features a no-code customization interface and dynamic extensibility.
+
+The architecture follows a modular, layered, and iterative design philosophy, emphasizing separation of concerns, scalability, robustness, and user-driven customization.
+
+## 2. Core Principles
+
+- **Modularity:** Components are independent services with well-defined responsibilities.
+- **Scalability:** Supports horizontal scaling of agents and potentially other services.
+- **Asynchronicity:** Primary communication via Redis Streams for decoupling and resilience.
+- **Extensibility:** Dynamically load new agents, tools (via GitHub URLs), and capabilities with robust sandboxing.
+- **Customizability:** Enable system behavior modification via a no-code UI, driving configuration changes.
+- **Iterative Development:** Build and deploy in layers, starting with core functionality.
+- **FOSS-First:** Prioritize open-source technologies (Python, FastAPI, PostgreSQL, Redis, Docker, Kubernetes, React/Next.js, Ollama).
+- **Production-Grade:** Focus on reliability, error handling, security, logging, and documentation.
+
+## 3. High-Level Components (Refined)
+
+The system comprises the following major components:
+
+1.  **Vision UI (Frontend):** Web interface (React/Next.js) for user interaction, task submission, monitoring, results viewing, and **no-code system customization** (workflows, agent parameters, tool selection).
+2.  **Daedalus (Orchestrator - Backend API):** Central control plane (FastAPI). Manages tasks, coordinates agents, handles UI interactions via REST API, manages system/user configurations (driven by no-code UI), interacts with persistence/messaging, and exposes an **external integration API**.
+3.  **Agents (Backend Services):** Specialized, independent Python services (containerized). Execute tasks based on configuration, listen via Redis Streams, utilize tools (including LLMs), and interact with the **Extensibility Framework**.
+4.  **Local Agent (Client-Side Component):** (Future Implementation) A secure component installed on the user's machine (e.g., macOS) to execute local automation tasks (terminal, file system, application control like VS Code) under the direction of backend Agents via a secure channel.
+5.  **Shared Library (Python):** Common Python package for data models (Pydantic), utilities, communication helpers, base classes.
+6.  **Persistence Layer (Database):** PostgreSQL storing tasks, configurations (for no-code UI), agent registry, user data, knowledge base artifacts, artifact metadata.
+7.  **Messaging/Cache Layer (Broker):** Redis for asynchronous task queuing (Streams), result passing, potentially caching, and configuration updates.
+8.  **Extensibility Framework:** Backend mechanism (managed by Daedalus/Agents) to securely fetch, sandbox (e.g., subprocesses, containers), and execute tools/capabilities defined by GitHub URLs.
+9.  **AI/LLM Integration:** Framework for agents to interact with local LLMs (Ollama) and external APIs (securely configured via backend).
+10. **Knowledge Base/Search:** Components for storing, indexing (e.g., vector embeddings in DB or dedicated vector store), and searching across documents, code, and web results (Deep Search).
+11. **Artifact Management:** System for storing and managing generated artifacts (code, docs, images) potentially using object storage (like MinIO or cloud provider services) linked from the database.
+12. **Deployment Infrastructure:** Containerization (Docker), Orchestration (Kubernetes recommended), Ingress/Proxy (Nginx/Traefik).
+
+## 4. Refined Communication & Interaction Flows
+
+### 4.1 Basic Task Flow (Unchanged)
+
+(Remains as previously defined: User -> UI -> Daedalus -> Redis -> Agent -> LLM/Tools -> Redis -> Daedalus -> UI -> User)
+
+### 4.2 No-Code Customization Flow
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant VisionUI
+    participant DaedalusAPI
+    participant Database
+    participant Redis
+    participant Agent
+
+    User->>VisionUI: Modifies configuration (e.g., agent parameter) via No-Code Interface
+    VisionUI->>DaedalusAPI: PUT /configurations/{config_key} (New Value)
+    DaedalusAPI->>Database: Store/Update Configuration Record
+    DaedalusAPI->>Redis: (Optional) Publish config update event (Pub/Sub or Stream)
+    Note over DaedalusAPI, Agent: Agents might fetch config on task start or listen for updates
+    Agent->>DaedalusAPI: (On Task Start) GET /configurations/{config_key}
+    DaedalusAPI->>Database: Retrieve Configuration
+    Database-->>DaedalusAPI: Configuration Value
+    DaedalusAPI-->>Agent: Configuration Value
+    Agent->>Agent: Adjust behavior based on new configuration
+```
+
+### 4.3 Local Automation Flow (Conceptual)
+
+```mermaid
+sequenceDiagram
+    participant BackendAgent
+    participant DaedalusAPI
+    participant SecureChannel
+    participant LocalAgent (on User's Mac)
+    participant LocalApp (e.g., VS Code)
+
+    BackendAgent->>DaedalusAPI: Request local action (e.g., run terminal command)
+    DaedalusAPI->>SecureChannel: Forward action request to specific LocalAgent
+    SecureChannel->>LocalAgent: Deliver action request
+    LocalAgent->>LocalApp: Execute action (e.g., via AppleScript, CLI, API)
+    LocalApp-->>LocalAgent: Action Result/Status
+    LocalAgent->>SecureChannel: Send result back
+    SecureChannel->>DaedalusAPI: Forward result
+    DaedalusAPI->>BackendAgent: Deliver result
+```
+
+## 5. Next Steps
+
+Refine detailed architecture documents (Backend, Frontend, Data, Deployment) to reflect these changes, particularly focusing on the interfaces and data models required for the no-code customization, extensibility framework, local agent communication, and external API.
+

backend_architecture.md

@@ -0,0 +1,153 @@
+# VisionOS SaaS - Backend Architecture (Refined)
+
+## 1. Introduction
+
+This document details the architecture for the backend components of the VisionOS SaaS platform, including the Daedalus Orchestrator, the Agent Services, the Shared Library, the Extensibility Framework, and interactions with other backend systems. It builds upon the refined high-level overview in `architecture_overview.md`.
+
+## 2. Daedalus (Orchestrator)
+
+### 2.1 Role (Expanded)
+
+Daedalus serves as the central API and control plane for VisionOS.
+
+- **API Gateway:** Exposes RESTful APIs for frontend interactions (tasks, status, results, **configurations**) and an **external integration API**.
+- **Task Management:** Receives, validates, persists tasks (DB), assigns them to agents (Redis Streams), tracks status.
+- **Agent Coordination:** Manages agent registry, potentially routes tasks based on capabilities.
+- **Configuration Management:** Manages system-wide and agent-specific configurations, providing APIs for the no-code UI to modify them. Stores configurations persistently (DB).
+- **State Management:** Maintains overall task state and configuration state.
+- **Result Handling:** Consumes results from agents (Redis Streams), updates DB.
+- **Extensibility Framework Management:** May coordinate the loading/updating of tools within the extensibility framework.
+- **Local Agent Communication:** Relays requests from backend agents to the appropriate Local Agent via a secure channel.
+- **External API Authentication:** Manages API keys for external system integration.
+- **Notifications:** (Optional/Future) Pushes real-time updates (task status, config changes) to the frontend (WebSockets).
+
+### 2.2 Technology Stack
+
+- **Framework:** FastAPI (Python)
+- **Server:** Uvicorn
+- **Data Validation:** Pydantic
+- **Database Interaction:** SQLAlchemy (async) + AsyncPG
+- **Messaging:** Redis-py (async)
+- **Configuration:** Pydantic-Settings
+
+### 2.3 Key Modules/Components (Expanded)
+
+- **API Endpoints (`api/v1/endpoints/`):** Routers for `tasks.py`, `agents.py`, **`configurations.py`**, **`external_api.py`**.
+- **Schemas (`schemas/`):** Pydantic models for API requests/responses, DTOs, **configuration structures**.
+- **Database (`database/`):** SQLAlchemy models (`models.py`), session management (`session.py`), CRUD operations.
+- **Core (`core/`):** Configuration (`config.py`), security (API key handling, encryption), core utilities.
+- **Orchestrator Logic (`orchestrator/`):** Task processing, agent communication, result handling, **configuration propagation**, **local agent request relay**.
+- **Extensibility (`extensibility/`):** Modules related to managing dynamically loaded tools (if managed centrally).
+- **Main Application (`main.py`):** FastAPI setup, middleware, routers, startup/shutdown events.
+
+### 2.4 Communication (Expanded)
+
+- **Frontend <-> Daedalus:** Synchronous REST API calls (HTTPS).
+- **Daedalus <-> Database:** Asynchronous SQL queries.
+- **Daedalus <-> Redis:** Asynchronous commands (Streams for tasks/results, potentially Pub/Sub for config updates).
+- **Daedalus -> Agents:** Indirectly via Redis Streams (tasks, potentially config updates).
+- **Daedalus <- Agents:** Indirectly via Redis Streams (results).
+- **Daedalus <-> Local Agent:** Via a secure channel (e.g., WebSocket, gRPC with mTLS - specific protocol TBD).
+- **External Systems -> Daedalus:** Via secured REST API endpoints.
+
+## 3. Agent Services
+
+### 3.1 Role (Expanded)
+
+Agents are specialized, independent, **configurable** backend services executing tasks.
+
+- **Task Execution:** Consume tasks from Redis Streams, driven by parameters/configuration received with the task or fetched from Daedalus.
+- **Tool Utilization:** Interact with internal tools (Knowledge Base, Artifact Management), the **Extensibility Framework** (dynamically loaded tools), external APIs (LLMs), libraries, and system resources.
+- **LLM Interaction:** Utilize local Ollama or external LLM APIs based on configuration.
+- **Knowledge Base Interaction:** Query knowledge base for context, potentially contribute new artifacts.
+- **Artifact Management:** Store/retrieve generated artifacts (code, docs) via dedicated service/storage.
+- **Local Task Delegation:** Request execution of local tasks via Daedalus to the Local Agent.
+- **State Tracking & Result Publication:** Maintain task state, publish results/errors/logs/reasoning steps ("think mode" data) to Redis `result_stream`.
+- **Error Handling:** Robust error handling and reporting.
+
+### 3.2 Architecture (Expanded)
+
+- **Structure:** Separate Python applications/services, inheriting from a base agent class in `visionos_shared`.
+- **Technology:** Python 3.11+, `asyncio`, `redis-py` (async), `httpx`, `ollama`, domain-specific libraries. **Parameter-driven logic** using configurations.
+- **Deployment:** Containerized (Docker), orchestrated (Kubernetes).
+- **Communication:** Asynchronous via Redis Streams. May make synchronous API calls to Daedalus for configuration or specific data if needed.
+
+### 3.3 Example Agents (Expanded List)
+
+- **Coding Agent:** Code generation, modification, debugging, repo interactions.
+- **UI Agent:** Frontend code generation (React, Vue, etc.).
+- **Ops Agent:** Deployment, infrastructure (IaC tools, Docker SDK, K8s client), monitoring.
+- **Error Analysis Agent:** Log/error analysis, debugging assistance.
+- **Context Assist Agent:** Knowledge base interaction, context retrieval/management.
+- **Data Science Agent:** Data analysis, visualization, model training/interaction (using relevant libraries).
+- **Vision Agent:** Image analysis, generation, manipulation (using relevant libraries/APIs).
+- **NLP Agent:** Advanced text processing, summarization, translation (using relevant libraries/models).
+- **Research Agent:** Web browsing, information gathering, summarization, citation.
+- **Planning Agent:** Task decomposition, workflow generation, coordination between other agents for complex tasks.
+- **Web Browsing Agent:** Dedicated agent for interacting with web pages (using Playwright/Selenium).
+- **(Future) Local Control Agent:** Backend counterpart communicating with the client-side Local Agent.
+
+### 3.4 Agent Lifecycle & Communication (Refined)
+
+1.  **Startup:** Connect to Redis, join consumer group.
+2.  **Listening:** Block on `XREADGROUP`.
+3.  **Task Received:** Get task message (includes Task ID, input data, potentially initial configuration).
+4.  **(Optional) Fetch Config:** Agent may fetch additional/updated configuration from Daedalus API based on task context.
+5.  **Processing:** Execute task using configured tools, LLMs, knowledge base, artifact storage, potentially requesting local actions via Daedalus.
+6.  **Result Publishing:** Publish result, status, logs, errors, **reasoning steps** to `result_stream`.
+7.  **Acknowledgement:** `XACK` task message.
+8.  **Loop:** Return to listening.
+
+## 4. Shared Library (`visionos_shared`)
+
+### 4.1 Role (Expanded)
+
+Provides common code, data structures, and utilities.
+
+- **Data Models:** Pydantic models for tasks, results, agent registration, **configurations**, **artifacts**, **knowledge entries**, **tool definitions**.
+- **Communication Utilities:** Redis Streams helpers.
+- **Constants & Enums:** Task statuses, stream names, agent types, **configuration keys**.
+- **Base Classes:** Base `Agent` class, potentially base `Tool` class for extensibility framework.
+- **Logging Configuration:** Standardized setup.
+- **Security Utilities:** Common functions for secure operations (if any).
+
+### 4.2 Implementation
+
+- Standard Python package, installed as a dependency.
+
+## 5. Extensibility Framework
+
+### 5.1 Role
+
+Enables dynamic loading and execution of tools defined in external Git repositories.
+
+- **Tool Discovery/Fetching:** Mechanism to fetch code/definitions from a specified GitHub URL.
+- **Sandboxing:** **CRITICAL:** Execute fetched tool code in a secure, isolated environment (e.g., dedicated subprocess with restricted permissions, `seccomp` profiles, potentially Docker containers per execution) to mitigate risks.
+- **Interface:** Define a standard interface (`Tool` base class) that dynamically loaded tools must implement.
+- **Execution:** Agents utilize the framework to invoke specific tools with necessary inputs.
+- **Management:** (Potentially via Daedalus/UI) Interface to manage registered tool sources.
+
+### 5.2 Implementation
+
+- Likely involves Python modules within Agents or Daedalus using libraries like `gitpython` for fetching, `subprocess` or container runtimes for sandboxing, and `importlib` for dynamic loading (within the sandbox).
+
+## 6. Local Agent Communication Channel
+
+### 6.1 Role
+
+Provides a secure, bidirectional communication path between the backend (Daedalus) and the Local Agent running on the user's machine.
+
+### 6.2 Implementation Considerations
+
+- **Protocol:** WebSockets (potentially with WSS for encryption) or gRPC (with mTLS) are suitable options.
+- **Security:** Requires robust authentication and authorization to ensure only the legitimate backend can command the Local Agent and only the correct Local Agent responds. Connection initiation likely from Local Agent to Backend.
+- **Reliability:** Needs to handle disconnections and reconnections gracefully.
+
+## 7. Key Considerations (Expanded)
+
+- **Error Handling:** Comprehensive error handling across all components, including tool execution failures in the extensibility framework and local agent communication issues.
+- **Configuration Propagation:** Efficiently update agents when configurations change via the no-code UI (e.g., Redis Pub/Sub or fetching on task start).
+- **Security:** Secure external API, secure local agent channel, robust sandboxing for extensibility, secure credential management (backend-only).
+- **Scalability:** Horizontal scaling of agents. Consider potential bottlenecks in Daedalus, Database, Redis.
+- **Monitoring & Logging:** Structured logging including task IDs, agent IDs, tool usage. Metrics for queue lengths, task durations, error rates, resource usage per agent/tool.
+

config.py

@@ -1,164 +1,73 @@
-"""
-Configuration management.
+# /home/ubuntu/visionos_farm/daedalus/core/config.py
 
-This module provides a centralized way to access configuration settings and
-environment variables across the application. It supports different environment
-modes (development, staging, production) and provides validation for required
-values.
+import os
+from typing import Optional, Any
+from pydantic_settings import BaseSettings
+from pydantic import PostgresDsn, RedisDsn
 
-Usage:
-    from utils.config import config
-    
-    # Access configuration values
-    api_key = config.OPENAI_API_KEY
-    env_mode = config.ENV_MODE
-"""
+class Settings(BaseSettings):
+    PROJECT_NAME: str = "VisionOS Daedalus"
+    API_V1_STR: str = "/api/v1"
 
-import os
-from enum import Enum
-from typing import Dict, Any, Optional, get_type_hints, Union
-from dotenv import load_dotenv
-import logging
+    # Database Configuration
+    POSTGRES_SERVER: str = os.getenv("POSTGRES_SERVER", "localhost")
+    POSTGRES_PORT: str = os.getenv("POSTGRES_PORT", "5432")
+    POSTGRES_USER: str = os.getenv("POSTGRES_USER", "visionos_user")
+    POSTGRES_PASSWORD: str = os.getenv("POSTGRES_PASSWORD", "visionos_password")
+    POSTGRES_DB: str = os.getenv("POSTGRES_DB", "visionos_db")
+    # Asynchronous database connection string
+    DATABASE_URL: Optional[PostgresDsn] = None
+
+    # Redis Configuration
+    REDIS_HOST: str = os.getenv("REDIS_HOST", "localhost")
+    REDIS_PORT: int = int(os.getenv("REDIS_PORT", 6379))
+    REDIS_DB: int = int(os.getenv("REDIS_DB", 0))
+    REDIS_PASSWORD: Optional[str] = os.getenv("REDIS_PASSWORD", None)
+    REDIS_URL: Optional[RedisDsn] = None
+
+    # Redis Stream Names
+    REDIS_TASK_STREAM: str = "visionos_task_stream"
+    REDIS_RESULT_STREAM: str = "visionos_result_stream"
+    REDIS_CONFIG_UPDATE_CHANNEL: str = "visionos_config_updates"
+
+    # Agent Configuration
+    AGENT_HEARTBEAT_INTERVAL: int = 30 # seconds
+
+    # Security
+    SECRET_KEY: str = os.getenv("SECRET_KEY", "a_very_secret_key_that_should_be_changed") # CHANGE THIS!
+    # Define algorithm for JWT if using token auth
+    # ALGORITHM: str = "HS256"
+    # ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
+
+    # CORS Origins (Update in production)
+    BACKEND_CORS_ORIGINS: list[str] = ["http://localhost", "http://localhost:3000", "http://127.0.0.1:3000"]
 
-logger = logging.getLogger(__name__)
+    class Config:
+        case_sensitive = True
+        env_file = ".env"
+        env_file_encoding = "utf-8"
 
-class EnvMode(Enum):
-    """Environment mode enumeration."""
-    LOCAL = "local"
-    STAGING = "staging"
-    PRODUCTION = "production"
+    def __init__(self, **values: Any):
+        super().__init__(**values)
+        # Construct DATABASE_URL from components if not set directly
+        if self.DATABASE_URL is None:
+            self.DATABASE_URL = PostgresDsn.build(
+                scheme="postgresql+asyncpg",
+                username=self.POSTGRES_USER,
+                password=self.POSTGRES_PASSWORD,
+                host=self.POSTGRES_SERVER,
+                port=int(self.POSTGRES_PORT),
+                path=self.POSTGRES_DB,
+            )
+        # Construct REDIS_URL from components if not set directly
+        if self.REDIS_URL is None:
+            self.REDIS_URL = RedisDsn.build(
+                scheme="redis",
+                host=self.REDIS_HOST,
+                port=self.REDIS_PORT,
+                password=self.REDIS_PASSWORD,
+                path=f"/{self.REDIS_DB}",
+            )
 
-class Configuration:
-    """
-    Centralized configuration for AgentPress backend.
-    
-    This class loads environment variables and provides type checking and validation.
-    Default values can be specified for optional configuration items.
-    """
-    
-    # Environment mode
-    ENV_MODE: EnvMode = EnvMode.LOCAL
-    
-    # LLM API keys
-    ANTHROPIC_API_KEY: str = None
-    OPENAI_API_KEY: Optional[str] = None
-    GROQ_API_KEY: Optional[str] = None
-    OPENROUTER_API_KEY: Optional[str] = None
-    OPENROUTER_API_BASE: Optional[str] = "https://openrouter.ai/api/v1"
-    OR_SITE_URL: Optional[str] = None
-    OR_APP_NAME: Optional[str] = "Suna.so"    
-    
-    # AWS Bedrock credentials
-    AWS_ACCESS_KEY_ID: Optional[str] = None
-    AWS_SECRET_ACCESS_KEY: Optional[str] = None
-    AWS_REGION_NAME: Optional[str] = None
-    
-    # Model configuration
-    MODEL_TO_USE: Optional[str] = "anthropic/claude-3-7-sonnet-latest"
-    
-    # Supabase configuration
-    SUPABASE_URL: str
-    SUPABASE_ANON_KEY: str
-    SUPABASE_SERVICE_ROLE_KEY: str
-    
-    # Redis configuration
-    REDIS_HOST: str
-    REDIS_PORT: int = 6379
-    REDIS_PASSWORD: str
-    REDIS_SSL: bool = True
-    
-    # Daytona sandbox configuration
-    DAYTONA_API_KEY: str
-    DAYTONA_SERVER_URL: str
-    DAYTONA_TARGET: str
-    
-    # Search and other API keys
-    TAVILY_API_KEY: str
-    RAPID_API_KEY: str
-    CLOUDFLARE_API_TOKEN: Optional[str] = None
-    FIRECRAWL_API_KEY: str
-    
-    # Stripe configuration
-    STRIPE_SECRET_KEY: Optional[str] = None
-    STRIPE_DEFAULT_PLAN_ID: Optional[str] = None
-    STRIPE_DEFAULT_TRIAL_DAYS: int = 14
-    
-    
-    def __init__(self):
-        """Initialize configuration by loading from environment variables."""
-        # Load environment variables from .env file if it exists
-        load_dotenv()
-        
-        # Set environment mode first
-        env_mode_str = os.getenv("ENV_MODE", EnvMode.LOCAL.value)
-        try:
-            self.ENV_MODE = EnvMode(env_mode_str.lower())
-        except ValueError:
-            logger.warning(f"Invalid ENV_MODE: {env_mode_str}, defaulting to LOCAL")
-            self.ENV_MODE = EnvMode.LOCAL
-            
-        logger.info(f"Environment mode: {self.ENV_MODE.value}")
-        
-        # Load configuration from environment variables
-        self._load_from_env()
-        
-        # Perform validation
-        self._validate()
-        
-    def _load_from_env(self):
-        """Load configuration values from environment variables."""
-        for key, expected_type in get_type_hints(self.__class__).items():
-            env_val = os.getenv(key)
-            
-            if env_val is not None:
-                # Convert environment variable to the expected type
-                if expected_type == bool:
-                    # Handle boolean conversion
-                    setattr(self, key, env_val.lower() in ('true', 't', 'yes', 'y', '1'))
-                elif expected_type == int:
-                    # Handle integer conversion
-                    try:
-                        setattr(self, key, int(env_val))
-                    except ValueError:
-                        logger.warning(f"Invalid value for {key}: {env_val}, using default")
-                elif expected_type == EnvMode:
-                    # Already handled for ENV_MODE
-                    pass
-                else:
-                    # String or other type
-                    setattr(self, key, env_val)
-    
-    def _validate(self):
-        """Validate configuration based on type hints."""
-        # Get all configuration fields and their type hints
-        type_hints = get_type_hints(self.__class__)
-        
-        # Find missing required fields
-        missing_fields = []
-        for field, field_type in type_hints.items():
-            # Check if the field is Optional
-            is_optional = hasattr(field_type, "__origin__") and field_type.__origin__ is Union and type(None) in field_type.__args__
-            
-            # If not optional and value is None, add to missing fields
-            if not is_optional and getattr(self, field) is None:
-                missing_fields.append(field)
-        
-        if missing_fields:
-            error_msg = f"Missing required configuration fields: {', '.join(missing_fields)}"
-            logger.error(error_msg)
-            raise ValueError(error_msg)
-    
-    def get(self, key: str, default: Any = None) -> Any:
-        """Get a configuration value with an optional default."""
-        return getattr(self, key, default)
-    
-    def as_dict(self) -> Dict[str, Any]:
-        """Return configuration as a dictionary."""
-        return {
-            key: getattr(self, key) 
-            for key in get_type_hints(self.__class__).keys()
-            if not key.startswith('_')
-        }
+settings = Settings()
 
-# Create a singleton instance
-config = Configuration() 

configurations.py

@@ -7,9 +7,9 @@ from sqlalchemy.ext.asyncio import AsyncSession
 import redis.asyncio as redis
 
 from shared import schemas
-from crud import crud_config
-from database.session import get_db
-from core.config import settings
+from daedalus.crud import crud_config
+from daedalus.database.session import get_db
+from daedalus.core.config import settings
 
 router = APIRouter()
 

data_architecture.md

@@ -0,0 +1,155 @@
+# VisionOS SaaS - Data Architecture (Refined)
+
+## 1. Introduction
+
+This document outlines the data architecture for the VisionOS SaaS platform, covering persistent storage (PostgreSQL), messaging/cache (Redis), and potentially artifact/vector storage. It complements the refined overall, backend, and frontend architecture documents.
+
+## 2. Persistence Layer (PostgreSQL)
+
+### 2.1 Role (Expanded)
+
+PostgreSQL serves as the primary persistent storage for structured data.
+
+- **Task Data:** Task details, inputs, status history, results, logs, reasoning steps.
+- **Configuration Data:** Stores system-wide settings, agent parameters, tool configurations, and workflow definitions managed via the no-code UI.
+- **Agent Registry:** (Future) Agent information, capabilities, status.
+- **User Data:** (If implemented) User profiles, authentication (hashed credentials), preferences, **encrypted external API keys** (alternative to secrets manager).
+- **Project/Workflow State:** Definitions and states of complex workflows.
+- **Knowledge Base Metadata:** Stores structured metadata, indexed content, source URIs for knowledge artifacts. Vector embeddings might be stored here (using `pgvector`) or in a dedicated vector database.
+- **Artifact Metadata:** Stores metadata about generated artifacts (code, docs, images), linking to their actual storage location (e.g., object storage URI).
+
+### 2.2 Technology
+
+- **Database:** PostgreSQL (Version 15+).
+- **Vector Support:** (Optional) `pgvector` extension if storing embeddings directly in PostgreSQL.
+- **Interaction Library:** SQLAlchemy (async 2.0+) + `asyncpg`.
+- **Schema Migrations:** Alembic.
+
+### 2.3 Key Schemas (Expanded & Refined)
+
+- **`tasks` table:**
+    - `id` (UUID, PK)
+    - `user_id` (UUID, FK, nullable)
+    - `submitted_at` (TimestampTZ)
+    - `status` (String/Enum)
+    - `input_data` (JSONB)
+    - `result_data` (JSONB, nullable)
+    - `error_message` (Text, nullable)
+    - `logs` (JSONB or Text[], nullable)
+    - **`reasoning_steps`** (JSONB, nullable) - For "think mode"
+    - `configuration_snapshot` (JSONB, nullable) - Config used for this task
+- **`configurations` table:**
+    - `key` (String, PK) - e.g., "agent.coding.model_name", "ui.theme"
+    - `value` (JSONB or Text) - The configuration value
+    - `description` (Text, nullable)
+    - `scope` (String/Enum: system, user, agent_type)
+    - `updated_at` (TimestampTZ)
+- **`users` table:** (If implemented)
+    - `id` (UUID, PK)
+    - `username` (String, Unique)
+    - `hashed_password` (String)
+    - **`encrypted_api_keys`** (JSONB, nullable) - Encrypted keys for external services
+- **`knowledge_artifacts` table:**
+    - `id` (UUID, PK)
+    - `source_uri` (String)
+    - `artifact_type` (String/Enum)
+    - `content_summary` (Text, nullable)
+    - `metadata` (JSONB)
+    - **`embedding`** (Vector, nullable) - Requires `pgvector` or link to external store
+    - `created_at` (TimestampTZ)
+- **`generated_artifacts` table:**
+    - `id` (UUID, PK)
+    - `task_id` (UUID, FK)
+    - `artifact_name` (String)
+    - `artifact_type` (String/Enum: code, document, image)
+    - **`storage_uri`** (String) - Link to actual file in object storage
+    - `metadata` (JSONB)
+    - `created_at` (TimestampTZ)
+- **`tool_sources` table:** (For Extensibility Framework)
+    - `id` (UUID, PK)
+    - `github_url` (String, Unique)
+    - `description` (Text, nullable)
+    - `status` (String/Enum: active, inactive, error)
+    - `last_checked_at` (TimestampTZ)
+
+### 2.4 Considerations
+
+- **Indexing:** Crucial for `configurations` key, `tasks` status/user_id, `knowledge_artifacts` metadata/embeddings.
+- **Data Integrity:** Use constraints.
+- **Encryption:** Use strong encryption (e.g., `cryptography` library) for sensitive data like `encrypted_api_keys` stored in the DB.
+- **Scalability:** Standard PostgreSQL scaling applies. Vector search performance might require tuning or a dedicated vector DB.
+- **Backups:** Essential.
+
+## 3. Messaging/Cache Layer (Redis)
+
+### 3.1 Role (Expanded)
+
+- **Task Queuing (Streams):** Distribute tasks (`task_stream`) and collect results (`result_stream`).
+- **Configuration Cache:** (Recommended) Cache frequently accessed configurations from PostgreSQL to reduce DB load for agents/Daedalus.
+- **Configuration Updates (Pub/Sub):** (Recommended) Daedalus publishes messages on a dedicated channel (e.g., `config_updates`) when configurations are changed via the API/UI. Interested services (Agents, potentially Daedalus instances) subscribe to invalidate their cache or reload config.
+- **Real-time UI Notifications (Pub/Sub):** Can be used instead of or alongside WebSockets originating from Daedalus.
+
+### 3.2 Technology
+
+- **Server:** Redis (Version 7+).
+- **Interaction Library:** `redis-py` (async).
+
+### 3.3 Usage (Expanded)
+
+- **Streams:** As previously defined for tasks/results.
+- **Caching:** Standard Redis key-value caching (e.g., `GET config:agent.coding.model_name`, `SET config:agent.coding.model_name "value" EX <ttl>`).
+- **Pub/Sub:**
+    - Daedalus uses `PUBLISH config_updates "{key: 'agent.coding.model_name', scope: 'agent_type'}"`.
+    - Subscribers use `SUBSCRIBE config_updates` and listen for messages.
+
+### 3.4 Considerations
+
+- **Persistence:** Configure appropriately for durability needs (Streams benefit from AOF/RDB).
+- **Scalability:** Redis scales well; clustering available if needed.
+- **Stream Trimming:** Implement strategy (`MAXLEN`/`MINID`).
+- **Cache Invalidation:** Use TTLs and Pub/Sub updates for effective cache management.
+- **Error Handling:** Implement robust consumer logic for Streams and Pub/Sub.
+
+## 4. Artifact Storage (Object Storage)
+
+### 4.1 Role
+
+Stores large binary artifacts generated by agents (e.g., code files, documents, images) that are not suitable for direct storage in PostgreSQL or Redis.
+
+### 4.2 Technology
+
+- **Options:**
+    - Self-hosted: MinIO (S3-compatible open-source object storage).
+    - Cloud-based: AWS S3, Google Cloud Storage, Azure Blob Storage.
+- **Interaction:** Use appropriate SDKs (e.g., `boto3` for S3/MinIO, `google-cloud-storage`).
+
+### 4.3 Usage
+
+- Agents upload generated files to the object store.
+- The storage URI (e.g., `s3://bucket-name/path/to/artifact.py`) is saved in the `generated_artifacts` table in PostgreSQL.
+- Daedalus/UI can generate pre-signed URLs for secure, temporary access to download artifacts if needed.
+
+## 5. Vector Database (Optional/Alternative)
+
+### 5.1 Role
+
+If `pgvector` performance is insufficient for large-scale similarity searches within the knowledge base, a dedicated vector database can be used.
+
+### 5.2 Technology
+
+- **Options:** Milvus, Weaviate, Pinecone, Qdrant.
+- **Interaction:** Use specific client libraries.
+
+### 5.3 Usage
+
+- Store vector embeddings generated from knowledge artifacts.
+- Perform similarity searches during context retrieval.
+- Metadata might still reside in PostgreSQL, linking to the vector ID in the vector database.
+
+## 6. Data Flow Summary (Refined)
+
+- Task flow remains similar, but agents now fetch configuration (potentially from Redis cache or Daedalus API backed by PostgreSQL) at the start.
+- Agents may interact with Knowledge Base (PostgreSQL/Vector DB) and Artifact Storage (Object Store) during processing.
+- Configuration changes via UI update PostgreSQL and potentially trigger Redis Pub/Sub messages for cache invalidation/updates.
+- Results published to `result_stream` include links (URIs) to artifacts stored in object storage and reasoning steps.
+

deployment_architecture.md

@@ -0,0 +1,100 @@
+# VisionOS SaaS - Deployment Architecture (Refined)
+
+## 1. Introduction
+
+This document outlines the deployment architecture for the VisionOS SaaS platform, refined to incorporate enhanced features like no-code customization, extensibility, local agent interaction, artifact storage, and advanced AI capabilities. It covers containerization, orchestration, networking, CI/CD, and deployment considerations for all components.
+
+## 2. Core Principles
+
+- **Containerization:** All backend services (Daedalus, Agents) containerized (Docker).
+- **Orchestration:** Kubernetes recommended for scalability and management. Docker Compose suitable for simpler local development/testing.
+- **Infrastructure as Code (IaC):** Terraform/Pulumi for cloud infrastructure.
+- **CI/CD:** Automated build, test, deploy pipelines (GitHub Actions/GitLab CI).
+- **Scalability & Availability:** Horizontal scaling for stateless services (Agents, Daedalus instances); HA for stateful services (DB, Redis, Object Store).
+- **Security:** Network policies, secrets management, secure communication channels.
+
+## 3. Deployment Model (Refined)
+
+### 3.1 Components & Containers/Services
+
+- **Daedalus API:** Docker container (FastAPI/Uvicorn).
+- **Agent Services:** Individual Docker containers per agent type.
+- **Vision UI:** Static build (HTML/CSS/JS) served via Nginx container or dedicated hosting/CDN.
+- **PostgreSQL:** Managed DB service (AWS RDS, Google Cloud SQL) or Kubernetes StatefulSet + Persistent Volumes.
+- **Redis:** Managed cache service (ElastiCache, Memorystore) or Kubernetes StatefulSet + Persistent Volumes.
+- **Ollama:** Separate containerized service, accessible by Agents.
+- **Artifact Storage (Object Store):** Managed service (S3, GCS) or self-hosted MinIO (containerized, potentially StatefulSet).
+- **Vector Database:** (If used) Managed service or self-hosted (e.g., Milvus/Weaviate on Kubernetes).
+- **Extensibility Sandbox:** The environment for running dynamic tools. Could be:
+    - Managed within Agent containers (using subprocesses with strict resource limits and permissions via `prlimit`/`seccomp`).
+    - Dedicated Docker containers launched on demand by Agents (requires Docker-in-Docker or access to host Docker socket - security implications).
+- **Local Agent:** **Not deployed centrally.** Requires separate installation package/process for user's local machine (macOS initially).
+- **Secure Channel Endpoint:** Service within Kubernetes (potentially part of Daedalus or separate) to handle connections from Local Agents (e.g., WebSocket/gRPC endpoint).
+- **Ingress/Proxy:** Nginx/Traefik (Kubernetes Ingress Controller or standalone).
+
+### 3.2 Orchestration (Kubernetes Example - Expanded)
+
+- **Daedalus:** Deployment + Service + HPA (optional).
+- **Agents:** Deployments (one per type) + Services + HPAs (based on CPU/memory/queue length).
+- **PostgreSQL:** StatefulSet + PVC + Service (or external service endpoint).
+- **Redis:** StatefulSet + PVC + Service (or external service endpoint).
+- **MinIO (if self-hosted):** StatefulSet + PVC + Service.
+- **Vector DB (if self-hosted):** Appropriate Helm chart or Operator (e.g., Milvus Operator).
+- **Vision UI (Nginx):** Deployment + Service.
+- **Secure Channel Endpoint:** Deployment + Service (potentially LoadBalancer or NodePort if needing external access for Local Agent connection).
+- **Ingress:** Ingress Controller + Ingress Resource.
+- **Configuration:** ConfigMaps, Secrets.
+- **Sandboxing Resources:** If using containerized sandboxes, potentially requires privileged Agent containers or specific node configurations.
+
+### 3.3 Networking (Refined)
+
+- **External Access:** Ingress for Vision UI, Daedalus API. Separate secure endpoint for Local Agent connections.
+- **Internal Communication:** Kubernetes Services.
+- **Security:** Network Policies to restrict traffic (e.g., Agents only talk to Redis, DB via Daedalus, Ollama, Artifact Store, Extensibility Sandbox; Daedalus talks to DB, Redis, Secure Channel Endpoint).
+- **Local Agent Channel:** Requires secure, authenticated connection (WSS/mTLS) from user's network to the Secure Channel Endpoint.
+
+## 4. CI/CD Pipeline (Refined)
+
+1.  **Trigger:** Code push/tag.
+2.  **Build:** Docker images (Backend), Static assets (UI).
+3.  **Test:** Unit, Integration (using Docker Compose), Frontend, E2E tests.
+4.  **Push:** Docker images to registry.
+5.  **Deploy (Backend/UI):** Update K8s manifests/Helm charts, apply changes (`kubectl`/`helm`). Upload UI assets.
+6.  **Deploy (Local Agent):** Separate process to build installer/package for macOS.
+
+## 5. Configuration & Secrets Management (Refined)
+
+- **Environment Variables:** Via ConfigMaps/Secrets.
+- **Secrets:** K8s Secrets or Vault for DB passwords, internal keys, external service keys managed by the system.
+- **User API Keys:** Stored encrypted in DB or secrets manager, accessed only by backend.
+- **No-Code Config:** Stored in PostgreSQL, potentially cached in Redis, managed via Daedalus API.
+
+## 6. Monitoring & Logging (Refined)
+
+- **Logging:** Structured JSON logs aggregated (EFK/Loki).
+- **Metrics:** Prometheus scraping metrics (request latency, errors, queue lengths, agent/tool resource usage).
+- **Tracing:** OpenTelemetry for distributed tracing.
+- **Health Checks:** K8s readiness/liveness probes.
+- **Alerting:** Alertmanager based on metrics/logs.
+
+## 7. Iterative Deployment Strategy (Refined)
+
+1.  **Foundation:** K8s cluster, DB, Redis, Object Store (if self-hosted).
+2.  **Core Backend:** Daedalus API.
+3.  **Basic Agent:** Deploy Coding Agent.
+4.  **Basic Frontend:** Deploy Vision UI (task submission/viewing).
+5.  **Core Features:** Implement/Deploy Knowledge Base, Artifact Management integration.
+6.  **Extensibility:** Deploy Extensibility Framework (including sandboxing).
+7.  **No-Code UI:** Deploy configuration management UI.
+8.  **Additional Agents:** Incrementally deploy other specialized agents.
+9.  **Local Agent:** Develop and provide Local Agent installer and deploy Secure Channel Endpoint.
+10. **Iterate:** Continue adding features based on user feedback and priorities.
+
+## 8. Local Agent Deployment
+
+- **Packaging:** Create a standard macOS application bundle (`.app`) or installer (`.pkg`).
+- **Installation:** User downloads and installs manually.
+- **Configuration:** Needs mechanism to securely configure connection details (URL of Secure Channel Endpoint, authentication token/certificate) during or after installation.
+- **Permissions:** Installer may need to request necessary permissions (e.g., Accessibility for UI automation, Full Disk Access for file manipulation).
+- **Updates:** Requires an update mechanism (manual download or auto-update feature).
+

distutils-precedence.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ea7ffef3fe2a117ee12c68ed6553617f0d7fd2f0590257c25c484959a3b7373
+size 152

docker-compose.yml

@@ -1,44 +1,26 @@
+version: '3.8'
+
 services:
-  kortix-suna:
-    platform: linux/amd64
-    build:
-      context: .
-      dockerfile: ${DOCKERFILE:-Dockerfile}
-      args:
-        TARGETPLATFORM: ${TARGETPLATFORM:-linux/amd64}
-    image: adamcohenhillel/kortix-suna:0.0.20
-    ports:
-      - "6080:6080"  # noVNC web interface
-      - "5901:5901"  # VNC port
-      - "9222:9222"  # Chrome remote debugging port
-      - "8000:8000"  # API server port
-      - "8080:8080"  # HTTP server port
+  postgres:
+    image: postgres:15
+    restart: always
     environment:
-      - ANONYMIZED_TELEMETRY=${ANONYMIZED_TELEMETRY:-false}
-      - CHROME_PATH=/usr/bin/google-chrome
-      - CHROME_USER_DATA=/app/data/chrome_data
-      - CHROME_PERSISTENT_SESSION=${CHROME_PERSISTENT_SESSION:-false}
-      - CHROME_CDP=${CHROME_CDP:-http://localhost:9222}
-      - DISPLAY=:99
-      - PLAYWRIGHT_BROWSERS_PATH=/ms-playwright
-      - RESOLUTION=${RESOLUTION:-1024x768x24}
-      - RESOLUTION_WIDTH=${RESOLUTION_WIDTH:-1024}
-      - RESOLUTION_HEIGHT=${RESOLUTION_HEIGHT:-768}
-      - VNC_PASSWORD=${VNC_PASSWORD:-vncpassword}
-      - CHROME_DEBUGGING_PORT=9222
-      - CHROME_DEBUGGING_HOST=localhost
+      - POSTGRES_USER=visionos_user
+      - POSTGRES_PASSWORD=visionos_pass
+      - POSTGRES_DB=visionos_db
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+
+  redis:
+    image: redis:7
+    restart: always
+    ports:
+      - "6379:6379"
     volumes:
-      - /tmp/.X11-unix:/tmp/.X11-unix
-    restart: unless-stopped
-    shm_size: '2gb'
-    cap_add:
-      - SYS_ADMIN
-    security_opt:
-      - seccomp=unconfined
-    tmpfs:
-      - /tmp
-    healthcheck:
-      test: ["CMD", "nc", "-z", "localhost", "5901"]
-      interval: 10s
-      timeout: 5s
-      retries: 3
+      - redis_data:/data
+
+volumes:
+  postgres_data:
+  redis_data:

dotenv

@@ -0,0 +1,8 @@
+#!/Users/lattm/Downloads/home/visionos_venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from dotenv.__main__ import cli
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(cli())

extensibility_framework.md

@@ -0,0 +1,98 @@
+# VisionOS SaaS - Extensibility Framework Design
+
+## 1. Introduction
+
+This document outlines the design for the extensibility framework within VisionOS, enabling the dynamic integration of tools, features, and functionalities specified via GitHub repository URLs. This framework is crucial for allowing VisionOS to evolve and adapt by incorporating new capabilities with minimal core system changes, aligning with the user's requirement for maximum versatility and future-proofing.
+
+## 2. Goals
+
+- **Dynamic Loading:** Allow agents (primarily) to load and utilize code/tools from specified GitHub repositories at runtime or during initialization.
+- **Standardized Interface:** Define a clear interface that dynamically loaded tools must adhere to for seamless integration.
+- **Security:** Implement security measures to mitigate risks associated with executing external code (sandboxing, permission controls).
+- **Management:** Provide mechanisms for registering, managing, and potentially versioning these external tools.
+- **Simplicity:** Aim for a straightforward process for developers to package their tools for compatibility with VisionOS.
+
+## 3. Proposed Architecture (Agent-Focused)
+
+The primary focus is enabling Agents to use external tools. A similar pattern could potentially be adapted for frontend plugins later, but is out of scope for the initial design.
+
+### 3.1 Tool Definition & Packaging (External Repository)
+
+Developers creating tools for VisionOS would structure their GitHub repository in a defined way:
+
+- **`manifest.json` (or `visionos_tool.yaml`):** A metadata file at the repository root describing the tool.
+    - `name`: Unique tool name.
+    - `version`: Tool version (e.g., SemVer).
+    - `description`: Brief description.
+    - `entry_point`: The main Python module/class to load (e.g., `src.my_tool:MyToolClass`).
+    - `dependencies`: A `requirements.txt` file path within the repo, listing Python dependencies.
+    - `permissions_required`: (Future) List of permissions needed (e.g., `filesystem_read`, `network_access`, `llm_call`).
+- **Source Code:** Python code implementing the tool logic, adhering to the VisionOS Tool Interface.
+- **`requirements.txt`:** Lists the tool's specific Python dependencies.
+
+### 3.2 Tool Loading & Execution (Agent Side)
+
+1.  **Registration:** Daedalus (or an admin interface) would manage a list of registered external tools, mapping a tool name/ID to its GitHub URL and potentially a specific commit/tag/branch.
+2.  **Task Assignment:** When a task requiring an external tool is assigned to an agent, the task details include the tool name/ID.
+3.  **Tool Acquisition (Agent):**
+    a.  The agent checks if the required tool (and specific version) is already locally available/cached.
+    b.  If not, the agent uses `GitPython` to clone or pull the specified repository (and checkout the correct version) into a dedicated, isolated directory (e.g., `/home/ubuntu/visionos_farm/agent_tools/<agent_id>/<tool_name>/<version>`).
+4.  **Environment Setup (Agent):**
+    a.  The agent creates a dedicated Python virtual environment (`venv`) within the tool's isolated directory.
+    b.  It installs the tool's dependencies listed in its `requirements.txt` into this dedicated `venv` using `pip`.
+5.  **Dynamic Loading (Agent):**
+    a.  The agent uses Python's `importlib` (or similar mechanisms) to dynamically load the specified `entry_point` module/class *from the tool's isolated directory and virtual environment context*.
+    b.  This might involve manipulating `sys.path` temporarily or executing the tool's code within a subprocess that activates the tool's specific `venv`.
+6.  **Interface Invocation (Agent):**
+    a.  The agent instantiates the loaded tool class (if applicable).
+    b.  It calls the standardized method (e.g., `execute(params)`) defined by the VisionOS Tool Interface, passing necessary parameters.
+7.  **Execution & Result:** The tool code executes within its isolated environment, performs its function, and returns results to the agent.
+8.  **Cleanup:** (Optional) Cache the cloned repo and environment for reuse, or clean up based on policy.
+
+### 3.3 VisionOS Tool Interface (Python Example)
+
+External tools would implement a standard interface, potentially defined in the `visionos_shared` library.
+
+```python
+# In visionos_shared.interfaces
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+class VisionOSTool(ABC):
+
+    def __init__(self, config: Dict[str, Any]):
+        """Initialize the tool with any required configuration."""
+        self.config = config
+
+    @abstractmethod
+    def execute(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute the tool's main function."""
+        pass
+
+    # Optional: Methods for setup, teardown, status checks, etc.
+```
+
+### 3.4 Security Considerations
+
+- **Isolation:** Cloning repos and creating separate virtual environments provides filesystem and dependency isolation.
+- **Code Execution Risks:** Running arbitrary code from GitHub is inherently risky.
+    - **Sandboxing:** Consider running the tool loading/execution logic within a dedicated container or using OS-level sandboxing mechanisms (e.g., `nsjail`, `firecracker` - more complex) for stronger isolation.
+    - **Permission Model:** (Future) Implement a permission system where tools declare required permissions in their manifest, and the agent/orchestrator grants them selectively.
+    - **Code Review/Vetting:** Implement a process (manual or automated) for vetting registered tools before they are widely usable.
+    - **Network Policies:** Restrict network access for tool execution environments unless explicitly required and permitted.
+- **Dependency Conflicts:** Per-tool virtual environments mitigate Python dependency conflicts between tools and the agent itself.
+
+## 4. Implementation Notes
+
+- **Agent Modification:** Agents need logic to handle tool acquisition, environment setup, dynamic loading, and execution.
+- **Shared Library:** Update `visionos_shared` with the `VisionOSTool` interface.
+- **Daedalus:** Needs API endpoints and database schema updates to manage the registry of external tools.
+- **Error Handling:** Robust error handling is needed for Git operations, dependency installation, code loading, and tool execution.
+
+## 5. Next Steps
+
+- Refine the `manifest.json` structure and Tool Interface.
+- Prototype the tool acquisition and dynamic loading mechanism within a sample agent.
+- Integrate tool registration management into Daedalus.
+- Address security sandboxing approaches in more detail.
+

fastapi

@@ -0,0 +1,8 @@
+#!/Users/lattm/Downloads/home/visionos_venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from fastapi.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

frontend_architecture.md

@@ -0,0 +1,73 @@
+# VisionOS SaaS - Frontend Architecture (Vision UI) (Refined)
+
+## 1. Introduction
+
+This document details the architecture for the Vision UI frontend component of the VisionOS SaaS platform, refined based on detailed requirements analysis. It serves as the primary user interface for interacting with the system, submitting tasks, viewing results, managing artifacts, and **customizing system behavior via a no-code interface**. It builds upon the refined high-level overview and backend architecture.
+
+## 2. Role (Expanded)
+
+- **User Interaction:** Provides the graphical interface for users.
+- **Task Submission:** Allows users to define and submit tasks to the Daedalus API.
+- **Status Monitoring:** Displays the real-time status of ongoing tasks.
+- **Results Display:** Presents results received from the backend in a user-friendly format (text, code, visualizations).
+- **Artifact Management:** Interface for viewing and potentially managing generated artifacts (code, documents, images).
+- **Reasoning Display ("Think Mode"):** Visualizes agent thought processes, plans, and tool usage steps.
+- **No-Code Customization:** Provides a visual interface for users to:
+    - Adjust system-wide settings.
+    - Configure agent parameters and behavior.
+    - Select and configure tools available via the Extensibility Framework.
+    - Potentially define simple automation workflows visually (inspired by n8n, Zapier, Make.com).
+- **Local Agent Interaction:** (Future) Display status of the local agent, potentially offer limited direct controls.
+
+## 3. Technology Stack
+
+- **Framework:** Next.js (Recommended for routing, potential SSR/SSG) or React + Vite.
+- **Language:** TypeScript.
+- **Styling:** Tailwind CSS + Component Library (e.g., shadcn/ui).
+- **State Management:** Zustand (Recommended) or Redux Toolkit.
+- **Data Fetching:** React Query (Recommended) or SWR.
+- **Routing:** Next.js built-in router or React Router.
+- **Real-time Updates:** WebSocket client library.
+- **No-Code UI Components:** Potentially libraries like `react-flow` for workflow visualization/editing.
+
+## 4. Key Modules/Components (Expanded & Refined)
+
+- **Layout:** Main application shell, navigation (potentially configurable).
+- **Dashboard:** Overview, quick actions, system status.
+- **Task Submission Form:** Task definition, agent selection, file uploads, parameter inputs.
+- **Task List/Monitor:** Task status tracking.
+- **Task Detail View:** Detailed task info, inputs, logs, results.
+- **Result Viewers:** Specialized components for code (syntax highlighting), markdown, images, tables, etc.
+- **Artifact Viewer:** Dedicated section or components to browse and view managed artifacts.
+- **Reasoning Display:** Component integrated into Task Detail View or a separate panel to show agent steps/reasoning.
+- **No-Code Customization Module:**
+    - **Settings Editor:** Forms/interfaces to modify agent parameters and system settings fetched from Daedalus API.
+    - **Tool Selector:** Interface to browse available tools (from extensibility framework) and configure their usage for agents.
+    - **Workflow Builder:** (Future) Visual canvas (e.g., using `react-flow`) to define sequences of agent tasks or tool executions.
+- **Settings:** User preferences, external API key management (secure input only), Local Agent status/connection.
+- **Authentication:** (If user accounts implemented) Login/signup, profile.
+
+## 5. Communication
+
+- **Vision UI -> Daedalus API:** Asynchronous REST API calls (HTTPS) for tasks, fetching/updating configurations, fetching artifacts/results.
+- **Daedalus API -> Vision UI:** Real-time updates via WebSockets (task status, new results, potentially config change notifications).
+
+## 6. State Management
+
+- **Server State (React Query/SWR):** Tasks, configurations, artifacts, knowledge base entries.
+- **Client State (Zustand/Redux):** UI state, user preferences, WebSocket status, state for no-code builders.
+- **Real-time Updates:** WebSocket messages trigger updates/invalidations in server state cache and updates to client state.
+
+## 7. Key Considerations (Expanded)
+
+- **User Experience (UX):** CRITICAL for the no-code interface. Must be intuitive, visually clear, and provide good feedback. Consider UX patterns from `lovable.dev`, `n8n.io`, etc.
+- **Responsiveness & Accessibility:** UI must be usable across devices and adhere to accessibility standards.
+- **Performance:** Optimize rendering, bundle size, and data fetching, especially for potentially complex no-code interfaces.
+- **Security:** Secure API interactions. **Strict adherence to backend-centric API key management (UI only collects and transmits securely, never stores).**
+- **Modularity:** Design UI components to be reusable and maintainable.
+- **Integration with Uploaded Assets:** Re-evaluate uploaded `.tsx` files (e.g., `APIKeyManager.tsx`, `Chat.client.tsx`) for conceptual reuse or specific component adaptation, discarding insecure patterns (like client-side key storage).
+
+## 8. Security: API Key Management (Reiteration)
+
+**API keys for external services MUST be handled securely on the backend.** The frontend's role is limited to providing a secure input field and transmitting the key *once* via HTTPS to a dedicated Daedalus endpoint. The frontend MUST NOT store or retrieve the actual key. It should only display status (Set/Not Set) provided by the backend.
+

greenlet.h

@@ -0,0 +1,164 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+
+/* Greenlet object interface */
+
+#ifndef Py_GREENLETOBJECT_H
+#define Py_GREENLETOBJECT_H
+
+
+#include <Python.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* This is deprecated and undocumented. It does not change. */
+#define GREENLET_VERSION "1.0.0"
+
+#ifndef GREENLET_MODULE
+#define implementation_ptr_t void*
+#endif
+
+typedef struct _greenlet {
+    PyObject_HEAD
+    PyObject* weakreflist;
+    PyObject* dict;
+    implementation_ptr_t pimpl;
+} PyGreenlet;
+
+#define PyGreenlet_Check(op) (op && PyObject_TypeCheck(op, &PyGreenlet_Type))
+
+
+/* C API functions */
+
+/* Total number of symbols that are exported */
+#define PyGreenlet_API_pointers 12
+
+#define PyGreenlet_Type_NUM 0
+#define PyExc_GreenletError_NUM 1
+#define PyExc_GreenletExit_NUM 2
+
+#define PyGreenlet_New_NUM 3
+#define PyGreenlet_GetCurrent_NUM 4
+#define PyGreenlet_Throw_NUM 5
+#define PyGreenlet_Switch_NUM 6
+#define PyGreenlet_SetParent_NUM 7
+
+#define PyGreenlet_MAIN_NUM 8
+#define PyGreenlet_STARTED_NUM 9
+#define PyGreenlet_ACTIVE_NUM 10
+#define PyGreenlet_GET_PARENT_NUM 11
+
+#ifndef GREENLET_MODULE
+/* This section is used by modules that uses the greenlet C API */
+static void** _PyGreenlet_API = NULL;
+
+#    define PyGreenlet_Type \
+        (*(PyTypeObject*)_PyGreenlet_API[PyGreenlet_Type_NUM])
+
+#    define PyExc_GreenletError \
+        ((PyObject*)_PyGreenlet_API[PyExc_GreenletError_NUM])
+
+#    define PyExc_GreenletExit \
+        ((PyObject*)_PyGreenlet_API[PyExc_GreenletExit_NUM])
+
+/*
+ * PyGreenlet_New(PyObject *args)
+ *
+ * greenlet.greenlet(run, parent=None)
+ */
+#    define PyGreenlet_New                                        \
+        (*(PyGreenlet * (*)(PyObject * run, PyGreenlet * parent)) \
+             _PyGreenlet_API[PyGreenlet_New_NUM])
+
+/*
+ * PyGreenlet_GetCurrent(void)
+ *
+ * greenlet.getcurrent()
+ */
+#    define PyGreenlet_GetCurrent \
+        (*(PyGreenlet * (*)(void)) _PyGreenlet_API[PyGreenlet_GetCurrent_NUM])
+
+/*
+ * PyGreenlet_Throw(
+ *         PyGreenlet *greenlet,
+ *         PyObject *typ,
+ *         PyObject *val,
+ *         PyObject *tb)
+ *
+ * g.throw(...)
+ */
+#    define PyGreenlet_Throw                 \
+        (*(PyObject * (*)(PyGreenlet * self, \
+                          PyObject * typ,    \
+                          PyObject * val,    \
+                          PyObject * tb))    \
+             _PyGreenlet_API[PyGreenlet_Throw_NUM])
+
+/*
+ * PyGreenlet_Switch(PyGreenlet *greenlet, PyObject *args)
+ *
+ * g.switch(*args, **kwargs)
+ */
+#    define PyGreenlet_Switch                                              \
+        (*(PyObject *                                                      \
+           (*)(PyGreenlet * greenlet, PyObject * args, PyObject * kwargs)) \
+             _PyGreenlet_API[PyGreenlet_Switch_NUM])
+
+/*
+ * PyGreenlet_SetParent(PyObject *greenlet, PyObject *new_parent)
+ *
+ * g.parent = new_parent
+ */
+#    define PyGreenlet_SetParent                                 \
+        (*(int (*)(PyGreenlet * greenlet, PyGreenlet * nparent)) \
+             _PyGreenlet_API[PyGreenlet_SetParent_NUM])
+
+/*
+ * PyGreenlet_GetParent(PyObject* greenlet)
+ *
+ * return greenlet.parent;
+ *
+ * This could return NULL even if there is no exception active.
+ * If it does not return NULL, you are responsible for decrementing the
+ * reference count.
+ */
+#     define PyGreenlet_GetParent                                    \
+    (*(PyGreenlet* (*)(PyGreenlet*))                                 \
+     _PyGreenlet_API[PyGreenlet_GET_PARENT_NUM])
+
+/*
+ * deprecated, undocumented alias.
+ */
+#     define PyGreenlet_GET_PARENT PyGreenlet_GetParent
+
+#     define PyGreenlet_MAIN                                         \
+    (*(int (*)(PyGreenlet*))                                         \
+     _PyGreenlet_API[PyGreenlet_MAIN_NUM])
+
+#     define PyGreenlet_STARTED                                      \
+    (*(int (*)(PyGreenlet*))                                         \
+     _PyGreenlet_API[PyGreenlet_STARTED_NUM])
+
+#     define PyGreenlet_ACTIVE                                       \
+    (*(int (*)(PyGreenlet*))                                         \
+     _PyGreenlet_API[PyGreenlet_ACTIVE_NUM])
+
+
+
+
+/* Macro that imports greenlet and initializes C API */
+/* NOTE: This has actually moved to ``greenlet._greenlet._C_API``, but we
+   keep the older definition to be sure older code that might have a copy of
+   the header still works. */
+#    define PyGreenlet_Import()                                               \
+        {                                                                     \
+            _PyGreenlet_API = (void**)PyCapsule_Import("greenlet._C_API", 0); \
+        }
+
+#endif /* GREENLET_MODULE */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_GREENLETOBJECT_H */

mako-render

@@ -0,0 +1,8 @@
+#!/Users/lattm/Downloads/home/visionos_venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from mako.cmd import cmdline
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(cmdline())

package-lock.json

@@ -16,13 +16,13 @@
       "devDependencies": {
         "@eslint/eslintrc": "^3",
         "@tailwindcss/postcss": "^4",
-        "@types/node": "^20",
+        "@types/node": "20.17.44",
         "@types/react": "^19",
         "@types/react-dom": "^19",
         "eslint": "^9",
         "eslint-config-next": "15.3.1",
         "tailwindcss": "^4",
-        "typescript": "^5"
+        "typescript": "5.8.3"
       }
     },
     "node_modules/@alloc/quick-lru": {
@@ -1570,9 +1570,9 @@
       "license": "MIT"
     },
     "node_modules/@types/node": {
-      "version": "20.17.32",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.17.32.tgz",
-      "integrity": "sha512-zeMXFn8zQ+UkjK4ws0RiOC9EWByyW1CcVmLe+2rQocXRsGEDxUCwPEIVgpsGcLHS/P8JkT0oa3839BRABS0oPw==",
+      "version": "20.17.44",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.17.44.tgz",
+      "integrity": "sha512-50sE4Ibb4BgUMxHrcJQSAU0Fu7fLcTdwcXwRzEF7wnVMWvImFLg2Rxc7SW0vpvaJm4wvhoWEZaQiPpBpocZiUA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {

package.json

@@ -17,12 +17,12 @@
   "devDependencies": {
     "@eslint/eslintrc": "^3",
     "@tailwindcss/postcss": "^4",
-    "@types/node": "^20",
+    "@types/node": "20.17.44",
     "@types/react": "^19",
     "@types/react-dom": "^19",
     "eslint": "^9",
     "eslint-config-next": "15.3.1",
     "tailwindcss": "^4",
-    "typescript": "^5"
+    "typescript": "5.8.3"
   }
 }

pip

@@ -0,0 +1,8 @@
+#!/Users/lattm/Downloads/home/visionos_venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

pip3

@@ -0,0 +1,8 @@
+#!/Users/lattm/Downloads/home/visionos_venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

pip3.10

@@ -0,0 +1,8 @@
+#!/Users/lattm/Downloads/home/ubuntu/venv/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

pip3.11

@@ -0,0 +1,8 @@
+#!/Users/lattm/Downloads/home/ubuntu/venv/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

pip3.9

@@ -0,0 +1,8 @@
+#!/Users/lattm/Downloads/home/visionos_venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

pyproject.toml

@@ -1,66 +1,17 @@
-[tool.poetry]
-name = "suna"
-version = "1.0"
-description = "open source generalist AI Agent"
-authors = ["marko-kraemer <[email protected]>"]
+[project]
+name = "visionos-shared"
+version = "0.1.0"
+description = ""
+authors = [
+    {name = "Your Name",email = "[email protected]"}
+]
 readme = "README.md"
-license = "MIT"
-homepage = "https://www.suna.so/"
-repository = "https://github.com/kortix-ai/suna"
-classifiers = [
-    "Development Status :: 4 - Beta",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.12",
-    "Topic :: Software Development :: Libraries :: Python Modules",
+requires-python = "^3.11"
+dependencies = [
+    "pydantic (>=2.11.4,<3.0.0)"
 ]
 
-[tool.poetry.dependencies]
-python = "^3.11"
-streamlit-quill = "0.0.3"
-python-dotenv = "1.0.1"
-litellm = "^1.44.0"
-click = "8.1.7"
-questionary = "2.0.1"
-requests = "^2.31.0"
-packaging = "24.1"
-setuptools = "75.3.0"
-pytest = "8.3.3"
-pytest-asyncio = "0.24.0"
-asyncio = "3.4.3"
-altair = "4.2.2"
-prisma = "0.15.0"
-fastapi = "0.110.0"
-uvicorn = "0.27.1"
-python-multipart = "0.0.20"
-redis = "5.2.1"
-upstash-redis = "1.3.0"
-supabase = "^2.15.0"
-pyjwt = "2.10.1"
-exa-py = "^1.9.1"
-e2b-code-interpreter = "^1.2.0"
-certifi = "2024.2.2"
-python-ripgrep = "0.0.6"
-daytona_sdk = "^0.14.0"
-boto3 = "^1.34.0"
-openai = "^1.72.0"
-streamlit = "^1.44.1"
-nest-asyncio = "^1.6.0"
-vncdotool = "^1.2.0"
-tavily-python = "^0.5.4"
-pytesseract = "^0.3.13"
-
-[tool.poetry.scripts]
-agentpress = "agentpress.cli:main"
-
-[[tool.poetry.packages]]
-include = "agentpress"
-
-
-[tool.poetry.group.dev.dependencies]
-daytona-sdk = "^0.14.0"
 
 [build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

python3.11

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:32835730b5f58e962221808865710cbcec50b2edc24184bf2bbaef6f1812e5b4
+size 152624

python3.9

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:832c074c7cb29f0871c219c419e86b849edda11e83e76b191be278a399f9ded1
+size 102352

pyvenv.cfg

@@ -0,0 +1,3 @@
+home = /Users/lattm/Downloads/home/ubuntu/visionos_venv/bin
+include-system-site-packages = false
+version = 3.9.6

requirements.txt

@@ -1,14 +1,3 @@
-flask>=2.2.3
-pillow>=10.0.0
-numpy>=1.24.3
-requests>=2.31.0
-python-dotenv>=1.0.0
-anthropic>=0.18.1
-openai>=1.13.0
-redis>=5.0.1
-fastapi>=0.109.0
-uvicorn>=0.27.0
-python-multipart>=0.0.9
-pydantic>=2.5.0
-pytest>=7.4.0
-opencv-python-headless>=4.8.0
+fastapi
+uvicorn
+requests

sandbox.py

@@ -1,213 +1,126 @@
+# /home/ubuntu/visionos_farm/daedalus/extensibility/sandbox.py
+import subprocess
+import json
+import logging
 import os
-from typing import Optional
-
-from daytona_sdk import Daytona, DaytonaConfig, CreateSandboxParams, Sandbox, SessionExecuteRequest
-from daytona_api_client.models.workspace_state import WorkspaceState
-from dotenv import load_dotenv
-
-from agentpress.tool import Tool
-from utils.logger import logger
-from utils.config import config
-from utils.files_utils import clean_path
-from agentpress.thread_manager import ThreadManager
-
-load_dotenv()
-
-logger.debug("Initializing Daytona sandbox configuration")
-daytona_config = DaytonaConfig(
-    api_key=config.DAYTONA_API_KEY,
-    server_url=config.DAYTONA_SERVER_URL,
-    target=config.DAYTONA_TARGET
-)
-
-if daytona_config.api_key:
-    logger.debug("Daytona API key configured successfully")
-else:
-    logger.warning("No Daytona API key found in environment variables")
-
-if daytona_config.server_url:
-    logger.debug(f"Daytona server URL set to: {daytona_config.server_url}")
-else:
-    logger.warning("No Daytona server URL found in environment variables")
-
-if daytona_config.target:
-    logger.debug(f"Daytona target set to: {daytona_config.target}")
-else:
-    logger.warning("No Daytona target found in environment variables")
-
-daytona = Daytona(daytona_config)
-logger.debug("Daytona client initialized")
-
-async def get_or_start_sandbox(sandbox_id: str):
-    """Retrieve a sandbox by ID, check its state, and start it if needed."""
-    
-    logger.info(f"Getting or starting sandbox with ID: {sandbox_id}")
-    
+import asyncio
+from typing import Dict, Any, Tuple
+
+logger = logging.getLogger(__name__)
+
+# --- Sandboxing Configuration ---
+# WARNING: This assumes a pre-existing virtual environment dedicated to sandboxing.
+# A more robust solution would involve dynamically creating environments per tool
+# or using containerization (e.g., Docker) for stronger isolation.
+SANDBOX_PYTHON_EXEC = "/home/ubuntu/sandbox_venv/bin/python"
+SANDBOX_RUNNER_SCRIPT_PATH = "/home/ubuntu/visionos_farm/daedalus/extensibility/sandbox_runner.py"
+
+async def execute_in_sandbox(repo_path: str, module_path: str, class_name: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
+    """Executes a tool's method within a sandboxed Python environment.
+
+    Args:
+        repo_path: The absolute path to the cloned repository containing the tool.
+        module_path: The absolute path to the Python module file containing the tool class.
+        class_name: The name of the Tool class to execute.
+        parameters: The parameters dictionary to pass to the tool's execute method.
+
+    Returns:
+        A dictionary containing the result from the tool execution, including
+        status ("SUCCESS" or "FAILURE") and output/error details.
+    """
+    logger.info(f"Executing tool {class_name} from {module_path} in sandbox.")
+
+    # Ensure the sandbox runner script exists
+    if not os.path.exists(SANDBOX_RUNNER_SCRIPT_PATH):
+        logger.error(f"Sandbox runner script not found at {SANDBOX_RUNNER_SCRIPT_PATH}")
+        return {"status": "FAILURE", "error": "Sandbox runner script missing."}
+
+    # Ensure the sandboxed Python executable exists
+    if not os.path.exists(SANDBOX_PYTHON_EXEC):
+        logger.error(f"Sandboxed Python executable not found at {SANDBOX_PYTHON_EXEC}. Please create the virtual environment.")
+        # In a real scenario, might try to create it here, but for now, fail.
+        return {"status": "FAILURE", "error": f"Sandboxed Python not found at {SANDBOX_PYTHON_EXEC}."}
+
     try:
-        sandbox = daytona.get_current_sandbox(sandbox_id)
-        
-        # Check if sandbox needs to be started
-        if sandbox.instance.state == WorkspaceState.ARCHIVED or sandbox.instance.state == WorkspaceState.STOPPED:
-            logger.info(f"Sandbox is in {sandbox.instance.state} state. Starting...")
-            try:
-                daytona.start(sandbox)
-                # Wait a moment for the sandbox to initialize
-                # sleep(5)
-                # Refresh sandbox state after starting
-                sandbox = daytona.get_current_sandbox(sandbox_id)
-                
-                # Start supervisord in a session when restarting
-                start_supervisord_session(sandbox)
-            except Exception as e:
-                logger.error(f"Error starting sandbox: {e}")
-                raise e
-        
-        logger.info(f"Sandbox {sandbox_id} is ready")
-        return sandbox
-        
-    except Exception as e:
-        logger.error(f"Error retrieving or starting sandbox: {str(e)}")
-        raise e
+        parameters_json = json.dumps(parameters)
+    except TypeError as e:
+        logger.error(f"Failed to serialize parameters for tool {class_name}: {e}")
+        return {"status": "FAILURE", "error": f"Could not serialize parameters: {e}"}
+
+    cmd = [
+        SANDBOX_PYTHON_EXEC,
+        SANDBOX_RUNNER_SCRIPT_PATH,
+        repo_path, # Pass repo path for sys.path manipulation within sandbox
+        module_path,
+        class_name,
+        parameters_json
+    ]
 
-def start_supervisord_session(sandbox: Sandbox):
-    """Start supervisord in a session."""
-    session_id = "supervisord-session"
     try:
-        logger.info(f"Creating session {session_id} for supervisord")
-        sandbox.process.create_session(session_id)
-        
-        # Execute supervisord command
-        sandbox.process.execute_session_command(session_id, SessionExecuteRequest(
-            command="exec /usr/bin/supervisord -n -c /etc/supervisor/conf.d/supervisord.conf",
-            var_async=True
-        ))
-        logger.info(f"Supervisord started in session {session_id}")
-    except Exception as e:
-        logger.error(f"Error starting supervisord session: {str(e)}")
-        raise e
-
-def create_sandbox(password: str, project_id: str = None):
-    """Create a new sandbox with all required services configured and running."""
-    
-    logger.debug("Creating new Daytona sandbox environment")
-    logger.debug("Configuring sandbox with browser-use image and environment variables")
-    
-    labels = None
-    if project_id:
-        logger.debug(f"Using sandbox_id as label: {project_id}")
-        labels = {'id': project_id}
-        
-    params = CreateSandboxParams(
-        image="adamcohenhillel/kortix-suna:0.0.20",
-        public=True,
-        labels=labels,
-        env_vars={
-            "CHROME_PERSISTENT_SESSION": "true",
-            "RESOLUTION": "1024x768x24",
-            "RESOLUTION_WIDTH": "1024",
-            "RESOLUTION_HEIGHT": "768",
-            "VNC_PASSWORD": password,
-            "ANONYMIZED_TELEMETRY": "false",
-            "CHROME_PATH": "",
-            "CHROME_USER_DATA": "",
-            "CHROME_DEBUGGING_PORT": "9222",
-            "CHROME_DEBUGGING_HOST": "localhost",
-            "CHROME_CDP": ""
-        },
-        resources={
-            "cpu": 2,
-            "memory": 4,
-            "disk": 5,
-        }
-    )
-    
-    # Create the sandbox
-    sandbox = daytona.create(params)
-    logger.debug(f"Sandbox created with ID: {sandbox.id}")
-    
-    # Start supervisord in a session for new sandbox
-    start_supervisord_session(sandbox)
-    
-    logger.debug(f"Sandbox environment successfully initialized")
-    return sandbox
-
-
-class SandboxToolsBase(Tool):
-    """Base class for all sandbox tools that provides project-based sandbox access."""
-    
-    # Class variable to track if sandbox URLs have been printed
-    _urls_printed = False
-    
-    def __init__(self, project_id: str, thread_manager: Optional[ThreadManager] = None):
-        super().__init__()
-        self.project_id = project_id
-        self.thread_manager = thread_manager
-        self.workspace_path = "/workspace"
-        self._sandbox = None
-        self._sandbox_id = None
-        self._sandbox_pass = None
-
-    async def _ensure_sandbox(self) -> Sandbox:
-        """Ensure we have a valid sandbox instance, retrieving it from the project if needed."""
-        if self._sandbox is None:
+        logger.debug(f"Running sandbox command: {' '.join(cmd)}")
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+
+        stdout, stderr = await process.communicate()
+        stdout_decoded = stdout.decode().strip()
+        stderr_decoded = stderr.decode().strip()
+
+        if process.returncode != 0:
+            logger.error(f"Sandbox execution failed for {class_name}. Return code: {process.returncode}")
+            logger.error(f"Sandbox stderr: {stderr_decoded}")
+            logger.error(f"Sandbox stdout: {stdout_decoded}") # Log stdout even on error for debugging
+            error_detail = stderr_decoded or f"Sandbox process exited with code {process.returncode}"
+            # Try to parse stdout as JSON even on error, might contain partial failure info
             try:
-                # Get database client
-                client = await self.thread_manager.db.client
-                
-                # Get project data
-                project = await client.table('projects').select('*').eq('project_id', self.project_id).execute()
-                if not project.data or len(project.data) == 0:
-                    raise ValueError(f"Project {self.project_id} not found")
-                
-                project_data = project.data[0]
-                sandbox_info = project_data.get('sandbox', {})
-                
-                if not sandbox_info.get('id'):
-                    raise ValueError(f"No sandbox found for project {self.project_id}")
-                
-                # Store sandbox info
-                self._sandbox_id = sandbox_info['id']
-                self._sandbox_pass = sandbox_info.get('pass')
-                
-                # Get or start the sandbox
-                self._sandbox = await get_or_start_sandbox(self._sandbox_id)
-                
-                # # Log URLs if not already printed
-                # if not SandboxToolsBase._urls_printed:
-                #     vnc_link = self._sandbox.get_preview_link(6080)
-                #     website_link = self._sandbox.get_preview_link(8080)
-                    
-                #     vnc_url = vnc_link.url if hasattr(vnc_link, 'url') else str(vnc_link)
-                #     website_url = website_link.url if hasattr(website_link, 'url') else str(website_link)
-                    
-                #     print("\033[95m***")
-                #     print(f"VNC URL: {vnc_url}")
-                #     print(f"Website URL: {website_url}")
-                #     print("***\033[0m")
-                #     SandboxToolsBase._urls_printed = True
-                
-            except Exception as e:
-                logger.error(f"Error retrieving sandbox for project {self.project_id}: {str(e)}", exc_info=True)
-                raise e
-        
-        return self._sandbox
-
-    @property
-    def sandbox(self) -> Sandbox:
-        """Get the sandbox instance, ensuring it exists."""
-        if self._sandbox is None:
-            raise RuntimeError("Sandbox not initialized. Call _ensure_sandbox() first.")
-        return self._sandbox
-
-    @property
-    def sandbox_id(self) -> str:
-        """Get the sandbox ID, ensuring it exists."""
-        if self._sandbox_id is None:
-            raise RuntimeError("Sandbox ID not initialized. Call _ensure_sandbox() first.")
-        return self._sandbox_id
-
-    def clean_path(self, path: str) -> str:
-        """Clean and normalize a path to be relative to /workspace."""
-        cleaned_path = clean_path(path, self.workspace_path)
-        logger.debug(f"Cleaned path: {path} -> {cleaned_path}")
-        return cleaned_path
+                result_json = json.loads(stdout_decoded)
+                if isinstance(result_json, dict) and "error" in result_json:
+                     error_detail = result_json["error"]
+            except json.JSONDecodeError:
+                pass # Stick with the original error detail
+            return {"status": "FAILURE", "error": error_detail}
+
+        logger.info(f"Sandbox execution successful for {class_name}.")
+        logger.debug(f"Sandbox stdout: {stdout_decoded}")
+        if stderr_decoded:
+             logger.warning(f"Sandbox stderr (non-fatal): {stderr_decoded}")
+
+        try:
+            result = json.loads(stdout_decoded)
+            if not isinstance(result, dict):
+                 raise ValueError("Sandbox output is not a JSON dictionary")
+            # Ensure status is present, default to FAILURE if missing
+            if "status" not in result:
+                result["status"] = "FAILURE"
+                result["error"] = "Tool execution result missing 'status' field."
+            return result
+        except json.JSONDecodeError as e:
+            logger.error(f"Failed to decode JSON output from sandbox for {class_name}: {e}")
+            logger.error(f"Raw sandbox stdout: {stdout_decoded}")
+            return {"status": "FAILURE", "error": f"Could not decode sandbox output: {e}"}
+        except ValueError as e:
+            logger.error(f"Invalid JSON output structure from sandbox for {class_name}: {e}")
+            logger.error(f"Raw sandbox stdout: {stdout_decoded}")
+            return {"status": "FAILURE", "error": f"Invalid sandbox output structure: {e}"}
+
+    except Exception as e:
+        logger.error(f"Failed to run sandbox process for {class_name}: {e}", exc_info=True)
+        return {"status": "FAILURE", "error": f"Failed to start or manage sandbox process: {e}"}
+
+# Example usage (would typically be called by an Agent)
+# async def main():
+#     # Assume fetch_and_discover_tools ran and found a tool
+#     repo_p = "/path/to/cloned/repo"
+#     module_p = "/path/to/cloned/repo/tools/my_tool.py"
+#     class_n = "MyTool"
+#     params = {"input_file": "/data/input.txt", "threshold": 0.5}
+#     result = await execute_in_sandbox(repo_p, module_p, class_n, params)
+#     print("Sandbox Execution Result:", result)
+
+# if __name__ == "__main__":
+#     import asyncio
+#     # Need to create the sandbox venv first: python3.11 -m venv /home/ubuntu/sandbox_venv
+#     asyncio.run(main())
+

setup_database.py

@@ -0,0 +1,45 @@
+# setup_database.py
+# Simple script to initialize the database using SQLAlchemy directly
+
+import os
+import sys
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+# Add the project root to the Python path
+sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
+
+# Import the Base and models
+from daedalus.database.models import Base
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv(os.path.join('daedalus', '.env'))
+
+# Get database URL from environment
+DATABASE_URL = os.getenv('DATABASE_URL', 'postgresql://visionos_user:visionos_pass@localhost:5432/visionos_db')
+
+def setup_database():
+    """Create all tables in the database."""
+    print(f"Connecting to database: {DATABASE_URL}")
+    engine = create_engine(DATABASE_URL)
+    
+    print("Creating database tables...")
+    Base.metadata.create_all(bind=engine)
+    print("Database tables created successfully!")
+    
+    # Create a session to test the connection
+    Session = sessionmaker(bind=engine)
+    session = Session()
+    
+    try:
+        # Test the connection by executing a simple query
+        result = session.execute("SELECT 1")
+        print("Database connection test successful!")
+    except Exception as e:
+        print(f"Error testing database connection: {e}")
+    finally:
+        session.close()
+
+if __name__ == "__main__":
+    setup_database()

simple_api.py

@@ -0,0 +1,79 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+import uuid
+from datetime import datetime
+from pydantic import BaseModel, Field
+from typing import Dict, Any, List, Optional
+import uvicorn
+
+# Create FastAPI app
+app = FastAPI(
+    title="VisionOS SaaS Platform API",
+    description="Demo API for VisionOS SaaS Platform",
+    version="0.1.0"
+)
+
+# Enable CORS for frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000", "http://localhost:3002"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Models for API
+class TaskBase(BaseModel):
+    input_data: Optional[Dict[str, Any]] = None
+    agent_type_requested: Optional[str] = None
+
+class TaskCreate(TaskBase):
+    pass
+
+class Task(TaskBase):
+    id: str
+    status: str = "pending"
+    created_at: datetime
+    result_data: Optional[Dict[str, Any]] = None
+
+# In-memory storage for demo
+tasks = {}
+
+@app.get("/")
+def read_root():
+    return {"message": "Welcome to VisionOS SaaS Platform API", "status": "operational"}
+
+@app.get("/api/v1/tasks", response_model=List[Task])
+def list_tasks():
+    return list(tasks.values())
+
+@app.post("/api/v1/tasks", response_model=Task)
+def create_task(task: TaskCreate):
+    task_id = str(uuid.uuid4())
+    new_task = Task(
+        id=task_id,
+        input_data=task.input_data,
+        agent_type_requested=task.agent_type_requested,
+        created_at=datetime.now(),
+        status="pending"
+    )
+    tasks[task_id] = new_task
+    return new_task
+
+@app.get("/api/v1/tasks/{task_id}", response_model=Task)
+def get_task(task_id: str):
+    if task_id not in tasks:
+        raise HTTPException(status_code=404, detail="Task not found")
+    return tasks[task_id]
+
+@app.put("/api/v1/tasks/{task_id}")
+def update_task(task_id: str):
+    if task_id not in tasks:
+        raise HTTPException(status_code=404, detail="Task not found")
+    # Simulate task completion
+    tasks[task_id].status = "completed"
+    tasks[task_id].result_data = {"message": "Task completed successfully", "timestamp": str(datetime.now())}
+    return tasks[task_id]
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

tasks.py

@@ -8,9 +8,9 @@ from sqlalchemy.ext.asyncio import AsyncSession
 import redis.asyncio as redis
 
 from shared import schemas
-from crud import crud_task
-from database.session import get_db
-from core.config import settings
+from daedalus.crud import crud_task
+from daedalus.database.session import get_db
+from daedalus.core.config import settings
 
 router = APIRouter()
 

tool_sources.py

@@ -4,8 +4,8 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from typing import List
 from uuid import UUID
 
-from database import session as db_session
-from crud import crud_tool_source
+from daedalus.database import session as db_session
+from daedalus.crud import crud_tool_source
 from shared.schemas import ToolSource, ToolSourceCreate, ToolSourceRead
 
 router = APIRouter()

uvicorn

@@ -0,0 +1,8 @@
+#!/Users/lattm/Downloads/home/visionos_venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from uvicorn.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())