godot-kit 1.0.0 → 1.0.1772991619

package/.github/workflows/publish.yml

@@ -10,6 +10,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
 
       - uses: actions/setup-node@v4
         with:
@@ -18,6 +20,25 @@ jobs:
 
       - run: npm ci --ignore-scripts
 
+      - name: Bump version to 1.0.<timestamp>
+        run: |
+          TS=$(date +%s)
+          node -e "
+            const fs = require('fs');
+            const p = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+            p.version = '1.0.' + process.argv[1];
+            fs.writeFileSync('package.json', JSON.stringify(p, null, 2) + '\n');
+            console.log('Version bumped to', p.version);
+          " $TS
+
+      - name: Commit version bump
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add package.json
+          git commit -m "chore: bump version [skip ci]" || echo "nothing to commit"
+          git push || echo "push skipped"
+
       - run: npm publish --access public
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -1,134 +1,143 @@
 # godot-kit
 
-Agentic Godot 4.x development boilerplate. Single command setup, REPL/CLI debugging, gdtoolkit integration, DAP support, scene inspector, profiler, and live log streaming.
+Agentic Godot 4.x development boilerplate. Provides CLI tools, a remote REPL/debugger bridge, an EditorPlugin HTTP API, a game runtime HTTP API, GDScript linting/formatting, and auto-installs skill files for AI coding agents (Claude Code, Cursor, Windsurf, Aider, Continue).
 
-## Quick Start
+## Install
 
 ```bash
-# Create a new Godot project
-npx godot-kit my-game
-
-# Install gdtoolkit
-godot-dev setup
-
-# Launch Godot with remote debugger
-godot-dev launch --godot /path/to/godot4
-
-# Connect interactive REPL
-godot-dev repl
-```
-
-## What it creates
-
-```
-my-game/
-├── project.godot           # Godot 4.x project config
-├── scenes/main.tscn        # Main scene
-├── scripts/main.gd         # Main script
-├── addons/repl_bridge/     # REPL autoload (GDScript)
-│   ├── repl_bridge.gd      # Debug bridge with eval, scene dump, logs
-│   └── plugin.cfg
-├── .gdlintrc               # gdtoolkit lint config
-├── .gdformatrc             # gdtoolkit format config
-├── .vscode/
-│   ├── launch.json         # DAP debug config
-│   ├── settings.json       # Godot LSP settings
-│   └── extensions.json     # Recommends Godot Tools
-├── Makefile                # Task shortcuts
-└── README.md
+npm install -g godot-kit
+npx godot-kit <my-project>    # scaffold new project
+godot-dev download-engine     # download Godot 4.x
+godot-dev setup               # install gdtoolkit + agent skills
 ```
 
 ## CLI Commands
 
+### Launch & Debug (Debugger port 6007)
 ```bash
-godot-dev repl              # Interactive debugger REPL
-godot-dev inspect           # Dump scene tree (one-shot)
-godot-dev logs              # Stream Godot output logs
-godot-dev lint [files]      # Run gdlint
-godot-dev format [files]    # Run gdformat
-godot-dev launch [scene]    # Launch Godot with debugger
-godot-dev setup             # Install gdtoolkit
+godot-dev launch [scene]      # launch game with remote debugger
+godot-dev repl                # interactive REPL via debugger
+godot-dev inspect             # dump scene tree (one-shot)
+godot-dev logs                # stream Godot output
 ```
 
-## REPL Commands
+### Code Quality
+```bash
+godot-dev lint [files...]     # GDScript lint via gdtoolkit
+godot-dev format [files...]   # GDScript format
+godot-dev validate            # validate all .gd file syntax
+```
 
-| Command | Description |
-|---------|-------------|
-| `tree` | Dump scene tree |
-| `inspect <id>` | Inspect object properties |
-| `stack` | Show call stack |
-| `vars <frame>` | Show variables at stack frame |
-| `c` / `continue` | Continue execution |
-| `n` / `next` | Step over |
-| `s` / `step` | Step into |
-| `b` / `break` | Pause execution |
-| `bp <file> <line>` | Set/clear breakpoint |
-| `quit` | Exit |
+### Test / Export / Watch
+```bash
+godot-dev test <script.gd>    # run GDScript headlessly, report pass/fail
+godot-dev export <preset>     # export project by preset name
+godot-dev watch               # watch .gd files, hot-reload running game
+```
 
-## Debug Architecture
+### Editor HTTP API (port 6008)
+Requires `godot_kit_bridge` EditorPlugin (scaffolded automatically). Open the Godot editor first.
 
-```
-Godot 4 Game
-  └─ --remote-debug tcp://127.0.0.1:6007
-       └─ Binary Variant Protocol (TCP)
-            └─ godot-dev repl / inspect / logs
-                 └─ lib/debugger-client.js
-                      └─ lib/protocol.js (encode/decode Godot variants)
+```bash
+godot-dev editor tree                            # scene tree JSON
+godot-dev editor select <node-path>              # select node in editor
+godot-dev editor run-script <file.gd>            # run GDScript in editor
+godot-dev editor open <res://scene.tscn>         # open scene
+godot-dev editor save                            # save current scene
+godot-dev editor files                           # list project files
+godot-dev editor property <node> <prop> <val>    # set node property
+godot-dev editor create <type> <parent> <name>   # create node
+godot-dev editor delete <node-path>              # delete node
+godot-dev editor signals                         # list signals
+godot-dev editor autoloads                       # list autoloads
 ```
 
-### Protocol Details
+### Game Runtime HTTP API (port 6009)
+Injected via `ReplBridge` autoload. Start the game with `godot-dev launch`.
 
-Godot 4.x remote debugger uses a binary TCP protocol:
-- Each packet: `uint32_LE(payload_size) + uint32_LE(param_count) + [variants...]`
-- First variant is always the command string
-- Remaining variants are parameters
-- Types: NIL, BOOL, INT (32/64), FLOAT (32/64), STRING, VECTOR2/3/4, COLOR, ARRAY, DICTIONARY, OBJECT, etc.
+```bash
+godot-dev game tree                              # runtime scene tree
+godot-dev game eval "<GDScript expression>"      # evaluate expression
+godot-dev game globals                           # list autoloads + root children
+godot-dev game fps                               # FPS + performance metrics
+godot-dev game set <node-path> <prop> <val>      # set node property at runtime
+godot-dev game call <node-path> <method> [args]  # call method on node
+godot-dev game node <node-path>                  # get node info
+godot-dev game pause                             # toggle pause
+godot-dev game reload                            # reload current scene
+godot-dev game input                             # show pause/input state
+```
 
-### Ports
+## Agent Skill Installation
 
-| Service | Port | Protocol |
-|---------|------|----------|
-| Remote Debugger (game) | 6007 | Binary TCP |
-| Language Server (LSP) | 6005 | JSON-RPC TCP |
-| Debug Adapter (DAP) | 6006 | DAP over TCP |
+`godot-dev setup` and `npx godot-kit` automatically install skill/rule files for detected AI coding agents:
 
-## gdtoolkit
+| Agent | File |
+|-------|------|
+| Claude Code | `~/.claude/skills/godot-dev.md` |
+| Cursor | `.cursor/rules/godot-dev.mdc` |
+| Windsurf | `.windsurf/rules/godot-dev.md` |
+| Aider | `.aider.conf.yml` |
+| Continue | `.continue/config.json` |
 
-```bash
-# Install (requires Python 3.7+)
-pip install "gdtoolkit==4.*"
+## Scaffolded Project Structure
 
-# Or via pipx
-pipx install "gdtoolkit==4.*"
+```
+my-project/
+  project.godot                        # Godot project config
+  scenes/main.tscn                     # main scene
+  scripts/main.gd                      # main script
+  addons/
+    repl_bridge/
+      repl_bridge.gd                   # autoload: game runtime HTTP (6009) + debugger bridge
+      plugin.cfg
+    godot_kit_bridge/
+      plugin.gd                        # EditorPlugin: starts HTTP server (6008)
+      editor_http.gd                   # REST API routes for editor control
+      plugin.cfg
+  .vscode/                             # VSCode + Godot Tools config
+  .cursor/rules/godot-dev.mdc          # Cursor AI rules
+  .windsurf/rules/godot-dev.md         # Windsurf AI rules
 ```
 
-Provides `gdlint` and `gdformat` for GDScript linting and formatting.
-
-## VSCode Integration
+## Ports
 
-1. Install [Godot Tools](https://marketplace.visualstudio.com/items?itemName=geequlim.godot-tools)
-2. Set Godot 4 executable path in VSCode settings
-3. Press `F5` to launch with DAP debugger
+| Service | Port |
+|---------|------|
+| Remote Debugger | 6007 |
+| Editor HTTP API | 6008 |
+| Game Runtime HTTP | 6009 |
+| LSP | 6005 |
+| DAP | 6006 |
 
-## Programmatic API
+## Common Workflows
 
-```js
-const { GodotDebuggerClient } = require('godot-kit');
+### Inspect running game
+```bash
+godot-dev launch &
+sleep 2
+godot-dev game tree
+godot-dev game eval "Engine.get_frames_per_second()"
+```
 
-const client = new GodotDebuggerClient('127.0.0.1', 6007);
-await client.connect();
+### Set property at runtime
+```bash
+godot-dev game set /root/Main speed 200
+```
 
-client.on('break', (params) => console.log('Paused at', params));
-client.on('output', (params) => console.log('[godot]', params));
+### Run a test
+```bash
+godot-dev test tests/test_math.gd
+```
 
-client.requestSceneTree();
-client.on('message', (msg) => {
-  if (msg.command === 'scene:scene_tree_parse_end') {
-    // msg.params contains scene tree data
-  }
-});
+### Hot reload on file change
+```bash
+godot-dev launch &
+godot-dev watch
 ```
 
-## License
+## Requirements
 
-MIT
+- Node.js 18+
+- Python + pip (for gdtoolkit)
+- Godot 4.x (`godot-dev download-engine`)

package/bin/cli.js

@@ -5,10 +5,13 @@ const { Command } = require('commander');
 const { GodotDebuggerClient } = require('../lib/debugger-client');
 const { parseSceneNode, formatSceneTree } = require('../lib/scene-tree');
 const { startRepl } = require('../lib/repl-commands');
-const { execSync, spawn } = require('child_process');
+const { execSync, spawn, spawnSync } = require('child_process');
+const { findGodot, downloadEngine, GODOT_VERSION } = require('../lib/engine');
+const { registerEditorCommands } = require('../lib/cli-editor');
+const { registerGameCommands } = require('../lib/cli-game');
 
 const program = new Command();
-program.name('godot-dev').description('Agentic Godot 4.x CLI - REPL, debugger, inspector, profiler').version('1.0.0');
+program.name('godot-dev').description('Agentic Godot 4.x CLI - REPL, debugger, inspector, editor bridge, game runtime').version('1.0.0');
 
 function makeClient(opts) {
   return new GodotDebuggerClient(opts.host || '127.0.0.1', parseInt(opts.port || '6007'));
@@ -20,8 +23,7 @@ async function connectOrDie(client) {
     console.log(`Connected to Godot debugger at ${client.host}:${client.port}`);
   } catch (e) {
     console.error(`Cannot connect to Godot at ${client.host}:${client.port}`);
-    console.error('Launch Godot with: --remote-debug tcp://127.0.0.1:6007');
-    console.error('Or run: godot-dev launch');
+    console.error('Launch Godot with: godot-dev launch');
     process.exit(1);
   }
 }
@@ -29,11 +31,7 @@ async function connectOrDie(client) {
 program.command('repl').description('Interactive REPL connected to running Godot debugger')
   .option('-h, --host <host>', 'Godot host', '127.0.0.1')
   .option('-p, --port <port>', 'Debugger port', '6007')
-  .action(async (opts) => {
-    const client = makeClient(opts);
-    await connectOrDie(client);
-    startRepl(client);
-  });
+  .action(async (opts) => { const c = makeClient(opts); await connectOrDie(c); startRepl(c); });
 
 program.command('inspect').description('Dump scene tree from running Godot game (one-shot)')
   .option('-h, --host <host>', 'Godot host', '127.0.0.1')
@@ -76,6 +74,9 @@ program.command('lint [files...]').description('Lint GDScript files using gdtool
       if (r) console.log(r);
       console.log('\x1b[32mLint passed.\x1b[0m');
     } catch (e) {
+      if (e.code === 'ENOENT' || (e.stderr && (e.stderr.includes('not found') || e.stderr.includes('not recognized')))) {
+        console.log('gdlint not found. Run: godot-dev setup'); return;
+      }
       if (e.stdout) process.stdout.write(e.stdout);
       if (e.stderr) process.stderr.write(e.stderr);
       process.exit(e.status || 1);
@@ -86,11 +87,26 @@ program.command('format [files...]').description('Format GDScript files using gd
   .option('--check', 'Check only, do not write')
   .action((files, opts) => {
     const targets = files.length ? files : ['.'];
-    const args = ['gdformat', ...(opts.check ? ['--check'] : []), ...targets];
     try {
-      const r = execSync(args.join(' '), { stdio: 'pipe', encoding: 'utf8' });
+      const r = execSync(['gdformat', ...(opts.check ? ['--check'] : []), ...targets].join(' '), { stdio: 'pipe', encoding: 'utf8' });
       if (r) console.log(r);
       console.log('\x1b[32mFormat complete.\x1b[0m');
+    } catch (e) {
+      if (e.code === 'ENOENT' || (e.stderr && (e.stderr.includes('not found') || e.stderr.includes('not recognized')))) {
+        console.log('gdformat not found. Run: godot-dev setup'); return;
+      }
+      if (e.stdout) process.stdout.write(e.stdout);
+      if (e.stderr) process.stderr.write(e.stderr);
+      process.exit(e.status || 1);
+    }
+  });
+
+program.command('validate').description('Validate GDScript syntax on all .gd files using gdparse')
+  .action(() => {
+    try {
+      const r = execSync('gdparse .', { stdio: 'pipe', encoding: 'utf8' });
+      if (r) console.log(r);
+      console.log('\x1b[32mValidation passed.\x1b[0m');
     } catch (e) {
       if (e.stdout) process.stdout.write(e.stdout);
       if (e.stderr) process.stderr.write(e.stderr);
@@ -103,28 +119,80 @@ program.command('launch [scene]').description('Launch Godot with remote debugger
   .option('--project <path>', 'Godot project path', '.')
   .option('-p, --port <port>', 'Debugger port', '6007')
   .option('--profiling', 'Enable profiling')
-  .option('--debug-collisions', 'Show collision shapes')
-  .option('--debug-navigation', 'Show navigation')
   .action((scene, opts) => {
+    const godot = findGodot(opts.godot);
+    if (!godot) { console.error('Godot not found. Run: godot-dev download-engine'); process.exit(1); }
     const args = ['--path', opts.project, '--remote-debug', `tcp://127.0.0.1:${opts.port}`, '--verbose'];
     if (opts.profiling) args.push('--profiling');
-    if (opts.debugCollisions) args.push('--debug-collisions');
-    if (opts.debugNavigation) args.push('--debug-navigation');
     if (scene) args.push(scene);
-    console.log(`Launching: ${opts.godot} ${args.join(' ')}`);
-    const proc = spawn(opts.godot, args, { stdio: 'inherit' });
+    console.log(`Launching: ${godot} ${args.join(' ')}`);
+    const proc = spawn(godot, args, { stdio: 'inherit' });
     proc.on('exit', (code) => process.exit(code || 0));
   });
 
-program.command('setup').description('Install gdtoolkit for GDScript linting/formatting')
+program.command('test <script>').description('Run a GDScript file headlessly and report pass/fail')
+  .option('--godot <path>', 'Path to Godot executable')
+  .option('--project <path>', 'Godot project path', '.')
+  .option('--timeout <ms>', 'Timeout in milliseconds', '30000')
+  .action((script, opts) => {
+    const godot = findGodot(opts.godot);
+    if (!godot) { console.error('Godot not found. Run: godot-dev download-engine'); process.exit(1); }
+    const args = ['--path', opts.project, '--headless', '--script', script, '--quit'];
+    console.log(`Running test: ${script}`);
+    const r = spawnSync(godot, args, { encoding: 'utf8', timeout: parseInt(opts.timeout) });
+    if (r.stdout) process.stdout.write(r.stdout);
+    if (r.stderr) process.stderr.write(r.stderr);
+    const passed = r.status === 0 && !(r.stdout || '').includes('FAILED');
+    console.log(passed ? '\x1b[32mTest PASSED\x1b[0m' : '\x1b[31mTest FAILED\x1b[0m');
+    process.exit(r.status || 0);
+  });
+
+program.command('export <preset>').description('Export project using a named export preset')
+  .option('--godot <path>', 'Path to Godot executable')
+  .option('--project <path>', 'Godot project path', '.')
+  .option('--output <path>', 'Output path', './build/export')
+  .action((preset, opts) => {
+    const godot = findGodot(opts.godot);
+    if (!godot) { console.error('Godot not found. Run: godot-dev download-engine'); process.exit(1); }
+    const args = ['--path', opts.project, '--headless', '--export-release', preset, opts.output];
+    console.log(`Exporting preset: ${preset}`);
+    const proc = spawn(godot, args, { stdio: 'inherit' });
+    proc.on('exit', (code) => process.exit(code || 0));
+  });
+
+program.command('watch').description('Watch .gd files and hot-reload running game on change')
+  .action(() => {
+    const chokidar = require('chokidar');
+    const { gamePost } = require('../lib/http-client');
+    console.log('Watching .gd files for changes... (Ctrl+C to stop)');
+    const watcher = chokidar.watch('**/*.gd', { ignored: /node_modules/, ignoreInitial: true });
+    watcher.on('change', async (file) => {
+      console.log(`Changed: ${file} - sending reload...`);
+      try { await gamePost('/reload-scene', {}); console.log('Reloaded.'); }
+      catch (e) { console.warn(`Reload failed: ${e.message}`); }
+    });
+    process.on('SIGINT', () => { watcher.close(); process.exit(0); });
+  });
+
+program.command('setup').description('Install gdtoolkit for GDScript linting/formatting and register agent skills')
   .action(() => {
     console.log('Installing gdtoolkit for Godot 4.x...');
-    const cmds = ['pip install --upgrade "gdtoolkit==4.*"', 'pip3 install --upgrade "gdtoolkit==4.*"'];
-    for (const cmd of cmds) {
-      try { execSync(cmd, { stdio: 'inherit' }); console.log('\x1b[32mgdtoolkit installed.\x1b[0m'); return; }
+    for (const cmd of ['pip install --upgrade "gdtoolkit==4.*"', 'pip3 install --upgrade "gdtoolkit==4.*"']) {
+      try { execSync(cmd, { stdio: 'inherit' }); console.log('\x1b[32mgdtoolkit installed.\x1b[0m'); break; }
       catch (e) { continue; }
     }
-    console.error('Failed. Install Python and pip first.'); process.exit(1);
+    try {
+      const { installSkills } = require('../lib/skills');
+      installSkills(process.cwd());
+    } catch (e) {
+      console.warn('Skills install warning:', e.message);
+    }
   });
 
+program.command('download-engine').description(`Download Godot ${GODOT_VERSION} for current platform`)
+  .action(async () => { await downloadEngine(); });
+
+registerEditorCommands(program);
+registerGameCommands(program);
+
 program.parse(process.argv);

package/bin/create.js

@@ -4,6 +4,8 @@
 const fs = require('fs');
 const path = require('path');
 const getTemplates = require('../lib/templates');
+const { findGodot, GODOT_VERSION } = require('../lib/engine');
+const { installSkills } = require('../lib/skills');
 
 const targetDir = process.argv[2] ? path.resolve(process.argv[2]) : (process.env.INIT_CWD || process.cwd());
 const projectName = path.basename(targetDir);
@@ -29,26 +31,55 @@ Scaffolded by [godot-kit](https://github.com/AnEntrypoint/godot-kit).
 ## Setup
 \`\`\`bash
 npm install -g godot-kit
+godot-dev download-engine
 godot-dev setup
 \`\`\`
 
 ## Commands
 \`\`\`bash
-godot-dev launch --godot /path/to/godot4  # Launch with debugger
-godot-dev repl                            # Interactive REPL
-godot-dev inspect                         # Dump scene tree
-godot-dev logs                            # Stream logs
-godot-dev lint                            # GDScript lint
-godot-dev format                          # GDScript format
+godot-dev launch                            # Launch with debugger
+godot-dev repl                              # Interactive REPL
+godot-dev inspect                           # Dump scene tree (debugger)
+godot-dev logs                              # Stream logs
+godot-dev lint                              # GDScript lint
+godot-dev format                            # GDScript format
+godot-dev watch                             # Watch .gd files, hot-reload
+godot-dev test <script.gd>                  # Run GDScript test headlessly
+godot-dev validate                          # Validate all .gd syntax
+godot-dev export <preset>                   # Export project
+godot-dev download-engine                   # Download Godot ${GODOT_VERSION}
 \`\`\`
 
-## REPL Commands
-\`continue|c\`, \`next|n\`, \`step|s\`, \`break|b\`, \`stack\`, \`vars <frame>\`, \`tree\`, \`inspect <id>\`, \`bp <file> <line>\`
+## Editor HTTP API (port 6008, requires godot_kit_bridge plugin)
+\`\`\`bash
+godot-dev editor tree                       # Scene tree JSON
+godot-dev editor open <res://scene.tscn>    # Open scene
+godot-dev editor save                       # Save current scene
+godot-dev editor files                      # List project files
+godot-dev editor property <node> <p> <v>   # Set node property
+godot-dev editor create <type> <parent> <n> # Create node
+godot-dev editor signals                    # List signals
+godot-dev editor autoloads                  # List autoloads
+\`\`\`
+
+## Game Runtime HTTP API (port 6009)
+\`\`\`bash
+godot-dev game tree                         # Runtime scene tree
+godot-dev game eval "<GDScript expr>"       # Evaluate expression
+godot-dev game globals                      # List autoloads
+godot-dev game fps                          # FPS + perf metrics
+godot-dev game set <path> <prop> <val>      # Set node property
+godot-dev game call <path> <method> [args]  # Call node method
+godot-dev game pause                        # Toggle pause
+godot-dev game reload                       # Reload scene
+\`\`\`
 
 ## Debug Ports
 | Service | Port |
 |---------|------|
 | Remote Debugger | 6007 |
+| Editor HTTP API | 6008 |
+| Game HTTP API | 6009 |
 | LSP | 6005 |
 | DAP | 6006 |
 `;
@@ -56,14 +87,26 @@ godot-dev format                          # GDScript format
 fs.writeFileSync(path.join(targetDir, 'README.md'), readme, 'utf8');
 console.log(`  + README.md`);
 
+try { installSkills(targetDir); } catch (e) { console.warn('  Skills install warning:', e.message); }
+
+const godotPath = findGodot(null);
+if (!godotPath) {
+  console.log(`
+  Godot not found. Download it with:
+
+    godot-dev download-engine
+`);
+} else {
+  console.log(`\n  Godot found at: ${godotPath}`);
+}
+
 console.log(`
   Done! Next steps:
 
-  1. Open project in Godot 4.x editor
+  1. Download engine:       godot-dev download-engine
   2. Install gdtoolkit:     godot-dev setup
-  3. Launch with debugger:  godot-dev launch --godot /path/to/godot4
+  3. Launch with debugger:  godot-dev launch
   4. Connect REPL:          godot-dev repl
-  5. Inspect scene tree:    godot-dev inspect
 
   VSCode: Install "Godot Tools" extension, use F5 to debug.
   Docs:   https://github.com/AnEntrypoint/godot-kit

package/lib/cli-editor.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const { editorGet, editorPost } = require('./http-client');
+const { readFileSync, existsSync } = require('fs');
+
+function printJSON(obj) {
+  console.log(JSON.stringify(obj, null, 2));
+}
+
+function fail(msg) {
+  console.error(msg);
+  process.exit(1);
+}
+
+async function run(fn) {
+  try { await fn(); }
+  catch (e) { fail(e.message); }
+}
+
+function registerEditorCommands(program) {
+  const ed = program.command('editor').description('Editor HTTP API commands (requires godot_kit_bridge on port 6008)');
+
+  ed.command('tree').description('Dump editor scene tree as JSON')
+    .action(() => run(async () => printJSON(await editorGet('/scene-tree'))));
+
+  ed.command('select <node-path>').description('Select a node in the editor by path')
+    .action((np) => run(async () => printJSON(await editorPost('/set-property', { node: np, property: '_name', value: np }))));
+
+  ed.command('run-script <file>').description('Run a GDScript file in editor context')
+    .action((file) => run(async () => {
+      if (!existsSync(file)) fail(`File not found: ${file}`);
+      const script = readFileSync(file, 'utf8');
+      printJSON(await editorPost('/run-script', { script }));
+    }));
+
+  ed.command('open <scene-path>').description('Open a scene in the editor (res:// path)')
+    .action((p) => run(async () => printJSON(await editorPost('/open-scene', { path: p }))));
+
+  ed.command('save').description('Save the current scene')
+    .action(() => run(async () => printJSON(await editorPost('/save-scene', {}))));
+
+  ed.command('files').description('List all project files')
+    .action(() => run(async () => {
+      const r = await editorGet('/project-files');
+      (r.files || []).forEach(f => console.log(f));
+    }));
+
+  ed.command('property <node> <prop> <val>').description('Set a node property in the editor')
+    .action((node, prop, val) => run(async () => {
+      let parsed = val;
+      try { parsed = JSON.parse(val); } catch {}
+      printJSON(await editorPost('/set-property', { node, property: prop, value: parsed }));
+    }));
+
+  ed.command('create <type> <parent> <name>').description('Create a new node in the editor')
+    .action((type, parent, name) => run(async () => printJSON(await editorPost('/create-node', { type, parent, name }))));
+
+  ed.command('delete <node-path>').description('Delete a node from the scene')
+    .action((np) => run(async () => printJSON(await editorPost('/node/' + np, { _method: 'DELETE' }))));
+
+  ed.command('signals').description('List all signals in the current scene')
+    .action(() => run(async () => printJSON(await editorGet('/signals'))));
+
+  ed.command('screenshot').description('Get screenshot path (open editor window to capture)')
+    .action(() => run(async () => printJSON(await editorGet('/selected-node'))));
+
+  ed.command('autoloads').description('List all project autoloads')
+    .action(() => run(async () => printJSON(await editorGet('/autoloads'))));
+}
+
+module.exports = { registerEditorCommands };