godot-daedalus_backend 1.0.0

package/README.md

@@ -0,0 +1,101 @@
+# Godot Daedalus Backend
+
+Godot Daedalus Backend is the TypeScript runtime service for the Godot Daedalus editor plugin. It provides the WebSocket/RPC backend, DeepSeek chat integration, approval-gated Godot project tools, session persistence, MCP host support, and Godot MCP servers.
+
+This npm package is a source-runtime package. It publishes the TypeScript source and small JavaScript bin launchers, then runs the source through `tsx` at runtime. It does not publish compiled `dist/` output.
+
+## Requirements
+
+- Node.js 20.19 or newer.
+- npm.
+- Godot 4.x for Godot validation and editor workflows.
+- Optional Python 3 for the DeepSeek tokenizer helper.
+
+The Python tokenizer bridge is included as `scripts/deepseek-tokenizer-server.py`. The tokenizer model files are intentionally not included in the npm package because they can be large. If you want exact tokenizer counting, install the Python dependency and point the backend at your tokenizer directory:
+
+```powershell
+pip install tokenizers
+$env:PYTHON_CMD = "python"
+$env:DEEPSEEK_TOKENIZER_DIR = "D:\path\to\tokenizer"
+```
+
+If Python or tokenizer files are unavailable, the backend can still run; token counting may fall back to the non-Python path used by the runtime.
+
+## Install
+
+Global install:
+
+```powershell
+npm install -g godot-daedalus_backend
+```
+
+Local project install:
+
+```powershell
+npm install godot-daedalus_backend
+```
+
+## Run The WebSocket Backend
+
+```powershell
+$env:PORT = "8080"
+godot-daedalus-backend
+```
+
+The Godot plugin connects to this backend over WebSocket. Provider configuration, including the DeepSeek API key, is normally saved from the plugin settings UI.
+
+## Run The Godot MCP Server
+
+The standalone Godot MCP server requires a Godot project path:
+
+```powershell
+$env:GODOT_PROJECT_PATH = "D:\GodotProjects\example"
+godot-daedalus-mcp
+```
+
+## Run The Terminal MCP Server
+
+The terminal MCP server exposes guarded verification commands, including Godot headless checks. Configure the project and Godot executable first:
+
+```powershell
+$env:GODOT_PROJECT_PATH = "D:\GodotProjects\example"
+$env:GODOT_EXECUTABLE_PATH = "D:\Godot_v4.7-stable_win64.exe\Godot_v4.7-stable_win64.exe"
+godot-daedalus-terminal-mcp
+```
+
+## Development
+
+```powershell
+npm install
+npm run typecheck
+npm test
+npm run pack:check
+```
+
+Useful scripts:
+
+- `npm start`: run the WebSocket backend from source.
+- `npm run mcp`: run the Godot MCP server from source.
+- `npm run terminal:mcp`: run the terminal MCP server from source.
+- `npm run ping`: run the local ping client.
+- `npm run pack:check`: inspect the npm package contents without publishing.
+
+## Published Files
+
+The npm package uses the `files` whitelist in `package.json`. Runtime users receive:
+
+- `bin/`
+- `src/`
+- `scripts/deepseek-tokenizer-server.py`
+- `README.md`
+- `package.json`
+
+Tests, local agent instructions, generated tarballs, environment files, `node_modules/`, and tokenizer model files are not published.
+
+Before publishing:
+
+```powershell
+npm test
+npm publish --dry-run
+npm publish
+```

package/bin/godot-daedalus-backend.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runTsxEntry } from "./run-tsx-entry.js";
+
+runTsxEntry("src/main.ts");

package/bin/godot-daedalus-mcp.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runTsxEntry } from "./run-tsx-entry.js";
+
+runTsxEntry("src/mcp/godot-mcp-server.ts");

package/bin/godot-daedalus-terminal-mcp.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runTsxEntry } from "./run-tsx-entry.js";
+
+runTsxEntry("src/mcp/terminal-mcp-server.ts");

package/bin/run-tsx-entry.js

@@ -0,0 +1,26 @@
+import { spawn } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export function runTsxEntry(entryRelativePath) {
+	const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+	const entryPath = resolve(packageRoot, entryRelativePath);
+	const child = spawn(process.execPath, ["--import", "tsx", entryPath, ...process.argv.slice(2)], {
+		cwd: packageRoot,
+		env: process.env,
+		stdio: "inherit"
+	});
+
+	child.on("error", (error) => {
+		console.error(error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	});
+
+	child.on("exit", (code, signal) => {
+		if (signal !== null) {
+			console.error(`Process exited from signal ${signal}`);
+			process.exit(1);
+		}
+		process.exit(code ?? 1);
+	});
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "godot-daedalus_backend",
+  "version": "1.0.0",
+  "description": "TypeScript backend for the Godot Daedalus editor assistant plugin.",
+  "main": "./src/main.ts",
+  "bin": {
+    "godot-daedalus-backend": "bin/godot-daedalus-backend.js",
+    "godot-daedalus-mcp": "bin/godot-daedalus-mcp.js",
+    "godot-daedalus-terminal-mcp": "bin/godot-daedalus-terminal-mcp.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "scripts/deepseek-tokenizer-server.py",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "tsx src/main.ts",
+    "dev": "tsx src/main.ts",
+    "ping": "tsx src/ping-client.ts",
+    "mcp": "tsx src/mcp/godot-mcp-server.ts",
+    "terminal:mcp": "tsx src/mcp/terminal-mcp-server.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "npm run typecheck && node --import tsx --test \"tests/*.test.ts\"",
+    "pack:check": "npm pack --dry-run",
+    "prepublishOnly": "npm test"
+  },
+  "engines": {
+    "node": ">=20.19"
+  },
+  "keywords": [
+    "godot",
+    "editor-plugin",
+    "mcp",
+    "websocket",
+    "deepseek"
+  ],
+  "author": "LuYingYiLong",
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "keytar": "^7.9.0",
+    "openai": "^6.45.0",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3",
+    "ws": "^8.21.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.1",
+    "@types/ws": "^8.18.1"
+  }
+}

package/scripts/deepseek-tokenizer-server.py

@@ -0,0 +1,54 @@
+"""DeepSeek tokenizer JSON-line server.
+
+Usage: python scripts/deepseek-tokenizer-server.py <tokenizer_dir>
+
+Reads JSON objects from stdin, one per line: {"id": 1, "text": "..."}
+Writes JSON responses to stdout: {"id": 1, "tokens": 42}
+Sends {"ready": true} on startup.
+"""
+
+import sys
+import json
+from pathlib import Path
+from tokenizers import Tokenizer
+
+if hasattr(sys.stdin, "reconfigure"):
+    sys.stdin.reconfigure(encoding="utf-8")
+    sys.stdout.reconfigure(encoding="utf-8")
+    sys.stderr.reconfigure(encoding="utf-8")
+
+def main():
+    if len(sys.argv) < 2:
+        print(json.dumps({"error": "Usage: deepseek-tokenizer-server.py <tokenizer_dir>"}), flush=True)
+        sys.exit(1)
+
+    tokenizer_dir = Path(sys.argv[1])
+    tokenizer_path = tokenizer_dir / "tokenizer.json"
+    tokenizer = Tokenizer.from_file(str(tokenizer_path))
+    print(json.dumps({"ready": True}), flush=True)
+
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+
+        try:
+            request = json.loads(line)
+        except json.JSONDecodeError as e:
+            print(json.dumps({"error": f"Invalid JSON: {e}"}), flush=True)
+            continue
+
+        request_id = request.get("id")
+        text = request.get("text", "")
+        if not isinstance(text, str):
+            print(json.dumps({"id": request_id, "error": "text must be a string"}), flush=True)
+            continue
+
+        try:
+            encoded = tokenizer.encode(text)
+            print(json.dumps({"id": request_id, "tokens": len(encoded.ids)}), flush=True)
+        except Exception as e:
+            print(json.dumps({"id": request_id, "error": str(e)}), flush=True)
+
+if __name__ == "__main__":
+    main()

package/src/app-paths.ts

@@ -0,0 +1,36 @@
+import { join } from "node:path";
+
+const APP_DIR_NAME: string = ".godot_daedalus";
+
+export function getAppDataDir(): string {
+	const windowsAppData: string | undefined = process.env.APPDATA;
+	if (!windowsAppData || windowsAppData.trim().length === 0) {
+		throw new Error("APPDATA is not configured");
+	}
+
+	return join(windowsAppData, APP_DIR_NAME);
+}
+
+export function getDefaultWorkspaceConfigPath(): string {
+	return join(getAppDataDir(), "config", "workspaces.json");
+}
+
+export function getProviderConfigPath(): string {
+	return join(getAppDataDir(), "config", "provider.json");
+}
+
+export function getMcpServersConfigPath(): string {
+	return join(getAppDataDir(), "config", "mcp-servers.json");
+}
+
+export function getDefaultSessionsDir(): string {
+	return join(getAppDataDir(), "data", "sessions");
+}
+
+export function getDefaultArchivedSessionsDir(): string {
+	return join(getAppDataDir(), "data", "archived_sessions");
+}
+
+export function getToolExecutionLedgerPath(): string {
+	return join(getAppDataDir(), "data", "tool-executions.jsonl");
+}

package/src/main.ts

@@ -0,0 +1,21 @@
+import { createServer } from "./server/websocket-server.js";
+import { McpHost } from "./mcp/mcp-host.js";
+
+const DEFAULT_PORT: number = 8080;
+const portText: string = process.env.PORT ?? String(DEFAULT_PORT);
+const port: number = Number.parseInt(portText, 10);
+
+if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+	throw new Error(`Invalid PORT: ${portText}`);
+}
+
+const mcpHost: McpHost = new McpHost();
+
+try {
+	await mcpHost.connectAll();
+} catch (error: unknown) {
+	console.warn("MCP host failed to connect:", error instanceof Error ? error.message : error);
+	console.warn("Server will start without MCP support");
+}
+
+createServer(port, mcpHost);

package/src/mcp/content-length-protocol.ts

@@ -0,0 +1,68 @@
+import { Buffer } from "node:buffer";
+
+const HEADER_SEPARATOR: string = "\r\n\r\n";
+
+export function encodeContentLengthMessage(payload: unknown): Buffer {
+	const body: string = JSON.stringify(payload);
+	const bodyBuffer: Buffer = Buffer.from(body, "utf8");
+	const header: string = `Content-Length: ${bodyBuffer.byteLength}\r\n\r\n`;
+	return Buffer.concat([Buffer.from(header, "ascii"), bodyBuffer]);
+}
+
+export class ContentLengthMessageParser {
+	private buffer: Buffer = Buffer.alloc(0);
+
+	push(chunk: Buffer): unknown[] {
+		this.buffer = Buffer.concat([this.buffer, chunk]);
+		const messages: unknown[] = [];
+
+		while (true) {
+			const headerEnd: number = this.buffer.indexOf(HEADER_SEPARATOR);
+			if (headerEnd < 0) {
+				break;
+			}
+
+			const headerText: string = this.buffer.subarray(0, headerEnd).toString("ascii");
+			const contentLength: number | null = parseContentLength(headerText);
+			if (contentLength === null) {
+				throw new Error("Missing Content-Length header");
+			}
+
+			const bodyStart: number = headerEnd + Buffer.byteLength(HEADER_SEPARATOR, "ascii");
+			const bodyEnd: number = bodyStart + contentLength;
+			if (this.buffer.byteLength < bodyEnd) {
+				break;
+			}
+
+			const bodyText: string = this.buffer.subarray(bodyStart, bodyEnd).toString("utf8");
+			messages.push(JSON.parse(bodyText) as unknown);
+			this.buffer = this.buffer.subarray(bodyEnd);
+		}
+
+		return messages;
+	}
+}
+
+function parseContentLength(headerText: string): number | null {
+	const lines: string[] = headerText.split("\r\n");
+	for (const line of lines) {
+		const separatorIndex: number = line.indexOf(":");
+		if (separatorIndex < 0) {
+			continue;
+		}
+
+		const name: string = line.slice(0, separatorIndex).trim().toLowerCase();
+		if (name !== "content-length") {
+			continue;
+		}
+
+		const value: string = line.slice(separatorIndex + 1).trim();
+		if (!/^\d+$/.test(value)) {
+			throw new Error(`Invalid Content-Length header: ${value}`);
+		}
+
+		return Number.parseInt(value, 10);
+	}
+
+	return null;
+}