Core: Don't strip data in class_get_method_list

.github/workflows/build-automation.yml

@@ -0,0 +1,101 @@
+# Build Godot automation branch and create release artifacts
+
+name: Build Godot Automation
+
+on:
+  push:
+    branches: [automation]
+  pull_request:
+    branches: [automation]
+  workflow_dispatch:
+  workflow_call:
+
+concurrency:
+  group: ${{ github.workflow }}|${{ github.ref_name }}
+  cancel-in-progress: true
+
+jobs:
+  static-checks:
+    name: Static Checks
+    uses: ./.github/workflows/static_checks.yml
+
+  linux-build:
+    name: Linux
+    needs: static-checks
+    uses: ./.github/workflows/linux_builds.yml
+
+  macos-build:
+    name: macOS
+    needs: static-checks
+    uses: ./.github/workflows/macos_builds.yml
+
+  # Create a release with the built binaries (only on push to automation branch)
+  release:
+    name: Create Release
+    needs: [linux-build, macos-build]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && github.ref == 'refs/heads/automation'
+    permissions:
+      contents: write
+    steps:
+      - name: Download Linux Editor artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: linux-editor-mono
+          path: artifacts/linux
+
+      - name: Download macOS Editor artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: macos-editor
+          path: artifacts/macos
+
+      - name: Prepare release assets
+        run: |
+          cd artifacts
+          # Make binaries executable
+          chmod +x linux/godot.linuxbsd.editor.x86_64.mono || true
+          chmod +x macos/godot.macos.editor.universal || true
+          # Create zip files for release
+          cd linux && zip -r ../godot-automation-linux-x86_64.zip . && cd ..
+          cd macos && zip -r ../godot-automation-macos-universal.zip . && cd ..
+          ls -la *.zip
+
+      - name: Get short SHA
+        id: sha
+        run: echo "short=$(echo ${{ github.sha }} | cut -c1-7)" >> $GITHUB_OUTPUT
+
+      - name: Create or update release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: automation-latest
+          name: Automation Build (latest)
+          body: |
+            Pre-built Godot binaries with PlayGodot automation support.
+
+            **Commit:** ${{ github.sha }}
+            **Built:** ${{ github.event.head_commit.timestamp }}
+
+            ## Downloads
+            - `godot-automation-linux-x86_64.zip` - Linux x86_64 editor
+            - `godot-automation-macos-universal.zip` - macOS universal (Intel + Apple Silicon) editor
+
+            ## Usage
+            ```bash
+            # Linux
+            unzip godot-automation-linux-x86_64.zip
+            chmod +x godot.linuxbsd.editor.x86_64.mono
+            ./godot.linuxbsd.editor.x86_64.mono --path /path/to/project --remote-debug tcp://127.0.0.1:6007
+
+            # macOS
+            unzip godot-automation-macos-universal.zip
+            chmod +x godot.macos.editor.universal
+            ./godot.macos.editor.universal --path /path/to/project --remote-debug tcp://127.0.0.1:6007
+            ```
+
+            See [PlayGodot](https://github.com/Randroids-Dojo/PlayGodot) for the Python client.
+          files: |
+            artifacts/godot-automation-linux-x86_64.zip
+            artifacts/godot-automation-macos-universal.zip
+          prerelease: true
+          make_latest: false

.github/workflows/playgodot-integration.yml

@@ -0,0 +1,100 @@
+# Run PlayGodot integration tests against the automation build
+# This validates that the automation protocol works correctly
+
+name: PlayGodot Integration Tests
+
+on:
+  workflow_run:
+    workflows: ["🔗 GHA"]
+    types: [completed]
+    branches: [automation]
+  workflow_dispatch:
+
+jobs:
+  test-integration:
+    # Only run if the build succeeded
+    if: ${{ github.event_name == 'workflow_dispatch' || github.event.workflow_run.conclusion == 'success' }}
+    runs-on: ubuntu-22.04
+    name: PlayGodot Integration Tests
+
+    steps:
+      - name: Download Godot artifact
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: runner.yml
+          workflow_conclusion: success
+          name: linux-editor-mono
+          path: godot-bin
+          # Use run_id from the triggering workflow, or latest for manual trigger
+          run_id: ${{ github.event.workflow_run.id }}
+          if_no_artifact_found: warn
+
+      - name: Fallback - Download from latest successful run
+        if: failure() || hashFiles('godot-bin/godot.*') == ''
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          workflow: runner.yml
+          workflow_conclusion: success
+          name: linux-editor-mono
+          path: godot-bin
+          search_artifacts: true
+
+      - name: Setup Godot
+        run: |
+          ls -la godot-bin/ || echo "No godot-bin directory"
+          chmod +x godot-bin/godot.* || true
+
+          # Find the godot binary
+          GODOT_BIN=$(find godot-bin -name 'godot.*' -type f | head -1)
+          if [ -z "$GODOT_BIN" ]; then
+            echo "No Godot binary found, skipping tests"
+            exit 0
+          fi
+
+          sudo mv "$GODOT_BIN" /usr/local/bin/godot
+          godot --version
+
+      - name: Install display dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y xvfb
+
+      - name: Checkout PlayGodot
+        uses: actions/checkout@v4
+        with:
+          repository: Randroids-Dojo/PlayGodot
+          path: playgodot
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install PlayGodot
+        run: |
+          cd playgodot/python
+          pip install -e ".[dev]"
+
+      - name: Run unit tests
+        run: |
+          cd playgodot/python
+          pytest tests/ -v --tb=short
+
+      - name: Run tic-tac-toe integration tests
+        run: |
+          cd playgodot/examples/tic-tac-toe
+          # Run with xvfb for headless display
+          xvfb-run -a pytest tests/ -v --tb=short
+        env:
+          GODOT_PATH: /usr/local/bin/godot
+
+      - name: Test results summary
+        if: always()
+        run: |
+          echo "## PlayGodot Integration Test Results" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          if [ "${{ job.status }}" == "success" ]; then
+            echo "✅ All integration tests passed!" >> $GITHUB_STEP_SUMMARY
+          else
+            echo "❌ Some tests failed. Check the logs above for details." >> $GITHUB_STEP_SUMMARY
+          fi

.github/workflows/sync-upstream.yml

@@ -0,0 +1,95 @@
+# Nightly job to sync with upstream godotengine/godot
+
+name: Sync Upstream
+
+on:
+  schedule:
+    # Run at 3 AM UTC every night
+    - cron: '0 3 * * *'
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  issues: write
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout fork
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.PAT_TOKEN }}
+
+      - name: Configure Git
+        run: |
+          git config user.name "GitHub Actions Bot"
+          git config user.email "actions@github.com"
+
+      - name: Add upstream and fetch
+        run: |
+          git remote add upstream https://github.com/godotengine/godot.git
+          git fetch upstream master
+          git fetch origin automation
+
+      - name: Update master from upstream
+        run: |
+          git checkout -B master origin/master
+          git reset --hard upstream/master
+          git push origin master --force
+
+      - name: Rebase automation onto master
+        id: rebase
+        continue-on-error: true
+        run: |
+          git checkout -B automation origin/automation
+          if git rebase master; then
+            echo "rebase_success=true" >> $GITHUB_OUTPUT
+          else
+            git rebase --abort
+            echo "rebase_success=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Push automation branch
+        if: steps.rebase.outputs.rebase_success == 'true'
+        run: |
+          git push origin automation --force-with-lease
+
+      - name: Create issue if rebase failed
+        if: steps.rebase.outputs.rebase_success == 'false'
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const title = 'Upstream sync failed - manual rebase required';
+            const body = `The nightly rebase of \`automation\` onto \`master\` failed due to conflicts.
+
+            **Action required:**
+
+            \`\`\`bash
+            git fetch origin
+            git checkout automation
+            git rebase origin/master
+            # Resolve conflicts
+            git push origin automation --force-with-lease
+            \`\`\`
+
+            Workflow run: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}`;
+
+            const issues = await github.rest.issues.listForRepo({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              state: 'open',
+              labels: 'upstream-sync'
+            });
+
+            if (issues.data.length === 0) {
+              await github.rest.issues.create({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                title: title,
+                body: body,
+                labels: ['upstream-sync', 'needs-attention']
+              });
+            }

AGENTS.md

@@ -0,0 +1,54 @@
+# Agent Guidelines for Godot Automation Fork
+
+Guidelines to avoid common mistakes when working on this codebase.
+
+## C++ Include Requirements
+
+**Always explicitly include headers for any types or functions you use.** Do not rely on transitive includes - they vary by platform and can cause CI failures on some builds but not others.
+
+**Includes must be alphabetically sorted.** The project uses clang-format which enforces include ordering. Run `clang-format -style=file -i <file>` before committing to fix formatting.
+
+Common includes that must be explicit:
+
+| Function/Type | Required Include |
+|---------------|------------------|
+| `callable_mp_static` | `#include "core/object/callable_method_pointer.h"` |
+| `callable_mp` | `#include "core/object/callable_method_pointer.h"` |
+| `Object::CONNECT_ONE_SHOT` | `#include "core/object/object.h"` (use `Object::` qualifier) |
+| `Ref<T>` | `#include "core/object/ref_counted.h"` |
+| `Vector`, `List`, `HashMap` | `#include "core/templates/<container>.h"` |
+
+**`callable_mp_static` syntax differs by function type:**
+```cpp
+// File-scope static functions: NO '&'
+static void my_callback() { ... }
+obj->connect("signal", callable_mp_static(my_callback));
+
+// Class static methods: USE '&'
+obj->connect("signal", callable_mp_static(&ClassName::static_method));
+```
+
+## Automation Protocol (remote_debugger.cpp)
+
+When modifying automation commands in `core/debugger/remote_debugger.cpp`:
+
+1. **Add `is_inside_tree()` guards** - Always check if the scene tree is initialized before accessing nodes:
+   ```cpp
+   Node *root = tree->get_root();
+   ERR_FAIL_NULL(root);
+   if (!root->is_inside_tree()) {
+       // Send empty/error response
+       return;
+   }
+   ```
+
+2. **Scene changes are deferred** - `change_scene_to_file()` returns immediately but the scene isn't loaded yet. Connect to `scene_changed` signal if you need to respond after the scene is ready.
+
+3. **Flush input events** - After injecting input events, call `DisplayServer::get_singleton()->process_events()` to ensure they reach the GUI system in headless mode.
+
+## Testing Changes
+
+The CI builds for multiple platforms (Linux, macOS, Windows). A local build passing does not guarantee CI will pass due to:
+- Different include resolution
+- Platform-specific code paths
+- Compiler differences (GCC vs Clang vs MSVC)