godot-kit 1.0.0 → 1.0.1772990785

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

@@ -8,11 +8,14 @@ Agentic Godot 4.x development boilerplate. Single command setup, REPL/CLI debugg
 # Create a new Godot project
 npx godot-kit my-game
 
+# Download Godot 4.6 automatically
+godot-dev download-engine
+
 # Install gdtoolkit
 godot-dev setup
 
 # Launch Godot with remote debugger
-godot-dev launch --godot /path/to/godot4
+godot-dev launch
 
 # Connect interactive REPL
 godot-dev repl
@@ -41,15 +44,36 @@ my-game/
 ## CLI Commands
 
 ```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 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 (requires Python)
+godot-dev download-engine       # Download Godot 4.6 for current platform
+```
+
+## Godot Engine Auto-Download
+
+`godot-dev download-engine` downloads Godot 4.6-stable from the official GitHub releases:
+
+- **Windows**: downloads `Godot_v4.6-stable_win64.exe.zip`, extracts `.exe`
+- **Linux**: downloads `Godot_v4.6-stable_linux.x86_64.zip`, extracts binary, `chmod +x`
+- **macOS**: downloads `Godot_v4.6-stable_macos.universal.zip`
+
+The engine is saved to `~/.godot-kit/godot[.exe]` and the path is stored in `~/.godot-kit/config.json`. The `launch` command reads this config automatically — no `--godot` flag needed after downloading.
+
+```bash
+# Download once
+godot-dev download-engine
+
+# Launch uses ~/.godot-kit/config.json automatically
+godot-dev launch
 ```
 
+When scaffolding a new project with `npx godot-kit`, it will detect whether Godot is installed and prompt you to run `godot-dev download-engine` if not found.
+
 ## REPL Commands
 
 | Command | Description |

package/bin/cli.js

@@ -6,6 +6,7 @@ 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 { findGodot, downloadEngine, GODOT_VERSION } = require('../lib/engine');
 
 const program = new Command();
 program.name('godot-dev').description('Agentic Godot 4.x CLI - REPL, debugger, inspector, profiler').version('1.0.0');
@@ -29,11 +30,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 +73,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,12 +86,14 @@ 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);
@@ -106,25 +108,32 @@ program.command('launch [scene]').description('Launch Godot with remote debugger
   .option('--debug-collisions', 'Show collision shapes')
   .option('--debug-navigation', 'Show navigation')
   .action((scene, opts) => {
+    const godot = findGodot(opts.godot);
+    if (!godot) {
+      console.error('Godot executable 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')
   .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) {
+    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'); return; }
       catch (e) { continue; }
     }
     console.error('Failed. Install Python and pip first.'); process.exit(1);
   });
 
+program.command('download-engine').description(`Download Godot ${GODOT_VERSION} for current platform`)
+  .action(async () => { await downloadEngine(); });
+
 program.parse(process.argv);

package/bin/create.js

@@ -4,6 +4,7 @@
 const fs = require('fs');
 const path = require('path');
 const getTemplates = require('../lib/templates');
+const { findGodot, GODOT_VERSION } = require('../lib/engine');
 
 const targetDir = process.argv[2] ? path.resolve(process.argv[2]) : (process.env.INIT_CWD || process.cwd());
 const projectName = path.basename(targetDir);
@@ -29,17 +30,19 @@ 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 launch                          # 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 download-engine                 # Download Godot ${GODOT_VERSION}
 \`\`\`
 
 ## REPL Commands
@@ -56,14 +59,24 @@ godot-dev format                          # GDScript format
 fs.writeFileSync(path.join(targetDir, 'README.md'), readme, 'utf8');
 console.log(`  + README.md`);
 
+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/engine.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const GODOT_VERSION = '4.6-stable';
+const CFG_DIR = path.join(os.homedir(), '.godot-kit');
+const CFG_PATH = path.join(CFG_DIR, 'config.json');
+const PLATFORM_ASSETS = {
+  win32: `Godot_v${GODOT_VERSION}_win64.exe.zip`,
+  linux: `Godot_v${GODOT_VERSION}_linux.x86_64.zip`,
+  darwin: `Godot_v${GODOT_VERSION}_macos.universal.zip`
+};
+
+function readConfig() {
+  try { return JSON.parse(fs.readFileSync(CFG_PATH, 'utf8')); } catch { return {}; }
+}
+
+function writeConfig(cfg) {
+  fs.mkdirSync(CFG_DIR, { recursive: true });
+  fs.writeFileSync(CFG_PATH, JSON.stringify(cfg, null, 2), 'utf8');
+}
+
+function findGodot(explicitPath) {
+  if (explicitPath && explicitPath !== 'godot') return explicitPath;
+  const cfg = readConfig();
+  if (cfg.godotPath && fs.existsSync(cfg.godotPath)) return cfg.godotPath;
+  const exeName = process.platform === 'win32' ? 'godot.exe' : 'godot';
+  const p = path.join(CFG_DIR, exeName);
+  if (fs.existsSync(p)) return p;
+  try { execSync('godot --version', { stdio: 'pipe' }); return 'godot'; } catch {}
+  try { execSync('godot4 --version', { stdio: 'pipe' }); return 'godot4'; } catch {}
+  return null;
+}
+
+function followRedirect(url, cb, depth = 0) {
+  if (depth > 10) return cb(new Error('Too many redirects'), null);
+  const u = new URL(url);
+  https.get({ hostname: u.hostname, path: u.pathname + (u.search || ''), headers: { 'User-Agent': 'godot-kit/1.0' } }, (res) => {
+    if ([301, 302, 303, 307, 308].includes(res.statusCode) && res.headers.location) {
+      res.destroy();
+      const loc = res.headers.location.startsWith('http') ? res.headers.location : `https://${u.hostname}${res.headers.location}`;
+      followRedirect(loc, cb, depth + 1);
+    } else cb(null, res);
+  }).on('error', e => cb(e, null));
+}
+
+async function downloadEngine() {
+  const assetFile = PLATFORM_ASSETS[process.platform];
+  if (!assetFile) throw new Error(`Unsupported platform: ${process.platform}`);
+  const url = `https://github.com/godotengine/godot/releases/download/${GODOT_VERSION}/${assetFile}`;
+  const zipPath = path.join(CFG_DIR, assetFile);
+  fs.mkdirSync(CFG_DIR, { recursive: true });
+  console.log(`Downloading Godot ${GODOT_VERSION}...`);
+  console.log(`From: ${url}`);
+  await new Promise((resolve, reject) => {
+    followRedirect(url, (err, res) => {
+      if (err || !res) return reject(err || new Error('No response'));
+      const total = parseInt(res.headers['content-length'] || '0');
+      let received = 0;
+      const out = fs.createWriteStream(zipPath);
+      res.on('data', (chunk) => {
+        received += chunk.length;
+        out.write(chunk);
+        if (total > 0) {
+          const pct = Math.round(received / total * 100);
+          process.stdout.write(`\rProgress: ${pct}% (${Math.round(received/1024/1024)}/${Math.round(total/1024/1024)} MB)  `);
+        }
+      });
+      res.on('end', () => { out.end(); console.log('\nDownload complete.'); resolve(); });
+      res.on('error', reject);
+    });
+  });
+  console.log('Extracting...');
+  if (process.platform === 'win32') {
+    execSync(`powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${CFG_DIR}' -Force"`, { stdio: 'inherit' });
+  } else {
+    execSync(`unzip -o "${zipPath}" -d "${CFG_DIR}"`, { stdio: 'inherit' });
+  }
+  fs.unlinkSync(zipPath);
+  const files = fs.readdirSync(CFG_DIR).filter(f => {
+    const p = path.join(CFG_DIR, f);
+    return fs.statSync(p).isFile() && (f.startsWith('Godot') || f === 'godot.exe' || f === 'godot');
+  });
+  const godotPath = files.length ? path.join(CFG_DIR, files[0]) : null;
+  if (!godotPath) throw new Error('Could not find extracted Godot executable.');
+  if (process.platform !== 'win32') execSync(`chmod +x "${godotPath}"`);
+  const cfg = readConfig();
+  cfg.godotPath = godotPath;
+  writeConfig(cfg);
+  console.log(`Godot installed to: ${godotPath}`);
+  console.log(`Config: ${CFG_PATH}`);
+  return godotPath;
+}
+
+module.exports = { GODOT_VERSION, CFG_DIR, CFG_PATH, readConfig, writeConfig, findGodot, downloadEngine };

package/lib/protocol.js

@@ -73,6 +73,17 @@ function encodeVariant(value) {
     for (const p of parts) { p.copy(b, off); off += p.length; }
     return b;
   }
+  if (typeof value === 'object') {
+    const keys = Object.keys(value);
+    const pairs = keys.map(k => [encodeVariant(k), encodeVariant(value[k])]);
+    const dataLen = 4 + pairs.reduce((a, [k, v]) => a + k.length + v.length, 0);
+    const b = Buffer.alloc(4 + dataLen);
+    b.writeUInt32LE(TYPES.DICTIONARY, 0);
+    b.writeUInt32LE(keys.length, 4);
+    let off = 8;
+    for (const [k, v] of pairs) { k.copy(b, off); off += k.length; v.copy(b, off); off += v.length; }
+    return b;
+  }
   return Buffer.from([0, 0, 0, 0]);
 }
 
@@ -136,7 +147,7 @@ function decodeVariant(buf, offset) {
         items.push(r.value);
         off += r.size;
       }
-      return { value: items, size: 4 + (off - offset - 4) };
+      return { value: items, size: 4 + (off - offset) };
     }
     case TYPES.DICTIONARY: {
       const count = buf.readUInt32LE(offset) & 0x7fffffff;
@@ -147,7 +158,7 @@ function decodeVariant(buf, offset) {
         const vr = decodeVariant(buf, off); off += vr.size;
         dict[String(kr.value)] = vr.value;
       }
-      return { value: dict, size: 4 + (off - offset - 4) };
+      return { value: dict, size: 4 + (off - offset) };
     }
     default: return { value: `<type:${type}>`, size: 4 };
   }

package/lib/templates.js

@@ -34,7 +34,9 @@ script = ExtResource("1_main")
 
 func _ready() -> void:
 \tprint("[%s] Ready" % name)
-\tReplBridge.log_info("Game started: " + name)
+\tvar bridge = get_node_or_null("/root/ReplBridge")
+\tif bridge:
+\t\tbridge.log_info("Game started: " + name)
 
 func _process(_delta: float) -> void:
 \tpass

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godot-kit",
-  "version": "1.0.0",
+  "version": "1.0.1772990785",
   "description": "Agentic Godot 4.x development boilerplate - REPL/CLI debugging, gdtoolkit, DAP, scene inspector, profiler",
   "bin": {
     "godot-kit": "bin/create.js",