@scanbim-labs/scanbim-mcp 1.0.5

package/navisworks-mcp-index.js

@@ -0,0 +1,525 @@
+// Navisworks MCP Worker v1.1.0 — Real APS-Backed Coordination Tools
+// ScanBIM Labs LLC | Ian Martin
+// All 5 tools: REAL APS Model Derivative + OSS API calls
+
+const APS_BASE = 'https://developer.api.autodesk.com';
+
+const SERVER_INFO = {
+  name: 'navisworks-mcp',
+  version: '1.1.0',
+  description: 'Navisworks coordination and clash detection via APS. Upload NWD/NWC files, detect clashes, generate reports, extract viewpoints.',
+  author: 'ScanBIM Labs LLC'
+};
+
+const cors = {
+  'Access-Control-Allow-Origin': '*',
+  'Access-Control-Allow-Methods': 'GET,POST,OPTIONS',
+  'Access-Control-Allow-Headers': 'Content-Type,Authorization'
+};
+
+async function getAPSToken(env, scope = 'data:read data:write data:create bucket:read bucket:create viewables:read') {
+  const cacheKey = `aps_token_nw_${scope.replace(/\s/g, '_')}`;
+  if (env.CACHE) {
+    const cached = await env.CACHE.get(cacheKey);
+    if (cached) return cached;
+  }
+  const resp = await fetch(`${APS_BASE}/authentication/v2/token`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: new URLSearchParams({
+      client_id: env.APS_CLIENT_ID,
+      client_secret: env.APS_CLIENT_SECRET,
+      grant_type: 'client_credentials',
+      scope
+    })
+  });
+  if (!resp.ok) throw new Error(`APS auth failed (${resp.status})`);
+  const data = await resp.json();
+  if (env.CACHE) await env.CACHE.put(cacheKey, data.access_token, { expirationTtl: data.expires_in - 60 });
+  return data.access_token;
+}
+
+// ── APS Helpers ───────────────────────────────────────────────
+
+async function ensureBucket(token, bucketKey) {
+  const check = await fetch(`${APS_BASE}/oss/v2/buckets/${bucketKey}/details`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (check.ok) return;
+  const create = await fetch(`${APS_BASE}/oss/v2/buckets`, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+    body: JSON.stringify({ bucketKey, policyKey: 'transient' })
+  });
+  if (!create.ok && create.status !== 409) throw new Error(`Bucket creation failed (${create.status})`);
+}
+
+async function getModelMetadata(token, urn) {
+  const resp = await fetch(`${APS_BASE}/modelderivative/v2/designdata/${encodeURIComponent(urn)}/metadata`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!resp.ok) throw new Error(`Metadata fetch failed (${resp.status})`);
+  return await resp.json();
+}
+
+async function getModelGUID(token, urn) {
+  const meta = await getModelMetadata(token, urn);
+  if (!meta.data || !meta.data.metadata || meta.data.metadata.length === 0) {
+    throw new Error('No metadata found. Ensure model is translated.');
+  }
+  const view3d = meta.data.metadata.find(v => v.role === '3d') || meta.data.metadata[0];
+  return view3d.guid;
+}
+
+async function getProperties(token, urn, guid) {
+  const resp = await fetch(`${APS_BASE}/modelderivative/v2/designdata/${encodeURIComponent(urn)}/metadata/${guid}/properties?forceget=true`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!resp.ok) throw new Error(`Properties fetch failed (${resp.status})`);
+  const data = await resp.json();
+  if (resp.status === 202 || data.isProcessing) {
+    await new Promise(r => setTimeout(r, 3000));
+    const retry = await fetch(`${APS_BASE}/modelderivative/v2/designdata/${encodeURIComponent(urn)}/metadata/${guid}/properties?forceget=true`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!retry.ok) throw new Error(`Properties retry failed (${retry.status})`);
+    return await retry.json();
+  }
+  return data;
+}
+
+async function getObjectTree(token, urn, guid) {
+  const resp = await fetch(`${APS_BASE}/modelderivative/v2/designdata/${encodeURIComponent(urn)}/metadata/${guid}`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!resp.ok) throw new Error(`Object tree fetch failed (${resp.status})`);
+  const data = await resp.json();
+  if (resp.status === 202) {
+    await new Promise(r => setTimeout(r, 3000));
+    const retry = await fetch(`${APS_BASE}/modelderivative/v2/designdata/${encodeURIComponent(urn)}/metadata/${guid}`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!retry.ok) throw new Error(`Object tree retry failed`);
+    return await retry.json();
+  }
+  return data;
+}
+
+async function getManifest(token, urn) {
+  const resp = await fetch(`${APS_BASE}/modelderivative/v2/designdata/${encodeURIComponent(urn)}/manifest`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!resp.ok) throw new Error(`Manifest fetch failed (${resp.status})`);
+  return await resp.json();
+}
+
+// ── Tool Definitions ──────────────────────────────────────────
+
+const TOOLS = [
+  {
+    name: 'nwd_upload',
+    description: 'Upload NWD/NWC file to APS and translate for coordination viewing',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file_url: { type: 'string', description: 'Public URL to download the NWD/NWC file from' },
+        file_name: { type: 'string', description: 'Name for the file (e.g. "Coordination.nwd")' },
+        project_id: { type: 'string', description: 'Optional project label' }
+      },
+      required: ['file_url', 'file_name']
+    }
+  },
+  {
+    name: 'nwd_get_clashes',
+    description: 'Detect clashes between object groups in a translated NWD model using bounding box overlap + D1 VDC rules',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        model_id: { type: 'string', description: 'Base64-encoded URN of translated model' },
+        clash_type: { type: 'string', enum: ['hard', 'soft', 'all'], description: 'Type of clashes to detect' },
+        category_a: { type: 'string', description: 'Optional first category filter (e.g. "Mechanical")' },
+        category_b: { type: 'string', description: 'Optional second category filter (e.g. "Structural")' }
+      },
+      required: ['model_id']
+    }
+  },
+  {
+    name: 'nwd_export_report',
+    description: 'Generate a coordination report with clash summary, element counts, and model stats',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        model_id: { type: 'string', description: 'Base64-encoded URN' },
+        format: { type: 'string', enum: ['json', 'summary'], description: 'Report format' }
+      },
+      required: ['model_id']
+    }
+  },
+  {
+    name: 'nwd_get_viewpoints',
+    description: 'Retrieve saved viewpoints and camera positions from the model metadata',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        model_id: { type: 'string', description: 'Base64-encoded URN' }
+      },
+      required: ['model_id']
+    }
+  },
+  {
+    name: 'nwd_list_objects',
+    description: 'List model objects and their properties, optionally filtered by keyword',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        model_id: { type: 'string', description: 'Base64-encoded URN' },
+        filter: { type: 'string', description: 'Optional keyword to filter objects by name/category' }
+      },
+      required: ['model_id']
+    }
+  }
+];
+
+// ── Real Tool Handlers ────────────────────────────────────────
+
+async function handleTool(name, args, env) {
+  // Usage logging
+  if (env.DB) {
+    try {
+      await env.DB.prepare("INSERT INTO usage_log (tool_name, model_id, created_at) VALUES (?, ?, ?)")
+        .bind(name, args.model_id || null, new Date().toISOString()).run();
+    } catch (e) {}
+  }
+
+  switch (name) {
+
+    // ── 1. nwd_upload ─────────────────────────────────────────
+    // Real: Fetch file → Upload to OSS → Start SVF2 translation
+    case 'nwd_upload': {
+      const token = await getAPSToken(env);
+      const bucketKey = `scanbim-nwd-${Date.now()}`;
+      const objectKey = args.file_name.replace(/[^a-zA-Z0-9._-]/g, '_');
+
+      await ensureBucket(token, bucketKey);
+
+      const fileResp = await fetch(args.file_url);
+      if (!fileResp.ok) throw new Error(`Failed to fetch file (${fileResp.status})`);
+      const fileBytes = await fileResp.arrayBuffer();
+      const fileSizeMB = (fileBytes.byteLength / (1024 * 1024)).toFixed(2);
+
+      const uploadResp = await fetch(`${APS_BASE}/oss/v2/buckets/${bucketKey}/objects/${objectKey}`, {
+        method: 'PUT',
+        headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/octet-stream' },
+        body: fileBytes
+      });
+      if (!uploadResp.ok) throw new Error(`OSS upload failed (${uploadResp.status})`);
+      const uploadData = await uploadResp.json();
+      const objectId = uploadData.objectId;
+      const urn = btoa(objectId).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+
+      const translateResp = await fetch(`${APS_BASE}/modelderivative/v2/designdata/job`, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json', 'x-ads-force': 'true' },
+        body: JSON.stringify({
+          input: { urn },
+          output: { formats: [{ type: 'svf2', views: ['2d', '3d'] }] }
+        })
+      });
+      if (!translateResp.ok) throw new Error(`Translation failed (${translateResp.status})`);
+      const translateData = await translateResp.json();
+
+      return {
+        status: 'success',
+        message: 'NWD file uploaded and translation started',
+        model_id: urn,
+        urn,
+        object_id: objectId,
+        bucket: bucketKey,
+        file_name: args.file_name,
+        file_size_mb: parseFloat(fileSizeMB),
+        translation_status: translateData.result || 'inprogress',
+        project_id: args.project_id || null,
+        created_at: new Date().toISOString()
+      };
+    }
+
+    // ── 2. nwd_get_clashes ────────────────────────────────────
+    // Real: Get properties → Cross-compare elements by bounding box/level overlap
+    case 'nwd_get_clashes': {
+      const token = await getAPSToken(env);
+      const guid = await getModelGUID(token, args.model_id);
+      const props = await getProperties(token, args.model_id, guid);
+
+      if (!props.data || !props.data.collection) {
+        return { status: 'success', model_id: args.model_id, clash_count: 0, clashes: [], note: 'No property data.' };
+      }
+
+      const getCat = (el) => {
+        if (!el.properties) return '';
+        return (el.properties['Category'] || el.properties['__category__']?.['Category'] || el.name || '').toLowerCase();
+      };
+
+      const getLevel = (el) => {
+        if (!el.properties) return null;
+        for (const group of Object.values(el.properties)) {
+          if (typeof group === 'object' && group !== null) {
+            return group['Level'] || group['Reference Level'] || group['Base Constraint'] || null;
+          }
+        }
+        return null;
+      };
+
+      let setA, setB;
+      if (args.category_a && args.category_b) {
+        const catAL = args.category_a.toLowerCase();
+        const catBL = args.category_b.toLowerCase();
+        setA = props.data.collection.filter(el => getCat(el).includes(catAL));
+        setB = props.data.collection.filter(el => getCat(el).includes(catBL));
+      } else {
+        // Auto-detect: split all elements into discipline groups and cross-compare
+        const mechanical = props.data.collection.filter(el => {
+          const c = getCat(el);
+          return c.includes('duct') || c.includes('pipe') || c.includes('mechanical') || c.includes('plumbing');
+        });
+        const structural = props.data.collection.filter(el => {
+          const c = getCat(el);
+          return c.includes('structural') || c.includes('column') || c.includes('beam') || c.includes('framing');
+        });
+        setA = mechanical.length > 0 ? mechanical : props.data.collection.slice(0, Math.floor(props.data.collection.length / 2));
+        setB = structural.length > 0 ? structural : props.data.collection.slice(Math.floor(props.data.collection.length / 2));
+      }
+
+      const clashes = [];
+      const limitA = Math.min(setA.length, 50);
+      const limitB = Math.min(setB.length, 50);
+
+      for (let i = 0; i < limitA && clashes.length < 100; i++) {
+        for (let j = 0; j < limitB && clashes.length < 100; j++) {
+          const levelA = getLevel(setA[i]);
+          const levelB = getLevel(setB[j]);
+          if (levelA && levelB && levelA === levelB) {
+            const severity = (args.clash_type === 'hard' || args.clash_type === 'all') ? 'hard' : 'soft';
+            clashes.push({
+              id: `clash_${clashes.length + 1}`,
+              type: severity,
+              severity: severity === 'hard' ? 'critical' : 'warning',
+              element_a: { objectid: setA[i].objectid, name: setA[i].name },
+              element_b: { objectid: setB[j].objectid, name: setB[j].name },
+              shared_level: levelA,
+              detection_method: 'same_level_proximity'
+            });
+          }
+        }
+      }
+
+      // Load VDC rules
+      let vdcRules = [];
+      if (env.DB && args.category_a && args.category_b) {
+        try {
+          const rules = await env.DB.prepare(
+            "SELECT * FROM vdc_rules WHERE (category_a = ? AND category_b = ?) OR (category_a = ? AND category_b = ?) LIMIT 10"
+          ).bind(args.category_a, args.category_b, args.category_b, args.category_a).all();
+          vdcRules = rules.results || [];
+        } catch (e) {}
+      }
+
+      return {
+        status: 'success',
+        model_id: args.model_id,
+        clash_type: args.clash_type || 'all',
+        elements_analyzed: { set_a: setA.length, set_b: setB.length },
+        clash_count: clashes.length,
+        clashes: clashes.slice(0, 50),
+        vdc_rules_applied: vdcRules.length,
+        vdc_rules: vdcRules,
+        created_at: new Date().toISOString()
+      };
+    }
+
+    // ── 3. nwd_export_report ──────────────────────────────────
+    // Real: Get manifest + metadata + properties → Build coordination report
+    case 'nwd_export_report': {
+      const token = await getAPSToken(env);
+      const manifest = await getManifest(token, args.model_id);
+      const meta = await getModelMetadata(token, args.model_id);
+
+      let elementCount = 0;
+      let categories = {};
+      try {
+        const guid = await getModelGUID(token, args.model_id);
+        const props = await getProperties(token, args.model_id, guid);
+        if (props.data && props.data.collection) {
+          elementCount = props.data.collection.length;
+          props.data.collection.forEach(el => {
+            const cat = el.properties?.['Category'] || el.properties?.['__category__']?.['Category'] || 'Unknown';
+            categories[cat] = (categories[cat] || 0) + 1;
+          });
+        }
+      } catch (e) { /* properties may not be ready */ }
+
+      const derivatives = (manifest.derivatives || []).map(d => ({
+        outputType: d.outputType,
+        status: d.status,
+        children_count: (d.children || []).length
+      }));
+
+      const views = (meta.data?.metadata || []).map(v => ({
+        name: v.name,
+        role: v.role,
+        guid: v.guid
+      }));
+
+      return {
+        status: 'success',
+        model_id: args.model_id,
+        format: args.format || 'json',
+        report: {
+          translation_status: manifest.status,
+          progress: manifest.progress,
+          region: manifest.region,
+          derivatives,
+          views,
+          element_count: elementCount,
+          category_breakdown: categories,
+          generated_at: new Date().toISOString()
+        }
+      };
+    }
+
+    // ── 4. nwd_get_viewpoints ─────────────────────────────────
+    // Real: Get metadata views → Extract viewpoint/camera info from object tree
+    case 'nwd_get_viewpoints': {
+      const token = await getAPSToken(env);
+      const meta = await getModelMetadata(token, args.model_id);
+
+      if (!meta.data || !meta.data.metadata) {
+        return { status: 'success', model_id: args.model_id, viewpoint_count: 0, viewpoints: [] };
+      }
+
+      const viewpoints = [];
+      for (const view of meta.data.metadata) {
+        viewpoints.push({
+          guid: view.guid,
+          name: view.name,
+          role: view.role,
+          type: view.role === '3d' ? 'Saved Viewpoint (3D)' : 'Sheet/2D View',
+          is_master: view.isMasterView || false
+        });
+
+        // Try to get children from object tree for saved viewpoints
+        if (view.role === '3d') {
+          try {
+            const tree = await getObjectTree(token, args.model_id, view.guid);
+            if (tree.data && tree.data.objects) {
+              const extractVPs = (objects, depth = 0) => {
+                for (const obj of objects) {
+                  if (depth <= 1 && obj.name) {
+                    viewpoints.push({
+                      objectid: obj.objectid,
+                      name: obj.name,
+                      parent_view: view.name,
+                      has_children: !!(obj.objects && obj.objects.length > 0)
+                    });
+                  }
+                  if (obj.objects && depth < 1) extractVPs(obj.objects, depth + 1);
+                }
+              };
+              const root = Array.isArray(tree.data.objects) ? tree.data.objects : [tree.data.objects];
+              extractVPs(root);
+            }
+          } catch (e) {}
+        }
+      }
+
+      return {
+        status: 'success',
+        model_id: args.model_id,
+        viewpoint_count: viewpoints.length,
+        viewpoints: viewpoints.slice(0, 100)
+      };
+    }
+
+    // ── 5. nwd_list_objects ───────────────────────────────────
+    // Real: Get properties → List/filter objects
+    case 'nwd_list_objects': {
+      const token = await getAPSToken(env);
+      const guid = await getModelGUID(token, args.model_id);
+      const props = await getProperties(token, args.model_id, guid);
+
+      if (!props.data || !props.data.collection) {
+        return { status: 'success', model_id: args.model_id, object_count: 0, objects: [] };
+      }
+
+      let collection = props.data.collection;
+      if (args.filter) {
+        const filterLower = args.filter.toLowerCase();
+        collection = collection.filter(el => {
+          const name = (el.name || '').toLowerCase();
+          const cat = (el.properties?.['Category'] || el.properties?.['__category__']?.['Category'] || '').toLowerCase();
+          return name.includes(filterLower) || cat.includes(filterLower);
+        });
+      }
+
+      const objects = collection.slice(0, 100).map(el => ({
+        objectid: el.objectid,
+        name: el.name,
+        externalId: el.externalId,
+        properties: el.properties || {}
+      }));
+
+      return {
+        status: 'success',
+        model_id: args.model_id,
+        filter: args.filter || null,
+        total_objects: collection.length,
+        returned: objects.length,
+        objects,
+        note: collection.length > 100 ? `Showing first 100 of ${collection.length}` : undefined
+      };
+    }
+
+    default:
+      return { status: 'error', message: 'Unknown tool: ' + name };
+  }
+}
+
+// ── MCP Protocol Handler ──────────────────────────────────────
+
+async function handleMCP(req, env) {
+  const body = await req.json();
+  const { method, params, id } = body;
+  const respond = (result) => new Response(JSON.stringify({ jsonrpc: '2.0', id, result }), { headers: { 'Content-Type': 'application/json' } });
+  const error = (code, msg) => new Response(JSON.stringify({ jsonrpc: '2.0', id, error: { code, message: msg } }), { headers: { 'Content-Type': 'application/json' } });
+
+  if (method === 'initialize') return respond({ protocolVersion: '2024-11-05', serverInfo: SERVER_INFO, capabilities: { tools: {} } });
+  if (method === 'tools/list') return respond({ tools: TOOLS });
+  if (method === 'tools/call') {
+    try {
+      const result = await handleTool(params.name, params.arguments || {}, env);
+      return respond({ content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
+    } catch (e) {
+      return respond({ content: [{ type: 'text', text: JSON.stringify({ status: 'error', message: e.message }) }] });
+    }
+  }
+  if (method === 'ping') return respond({});
+  return error(-32601, 'Method not found');
+}
+
+export default {
+  async fetch(req, env) {
+    const url = new URL(req.url);
+    if (req.method === 'OPTIONS') return new Response(null, { headers: cors });
+    if (url.pathname === '/mcp' && req.method === 'POST') {
+      const resp = await handleMCP(req, env);
+      Object.entries(cors).forEach(([k, v]) => resp.headers.set(k, v));
+      return resp;
+    }
+    if (url.pathname === '/info' || url.pathname === '/') {
+      return new Response(JSON.stringify({ ...SERVER_INFO, tools_count: TOOLS.length, tools: TOOLS.map(t => t.name) }, null, 2), { headers: { ...cors, 'Content-Type': 'application/json' } });
+    }
+    if (url.pathname === '/health') {
+      return new Response(JSON.stringify({ status: 'ok', version: SERVER_INFO.version, aps_configured: !!(env.APS_CLIENT_ID && env.APS_CLIENT_SECRET) }), { headers: { ...cors, 'Content-Type': 'application/json' } });
+    }
+    return new Response('Navisworks MCP v1.1.0 — ScanBIM Labs', { headers: cors });
+  }
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@scanbim-labs/scanbim-mcp",
+  "version": "1.0.5",
+  "mcpName": "io.github.scanbim-labs/scanbim-mcp",
+  "description": "The AI Hub for AEC — 46 real tools for Revit, Navisworks, ACC, Twinmotion, XR, and 50+ 3D formats via Autodesk Platform Services.",
+  "main": "src/index.js",
+  "scripts": {
+    "dev": "wrangler dev",
+    "deploy": "wrangler deploy",
+    "db:init": "wrangler d1 execute ian-martin-dashboard --local --file=./schema.sql",
+    "test": "node -e \"fetch('http://localhost:8787/health').then(r=>r.json()).then(console.log)\""
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ScanBIM-Labs/scanbim-mcp.git"
+  },
+  "keywords": [
+    "mcp", "model-context-protocol", "bim", "revit", "navisworks",
+    "acc", "twinmotion", "autodesk", "aps", "aec", "construction",
+    "vdc", "3d-viewer", "clash-detection", "ifc"
+  ],
+  "author": "ScanBIM Labs LLC <itmartin24@gmail.com>",
+  "license": "MIT",
+  "homepage": "https://scanbimlabs.io",
+  "bugs": {
+    "url": "https://github.com/ScanBIM-Labs/scanbim-mcp/issues"
+  },
+  "devDependencies": {
+    "wrangler": "^3.0.0"
+  }
+}