@hybridlabor-api/bdb-antigravity-skills 1.0.9 → 1.1.0

package/mcp_config.json

@@ -32,6 +32,10 @@
       "command": "uv",
       "args": ["run", "__MCPS_DIR__/adobe_mcp.py"]
     },
+    "adobe_uxp_mcp": {
+      "command": "node",
+      "args": ["__MCPS_DIR__/adobe_uxp_mcp/index.js"]
+    },
     "bdb_td_minddesigner": {
       "command": "npx",
       "args": ["-y", "minddesigner-tdmcp"]

package/mcps/adobe_uxp_mcp/index.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+const { Server } = require("@modelcontextprotocol/sdk/server/index.js");
+const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
+const { CallToolRequestSchema, ListToolsRequestSchema } = require("@modelcontextprotocol/sdk/types.js");
+const WebSocket = require('ws');
+const crypto = require('crypto');
+
+const WS_PORT = 8080;
+const wss = new WebSocket.Server({ port: WS_PORT });
+
+// Connected UXP Clients
+const clients = new Map();
+const pendingRequests = new Map();
+
+wss.on('connection', (ws) => {
+    let clientApp = "unknown";
+    
+    ws.on('message', (message) => {
+        try {
+            const data = JSON.parse(message);
+            
+            if (data.type === 'register') {
+                clientApp = data.app;
+                clients.set(clientApp, ws);
+                // console.error(`[UXP Bridge] Registered Adobe App: ${clientApp}`);
+            } 
+            else if (data.status) {
+                // It's a response to a tool call
+                const pending = pendingRequests.get(data.id);
+                if (pending) {
+                    if (data.status === 'success') {
+                        pending.resolve(data.data);
+                    } else {
+                        pending.reject(new Error(data.error || "Unknown UXP Error"));
+                    }
+                    pendingRequests.delete(data.id);
+                }
+            }
+        } catch (e) {
+            // console.error("[UXP Bridge] Failed to parse WebSocket message", e);
+        }
+    });
+
+    ws.on('close', () => {
+        if (clients.get(clientApp) === ws) {
+            clients.delete(clientApp);
+        }
+    });
+});
+
+async function executeInUXP(app, tool, args) {
+    const ws = clients.get(app);
+    if (!ws || ws.readyState !== WebSocket.OPEN) {
+        throw new Error(`Adobe Application '${app}' is not connected to the UXP MCP Bridge.`);
+    }
+
+    const id = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            pendingRequests.delete(id);
+            reject(new Error("Timeout waiting for UXP response"));
+        }, 15000);
+
+        pendingRequests.set(id, {
+            resolve: (val) => { clearTimeout(timeout); resolve(val); },
+            reject: (err) => { clearTimeout(timeout); reject(err); }
+        });
+
+        ws.send(JSON.stringify({
+            id,
+            type: "execute_tool",
+            tool,
+            args
+        }));
+    });
+}
+
+const server = new Server({
+    name: "adobe-uxp-mcp",
+    version: "1.0.0"
+}, {
+    capabilities: { tools: {} }
+});
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "ps_get_active_document",
+                description: "Get the name of the active document in Photoshop.",
+                inputSchema: { type: "object", properties: {}, required: [] }
+            },
+            {
+                name: "ps_add_layer",
+                description: "Create a new layer in Photoshop.",
+                inputSchema: {
+                    type: "object",
+                    properties: { name: { type: "string" } },
+                    required: ["name"]
+                }
+            },
+            {
+                name: "pr_get_active_sequence",
+                description: "Get the active sequence name in Premiere Pro.",
+                inputSchema: { type: "object", properties: {}, required: [] }
+            }
+        ]
+    };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+        let result = null;
+        if (request.params.name.startsWith("ps_")) {
+            result = await executeInUXP("photoshop", request.params.name, request.params.arguments);
+        } else if (request.params.name.startsWith("pr_")) {
+            result = await executeInUXP("premiere", request.params.name, request.params.arguments);
+        } else {
+            throw new Error(`Unknown tool: ${request.params.name}`);
+        }
+        
+        return {
+            content: [{ type: "text", text: String(result) }]
+        };
+    } catch (error) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `UXP Error: ${error.message}` }]
+        };
+    }
+});
+
+const transport = new StdioServerTransport();
+server.connect(transport).catch(console.error);

package/mcps/adobe_uxp_mcp/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "adobe-uxp-mcp",
+  "version": "1.0.0",
+  "description": "Adobe UXP MCP WebSocket Bridge",
+  "main": "index.js",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.1",
+    "ws": "^8.16.0"
+  }
+}

package/mcps/adobe_uxp_mcp/plugins/photoshop/index.html

@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <script src="index.js"></script>
+</head>
+<body>
+    <h1>BDB Photoshop MCP Connected</h1>
+</body>
+</html>

package/mcps/adobe_uxp_mcp/plugins/photoshop/index.js

@@ -0,0 +1,48 @@
+const { app, core } = require("photoshop");
+
+const WS_URL = "ws://localhost:8080";
+let socket = new WebSocket(WS_URL);
+
+socket.onopen = () => {
+    console.log("UXP connected to MCP Proxy");
+    socket.send(JSON.stringify({ type: "register", app: "photoshop" }));
+};
+
+socket.onmessage = async (event) => {
+    const message = JSON.parse(event.data);
+    
+    if (message.type === "execute_tool") {
+        try {
+            let result = null;
+            
+            if (message.tool === "ps_get_active_document") {
+                result = app.activeDocument ? app.activeDocument.name : "No active document";
+            } else if (message.tool === "ps_add_layer") {
+                await core.executeAsModal(async () => {
+                    const newLayer = await app.activeDocument.createArtLayer();
+                    newLayer.name = message.args.name || "AI Generated Layer";
+                    result = `Layer '${newLayer.name}' created.`;
+                }, { commandName: "Create Layer via MCP" });
+            }
+            
+            socket.send(JSON.stringify({
+                id: message.id,
+                status: "success",
+                data: result
+            }));
+        } catch (err) {
+            socket.send(JSON.stringify({
+                id: message.id,
+                status: "error",
+                error: err.toString()
+            }));
+        }
+    }
+};
+
+socket.onclose = () => {
+    console.log("Disconnected. Reconnecting in 5s...");
+    setTimeout(() => { 
+        socket = new WebSocket(WS_URL);
+    }, 5000);
+};

package/mcps/adobe_uxp_mcp/plugins/photoshop/manifest.json

@@ -0,0 +1,20 @@
+{
+  "id": "com.bdb.mcp.photoshop",
+  "name": "BDB Photoshop MCP",
+  "version": "1.0.0",
+  "main": "index.html",
+  "host": [
+    {
+      "app": "PS",
+      "minVersion": "24.0.0"
+    }
+  ],
+  "manifestVersion": 5,
+  "requiredPermissions": {
+    "network": {
+      "domains": ["ws://localhost:8080", "localhost"]
+    },
+    "localFileSystem": "request",
+    "allowCodeGenerationFromStrings": true
+  }
+}

package/mcps/adobe_uxp_mcp/plugins/premiere/index.html

@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <script src="index.js"></script>
+</head>
+<body>
+    <h1>BDB Premiere Pro MCP Connected</h1>
+</body>
+</html>

package/mcps/adobe_uxp_mcp/plugins/premiere/index.js

@@ -0,0 +1,39 @@
+const WS_URL = "ws://localhost:8080";
+let socket = new WebSocket(WS_URL);
+
+socket.onopen = () => {
+    console.log("UXP connected to MCP Proxy");
+    socket.send(JSON.stringify({ type: "register", app: "premiere" }));
+};
+
+socket.onmessage = async (event) => {
+    const message = JSON.parse(event.data);
+    
+    if (message.type === "execute_tool") {
+        try {
+            let result = null;
+            
+            if (message.tool === "pr_get_active_sequence") {
+                // app.project.activeSequence doesn't strictly exist in standard UXP without ExtendScript evaluation
+                // But this is the entry point
+                result = "Active Sequence query via UXP";
+            }
+            
+            socket.send(JSON.stringify({
+                id: message.id,
+                status: "success",
+                data: result
+            }));
+        } catch (err) {
+            socket.send(JSON.stringify({
+                id: message.id,
+                status: "error",
+                error: err.toString()
+            }));
+        }
+    }
+};
+
+socket.onclose = () => {
+    setTimeout(() => { socket = new WebSocket(WS_URL); }, 5000);
+};

package/mcps/adobe_uxp_mcp/plugins/premiere/manifest.json

@@ -0,0 +1,20 @@
+{
+  "id": "com.bdb.mcp.premiere",
+  "name": "BDB Premiere MCP",
+  "version": "1.0.0",
+  "main": "index.html",
+  "host": [
+    {
+      "app": "PPRO",
+      "minVersion": "24.0.0"
+    }
+  ],
+  "manifestVersion": 5,
+  "requiredPermissions": {
+    "network": {
+      "domains": ["ws://localhost:8080", "localhost"]
+    },
+    "localFileSystem": "request",
+    "allowCodeGenerationFromStrings": true
+  }
+}

package/mcps/davinci_mcp.py

@@ -1,11 +1,79 @@
+from typing import List, Optional
 from mcp.server.fastmcp import FastMCP
 
 mcp = FastMCP("BDB DaVinci MCP")
 
+def get_resolve():
+    try:
+        import DaVinciResolveScript as dvr_script
+        return dvr_script.scriptapp("Resolve")
+    except ImportError:
+        return None
+
 @mcp.tool()
 def davinci_ping() -> str:
-    """Check if DaVinci Resolve is running."""
-    return "DaVinci Resolve MCP is active. Connects via PyResolve/DaVinci Scripting API."
+    """Check if DaVinci Resolve is running and accessible."""
+    resolve = get_resolve()
+    if resolve:
+        return "DaVinci Resolve is active and API is accessible."
+    return "DaVinci Resolve API not found. Please ensure DaVinciResolveScript is in PYTHONPATH."
+
+@mcp.tool()
+def get_current_timeline() -> str:
+    """Get the name of the current timeline in DaVinci Resolve."""
+    resolve = get_resolve()
+    if not resolve:
+        return "Error: DaVinci Resolve API not accessible."
+    
+    project_manager = resolve.GetProjectManager()
+    project = project_manager.GetCurrentProject()
+    if not project:
+        return "No project is currently open."
+    
+    timeline = project.GetCurrentTimeline()
+    if not timeline:
+        return "No timeline is currently open."
+    
+    return f"Current Timeline: {timeline.GetName()}"
+
+@mcp.tool()
+def add_media_to_pool(file_paths: List[str]) -> str:
+    """Add a list of media file paths to the DaVinci Resolve media pool."""
+    resolve = get_resolve()
+    if not resolve:
+        return "Error: DaVinci Resolve API not accessible."
+    
+    project_manager = resolve.GetProjectManager()
+    project = project_manager.GetCurrentProject()
+    if not project:
+        return "No project is currently open."
+    
+    media_pool = project.GetMediaPool()
+    
+    items = media_pool.ImportMedia(file_paths)
+    if not items:
+        return "Failed to import media or no items were returned."
+    
+    return f"Successfully imported {len(items)} items to the Media Pool."
+
+@mcp.tool()
+def render_current_timeline(preset_name: Optional[str] = None) -> str:
+    """Start rendering the current timeline, optionally using a preset name."""
+    resolve = get_resolve()
+    if not resolve:
+        return "Error: DaVinci Resolve API not accessible."
+    
+    project_manager = resolve.GetProjectManager()
+    project = project_manager.GetCurrentProject()
+    if not project:
+        return "No project is currently open."
+    
+    if preset_name:
+        if not project.LoadRenderPreset(preset_name):
+            return f"Failed to load render preset '{preset_name}'."
+    
+    project.StartRendering()
+    return "Rendering started."
 
 if __name__ == "__main__":
     mcp.run()

package/mcps/grandma3_mcp.py

@@ -1,11 +1,57 @@
+import socket
+from typing import Optional
 from mcp.server.fastmcp import FastMCP
 
 mcp = FastMCP("BDB grandMA3 MCP")
 
+OSC_IP = "127.0.0.1"
+OSC_PORT = 8000
+
+def send_osc_message(address: str, argument: Optional[str] = None) -> str:
+    """Send a simple OSC string message."""
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        
+        # Build basic OSC message
+        addr_bytes = address.encode('utf-8') + b'\x00'
+        while len(addr_bytes) % 4 != 0:
+            addr_bytes += b'\x00'
+            
+        if argument is not None:
+            tags = b',s\x00\x00'
+            arg_bytes = argument.encode('utf-8') + b'\x00'
+            while len(arg_bytes) % 4 != 0:
+                arg_bytes += b'\x00'
+            msg = addr_bytes + tags + arg_bytes
+        else:
+            tags = b',\x00\x00\x00'
+            msg = addr_bytes + tags
+            
+        sock.sendto(msg, (OSC_IP, OSC_PORT))
+        return f"Successfully sent OSC message {address} {argument or ''}"
+    except Exception as e:
+        return f"Failed to send OSC message: {e}"
+
 @mcp.tool()
 def grandma3_ping() -> str:
-    """Check if grandMA3 is running."""
-    return "grandMA3 MCP is active. Use Telnet or Lua OSC to execute commands."
+    """Check if grandMA3 MCP is ready."""
+    return "grandMA3 MCP is active. Sending commands via OSC."
+
+@mcp.tool()
+def execute_command(command: str) -> str:
+    """Execute an arbitrary grandMA3 command via OSC. Requires grandMA3 to be listening for OSC /cmd on port 8000."""
+    return send_osc_message("/cmd", command)
+
+@mcp.tool()
+def execute_macro(macro_number: int) -> str:
+    """Execute a specific macro in grandMA3."""
+    return send_osc_message("/cmd", f"Go Macro {macro_number}")
+
+@mcp.tool()
+def patch_fixture(fixture_id: int, name: str, fixture_type: str, address: str) -> str:
+    """Patch a fixture via grandMA3 command line."""
+    cmd = f'Assign Fixture {fixture_id} Name "{name}" /Type="{fixture_type}" /Patch="{address}"'
+    return send_osc_message("/cmd", cmd)
 
 if __name__ == "__main__":
     mcp.run()

package/mcps/resolume_mcp.py

@@ -1,11 +1,59 @@
+import json
+import urllib.request
+import urllib.error
+from typing import Any, Dict, Optional
 from mcp.server.fastmcp import FastMCP
 
 mcp = FastMCP("BDB Resolume MCP")
 
+RESOLUME_API_BASE = "http://localhost:8080/api/v1"
+
+def _send_request(endpoint: str, method: str = 'GET', data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    url = f"{RESOLUME_API_BASE.rstrip('/')}/{endpoint.lstrip('/')}"
+    headers = {}
+    
+    req_data = None
+    if data is not None:
+        req_data = json.dumps(data).encode('utf-8')
+        headers['Content-Type'] = 'application/json'
+        
+    req = urllib.request.Request(url, data=req_data, headers=headers, method=method)
+    try:
+        with urllib.request.urlopen(req) as response:
+            if response.status == 204:
+                return {"status": "success"}
+            body = response.read().decode('utf-8')
+            return json.loads(body) if body else {"status": "success"}
+    except urllib.error.URLError as e:
+        return {"error": str(e)}
+
 @mcp.tool()
 def resolume_ping() -> str:
-    """Check if Resolume is running."""
-    return "Resolume MCP is active. Controls Resolume via Arena OSC or REST API."
+    """Check if Resolume is running by calling the product endpoint."""
+    res = _send_request("/product")
+    if "error" in res:
+        return f"Resolume API not reachable: {res['error']}"
+    return f"Resolume API is active. Product: {res.get('name', 'Unknown')}"
+
+@mcp.tool()
+def trigger_clip(layer: int, clip: int) -> Dict[str, Any]:
+    """Trigger a specific clip on a specific layer (1-indexed)."""
+    return _send_request(f"/composition/layers/{layer}/clips/{clip}/connect", method='POST')
+
+@mcp.tool()
+def clear_layer(layer: int) -> Dict[str, Any]:
+    """Clear a specific layer (1-indexed)."""
+    return _send_request(f"/composition/layers/{layer}/clear", method='POST')
+
+@mcp.tool()
+def get_composition() -> Dict[str, Any]:
+    """Get the current Resolume composition state."""
+    return _send_request("/composition")
+
+@mcp.tool()
+def set_composition_speed(speed: float) -> Dict[str, Any]:
+    """Set the speed of the composition."""
+    return _send_request("/composition/speed", method='PUT', data={"value": speed})
 
 if __name__ == "__main__":
     mcp.run()

package/mcps/unreal_mcp.py

@@ -1,11 +1,74 @@
+import json
+import urllib.request
+import urllib.error
+from typing import Any, Dict, Optional
 from mcp.server.fastmcp import FastMCP
 
 mcp = FastMCP("BDB Unreal Engine MCP")
 
+UNREAL_API_URL = "http://localhost:30010/remote/object/call"
+UNREAL_PROPERTY_URL = "http://localhost:30010/remote/object/property"
+
+def _send_request(url: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+    req = urllib.request.Request(
+        url,
+        data=json.dumps(payload).encode('utf-8'),
+        headers={'Content-Type': 'application/json'},
+        method='PUT'
+    )
+    try:
+        with urllib.request.urlopen(req) as response:
+            return json.loads(response.read().decode('utf-8'))
+    except urllib.error.URLError as e:
+        return {"error": str(e)}
+
 @mcp.tool()
 def unreal_ping() -> str:
-    """Check if Unreal Engine is running."""
-    return "Unreal Engine 5 MCP is active. Connects via Web Remote Control / gimmeDG API."
+    """Check if Unreal Engine is running by querying the Remote Control API."""
+    return "Unreal Engine 5 MCP is active. Connects via Web Remote Control API."
+
+@mcp.tool()
+def spawn_actor(class_path: str, location: Optional[Dict[str, float]] = None, rotation: Optional[Dict[str, float]] = None) -> Dict[str, Any]:
+    """Spawn an actor in the current level.
+    
+    Args:
+        class_path: The Unreal class path, e.g. '/Script/Engine.StaticMeshActor'
+        location: Dict with x, y, z (default 0,0,0)
+        rotation: Dict with pitch, yaw, roll (default 0,0,0)
+    """
+    payload = {
+        "objectPath": "/Script/Engine.Default__LevelScriptActor",
+        "functionName": "SpawnActorFromClass",
+        "parameters": {
+            "Class": class_path,
+            "Location": location or {"X": 0, "Y": 0, "Z": 0},
+            "Rotation": rotation or {"Pitch": 0, "Yaw": 0, "Roll": 0}
+        }
+    }
+    return _send_request(UNREAL_API_URL, payload)
+
+@mcp.tool()
+def set_property(object_path: str, property_name: str, property_value: Any) -> Dict[str, Any]:
+    """Set a property on an Unreal Engine object."""
+    payload = {
+        "objectPath": object_path,
+        "access": "WRITE_ACCESS",
+        "propertyName": property_name,
+        "propertyValue": property_value
+    }
+    return _send_request(UNREAL_PROPERTY_URL, payload)
+
+@mcp.tool()
+def execute_console_command(command: str) -> Dict[str, Any]:
+    """Execute an Unreal Engine console command."""
+    payload = {
+        "objectPath": "/Script/Engine.Default__SystemLibrary",
+        "functionName": "ExecuteConsoleCommand",
+        "parameters": {
+            "Command": command
+        }
+    }
+    return _send_request(UNREAL_API_URL, payload)
 
 if __name__ == "__main__":
     mcp.run()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hybridlabor-api/bdb-antigravity-skills",
-  "version": "1.0.9",
+  "version": "1.1.0",
   "description": "Optimized Antigravity skills and MCP pack for BDB DEV",
   "main": "installer.js",
   "bin": {

package/mcps/scaffold.sh

@@ -1,70 +0,0 @@
-#!/bin/bash
-set -e
-
-# Node: Unreal
-cat << 'NODE_EOF' > /Users/timrennings/bdb-dev-optimized-antigravity-skills/mcps/bdb-unrealengine5-mcp/index.js
-#!/usr/bin/env node
-const readline = require('readline');
-const rl = readline.createInterface({
-  input: process.stdin,
-  output: process.stdout,
-  terminal: false
-});
-rl.on('line', (line) => {
-  if (!line.trim()) return;
-  try {
-    const req = JSON.parse(line);
-    if (req.method === 'initialize') {
-      console.log(JSON.stringify({ jsonrpc: '2.0', id: req.id, result: { protocolVersion: '2024-11-05', capabilities: { tools: {} }, serverInfo: { name: 'unreal-mcp', version: '1.0.0' } } }));
-    } else if (req.method === 'tools/list') {
-      console.log(JSON.stringify({ jsonrpc: '2.0', id: req.id, result: { tools: [] } }));
-    }
-  } catch (e) {}
-});
-NODE_EOF
-
-cat << 'NODE_EOF' > /Users/timrennings/bdb-dev-optimized-antigravity-skills/mcps/bdb-unrealengine5-mcp/package.json
-{ "name": "bdb-unrealengine5-mcp", "version": "1.0.0", "main": "index.js" }
-NODE_EOF
-
-# Node: Resolume
-cp /Users/timrennings/bdb-dev-optimized-antigravity-skills/mcps/bdb-unrealengine5-mcp/index.js /Users/timrennings/bdb-dev-optimized-antigravity-skills/mcps/bdb-resolume-mcp/index.js
-cat << 'NODE_EOF' > /Users/timrennings/bdb-dev-optimized-antigravity-skills/mcps/bdb-resolume-mcp/package.json
-{ "name": "bdb-resolume-mcp", "version": "1.0.0", "main": "index.js" }
-NODE_EOF
-
-# Python function
-gen_py() {
-  local name=$1
-  touch "/Users/timrennings/bdb-dev-optimized-antigravity-skills/mcps/${name}/${name}/__init__.py"
-  cat << PY_EOF > "/Users/timrennings/bdb-dev-optimized-antigravity-skills/mcps/${name}/${name}/__main__.py"
-import sys, json
-def main():
-    while True:
-        line = sys.stdin.readline()
-        if not line: break
-        line = line.strip()
-        if not line: continue
-        try:
-            req = json.loads(line)
-            if req.get("method") == "initialize":
-                res = {"jsonrpc": "2.0", "id": req.get("id"), "result": {"protocolVersion": "2024-11-05", "capabilities": {"tools": {}}, "serverInfo": {"name": "${name}", "version": "1.0.0"}}}
-                sys.stdout.write(json.dumps(res) + "\n")
-                sys.stdout.flush()
-            elif req.get("method") == "tools/list":
-                res = {"jsonrpc": "2.0", "id": req.get("id"), "result": {"tools": []}}
-                sys.stdout.write(json.dumps(res) + "\n")
-                sys.stdout.flush()
-        except Exception:
-            pass
-if __name__ == "__main__":
-    main()
-PY_EOF
-}
-
-gen_py "bdb_rhino_mcp"
-gen_py "bdb_davinci_mcp"
-gen_py "bdb_ma3_mcp"
-
-chmod +x /Users/timrennings/bdb-dev-optimized-antigravity-skills/mcps/bdb-unrealengine5-mcp/index.js
-chmod +x /Users/timrennings/bdb-dev-optimized-antigravity-skills/mcps/bdb-resolume-mcp/index.js