OpenManus v2 upgrade

.github/workflows/docker-celery-smoke-test.yml

@@ -0,0 +1,90 @@
+name: Docker Celery Smoke Test
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+jobs:
+  smoke:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build and start stack
+        run: |
+          docker compose build
+          docker compose up -d
+
+          # Wait for server to be ready with retries
+          for i in {1..30}; do
+            if curl -sf http://127.0.0.1:8000/api/health >/dev/null 2>&1; then
+              echo "Server is ready"
+              break
+            fi
+            echo "Waiting for server... attempt $i/30"
+            sleep 1
+          done
+          if ! curl -sf http://127.0.0.1:8000/api/health >/dev/null 2>&1; then
+            echo "Server did not become ready in time"
+            docker compose logs web worker postgres redis || true
+            exit 1
+          fi
+
+      - name: Verify service health
+        run: |
+          docker compose ps
+          # Ensure key services are up before API checks
+          docker compose ps postgres | grep -E "Up|running"
+          docker compose ps redis | grep -E "Up|running"
+          docker compose ps web | grep -E "Up|running"
+          docker compose ps worker | grep -E "Up|running"
+
+      - name: Check /api/health
+        run: curl --fail http://127.0.0.1:8000/api/health
+
+      - name: Check /docs
+        run: curl --fail http://127.0.0.1:8000/docs
+
+      - name: Task create, interrupt, and poll terminal state
+        run: |
+          set -e
+          curl -s -o /dev/null -c cookies.txt -X POST http://127.0.0.1:8000/api/auth/signup -H "Content-Type: application/json" -d "{\"email\":\"user$RANDOM@test.com\", \"password\":\"password\", \"name\":\"test\"}"
+          TASK_JSON=$(curl -b cookies.txt -s -X POST http://127.0.0.1:8000/api/tasks -H "Content-Type: application/json" -d '{"prompt":"ping"}')
+          echo "Created: $TASK_JSON"
+          TASK_ID=$(echo "$TASK_JSON" | python -c "import sys, json; print(json.load(sys.stdin)['task_id'])")
+          if [ -z "$TASK_ID" ]; then echo "No task id"; exit 1; fi
+
+          # Interrupt quickly so this smoke test does not depend on LLM latency.
+          curl -b cookies.txt -s -X POST "http://127.0.0.1:8000/api/tasks/$TASK_ID/interrupt" || true
+
+          for i in {1..60}; do
+            STATUS_JSON=$(curl -b cookies.txt -s http://127.0.0.1:8000/api/tasks/$TASK_ID)
+            echo "Status: $STATUS_JSON"
+            STATUS=$(echo "$STATUS_JSON" | python -c "import sys, json; print(json.load(sys.stdin).get('status'))")
+            if [ "$STATUS" = "COMPLETED" ] || [ "$STATUS" = "FAILED" ] || [ "$STATUS" = "INTERRUPTED" ]; then
+              if [ "$STATUS" = "INTERRUPTED" ]; then
+                echo "Task interrupted as expected"
+              fi
+              exit 0
+            fi
+            sleep 2
+          done
+          echo "Task did not complete in time"
+          exit 1
+
+      - name: Dump logs on failure
+        if: failure()
+        run: |
+          docker compose ps
+          docker compose logs web worker postgres redis
+
+      - name: Tear down
+        if: always()
+        run: docker compose down -v

.github/workflows/docker-smoke-test.yml

@@ -0,0 +1,141 @@
+name: Docker Smoke Test
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+jobs:
+  smoke:
+    runs-on: ubuntu-latest
+
+    services:
+      postgres:
+        image: postgres:15
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_DB: openmanus
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd "pg_isready -U postgres"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+      redis:
+        image: redis:latest
+        ports:
+          - 6379:6379
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 5s
+          --health-timeout 5s
+          --health-retries 5
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Build image
+        run: docker build -t openmanus:latest .
+
+      - name: Run container
+        run: |
+          docker run -d --network host --name openmanus \
+            -e DATABASE_URL=postgresql+psycopg2://postgres:postgres@localhost:5432/openmanus \
+            -e CELERY_BROKER_URL=redis://localhost:6379/0 \
+            -e CELERY_RESULT_BACKEND=redis://localhost:6379/0 \
+            openmanus:latest
+          # start websocket server inside container on port 8001
+          docker exec openmanus sh -c "uvicorn server.ws:app --host 0.0.0.0 --port 8001 --workers 1 >/tmp/ws.log 2>&1 & echo \$! >/tmp/ws.pid"
+
+          # Wait for server to be ready with retries
+          for i in {1..30}; do
+            if curl -sf http://127.0.0.1:8000/api/health >/dev/null 2>&1; then
+              echo "Server is ready"
+              break
+            fi
+            echo "Waiting for server... attempt $i/30"
+            sleep 1
+          done
+          if ! curl -sf http://127.0.0.1:8000/api/health >/dev/null 2>&1; then
+            echo "Server did not become ready in time"
+            docker logs openmanus || true
+            exit 1
+          fi
+
+          # Wait for websocket server readiness
+          for i in {1..20}; do
+            if curl -sf http://127.0.0.1:8001/health >/dev/null 2>&1; then
+              echo "WebSocket server is ready"
+              break
+            fi
+            echo "Waiting for websocket server... attempt $i/20"
+            sleep 1
+          done
+
+      - name: Check /api/health
+        run: curl --fail http://127.0.0.1:8000/api/health
+
+      - name: Check /docs
+        run: curl --fail http://127.0.0.1:8000/docs
+
+      - name: Install tooling for task test
+        run: |
+          sudo apt-get update && sudo apt-get install -y jq
+          python -m pip install --upgrade pip
+          pip install websockets
+
+      - name: Simulate task lifecycle with interrupt and event stream
+        run: |
+          set -e
+          curl -s -o /dev/null -c cookies.txt -X POST http://127.0.0.1:8000/api/auth/signup -H "Content-Type: application/json" -d "{\"email\":\"user$RANDOM@test.com\", \"password\":\"password\", \"name\":\"test\"}"
+          TASK_JSON=$(curl -b cookies.txt -s -X POST http://127.0.0.1:8000/api/tasks)
+          echo "Task created: $TASK_JSON"
+          TASK_ID=$(echo "$TASK_JSON" | jq -r '.task_id')
+          if [ -z "$TASK_ID" ] || [ "$TASK_ID" = "null" ]; then
+            echo "Failed to parse task id"; exit 1; fi
+          export TASK_ID
+
+          python - <<'PY'
+          import asyncio, json, websockets, os, sys
+          task_id = os.environ["TASK_ID"]
+          uri = f"ws://127.0.0.1:8001/tasks/{task_id}/stream"
+          events = []
+          async def main():
+              try:
+                  async with websockets.connect(uri) as ws:
+                      # send interrupt quickly to avoid long-running agent
+                      await ws.send(json.dumps({"command": "interrupt"}))
+                      try:
+                          for _ in range(10):
+                              msg = await asyncio.wait_for(ws.recv(), timeout=10)
+                              events.append(msg)
+                              if len(events) >= 2:
+                                  break
+                      except asyncio.TimeoutError:
+                          pass
+              except Exception as e:
+                  print("WebSocket error:", e, file=sys.stderr)
+                  sys.exit(1)
+          asyncio.run(main())
+          if not events:
+              print("No events received"); sys.exit(1)
+          print("Received events:", events)
+          PY
+
+      - name: Dump container logs on failure
+        if: failure()
+        run: |
+          docker logs openmanus || true
+          docker exec openmanus cat /tmp/ws.log || true
+          docker exec openmanus cat /tmp/server.log || true
+
+      - name: Stop container
+        if: always()
+        run: |
+          docker stop openmanus || true
+          docker rm openmanus || true

.github/workflows/web-smoke-test.yml

@@ -0,0 +1,107 @@
+name: Web Smoke Test
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  smoke:
+    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:15
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_DB: openmanus
+        options: >-
+          --health-cmd "pg_isready -U postgres"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 5432:5432
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+
+      - name: Wait for PostgreSQL
+        run: |
+          python - <<'PY'
+          import time
+          import psycopg2
+
+          for i in range(30):
+              try:
+                  conn = psycopg2.connect(
+                      host="localhost",
+                      port=5432,
+                      user="postgres",
+                      password="postgres",
+                      dbname="openmanus",
+                  )
+                  conn.close()
+                  print("PostgreSQL is ready")
+                  raise SystemExit(0)
+              except Exception as exc:
+                  print(f"Waiting for PostgreSQL... {i+1}/30 ({exc})")
+                  time.sleep(1)
+          print("PostgreSQL not ready in time")
+          raise SystemExit(1)
+          PY
+
+      - name: Start FastAPI server
+        env:
+          DATABASE_URL: postgresql+psycopg2://postgres:postgres@localhost:5432/openmanus
+        run: |
+          uvicorn server.api:app --host 0.0.0.0 --port 8000 --workers 1 > /tmp/server.log 2>&1 &
+          echo $! > server.pid
+
+          # Wait for server to be ready with retries
+          for i in {1..30}; do
+            if curl -sf http://127.0.0.1:8000/api/health >/dev/null 2>&1; then
+              echo "Server is ready"
+              break
+            fi
+            echo "Waiting for server... attempt $i/30"
+            sleep 1
+          done
+
+      - name: Check /api/health
+        run: |
+          for i in {1..10}; do
+            if curl -sf http://127.0.0.1:8000/api/health > /tmp/health.json; then
+              cat /tmp/health.json
+              exit 0
+            fi
+            sleep 2
+          done
+          echo "Health endpoint not responding"
+          cat /tmp/server.log || true
+          exit 1
+
+      - name: Check /docs
+        run: |
+          curl -sf http://127.0.0.1:8000/docs > /tmp/docs.html
+          grep -i "swagger" /tmp/docs.html
+
+      - name: Stop server
+        if: always()
+        run: |
+          if [ -f server.pid ]; then kill $(cat server.pid) || true; fi
+
+      - name: Dump server logs on failure
+        if: failure()
+        run: |
+          cat /tmp/server.log || true

.gitignore

@@ -134,7 +134,7 @@ __pypackages__/
 # Celery stuff
 celerybeat-schedule
 celerybeat.pid
-
+OpenManus.code-workspace
 # SageMath parsed files
 *.sage.py
 

.openhands/skills/code-review.md

@@ -0,0 +1,18 @@
+---
+name: code-review
+type: knowledge
+version: 1.0
+agent: Manus
+triggers:
+  - review
+  - bug
+  - regression
+  - security
+  - test
+---
+Code review workflow:
+1. Prioritize correctness, regressions, missing tests, and security issues.
+2. Ground findings in exact files, functions, or observable behavior.
+3. Verify suspicious behavior by reading the caller and callee, not just one file.
+4. Keep style-only notes secondary unless they block maintainability.
+5. When implementing fixes, run focused tests and inspect the resulting diff.

.openhands/skills/docker.md

@@ -0,0 +1,18 @@
+---
+name: docker
+type: knowledge
+version: 1.0
+agent: Manus
+triggers:
+  - docker
+  - container
+  - compose
+  - port
+  - server
+---
+Docker workflow:
+1. Inspect `docker compose ps`, container logs, and exposed ports before guessing.
+2. Keep long-running dev servers in the background and write logs to a file in the conversation workspace.
+3. After starting a server, verify it is listening with `ss -tlnp` or `curl`.
+4. Report the reachable URL and leave enough runtime evidence for the UI process panel.
+5. Do not stop OpenManus system containers unless explicitly asked.