solidworks-mcp-server 3.0.8 → 3.1.3

package/dist/solidworks/api.js

@@ -1,55 +1,9 @@
+import { mkdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+// @ts-ignore
+import winax from 'winax';
 import { logger } from '../utils/logger.js';
-// @ts-ignore - winax module doesn't have proper TypeScript definitions
-// We MUST load winax as CommonJS for it to work properly
-let winax;
-let ActiveXObject;
-// Initialize winax - this MUST happen before we use it
-function initializeWinax() {
-    if (!winax) {
-        try {
-            // In the compiled JS, this will use require() which properly loads winax
-            winax = eval("require('winax')");
-            ActiveXObject = global.ActiveXObject;
-            logger.info('Winax initialized successfully', {
-                hasObject: !!winax?.Object,
-                hasActiveXObject: !!ActiveXObject
-            });
-        }
-        catch (error) {
-            logger.error('Failed to initialize winax', error);
-            throw new Error('Failed to load winax module. Ensure it is installed.');
-        }
-    }
-    return winax;
-}
-// Create a robust COM object factory
-function createCOMObject(progId) {
-    // Ensure winax is loaded
-    initializeWinax();
-    try {
-        // Method 1: Try winax.Object directly (this worked in your test)
-        if (winax && winax.Object) {
-            logger.info(`Creating COM object using winax.Object: ${progId}`);
-            const obj = new winax.Object(progId);
-            logger.info(`COM object created successfully`, { progId, hasObject: !!obj });
-            return obj;
-        }
-        // Method 2: Use global ActiveXObject (also worked in your test)
-        if (ActiveXObject) {
-            logger.info(`Creating COM object using global ActiveXObject: ${progId}`);
-            const obj = new ActiveXObject(progId);
-            logger.info(`COM object created successfully`, { progId, hasObject: !!obj });
-            return obj;
-        }
-        throw new Error('No COM object creation method available');
-    }
-    catch (error) {
-        logger.error(`Failed to create COM object ${progId}:`, error);
-        throw error;
-    }
-}
-// Export a compatibility function for legacy code
-export const createActiveXObject = createCOMObject;
 export class SolidWorksAPI {
     swApp;
     currentModel;
@@ -60,13 +14,23 @@ export class SolidWorksAPI {
     connect() {
         try {
             // Create or get running instance of SolidWorks
-            // Use our robust COM object factory
-            this.swApp = createCOMObject('SldWorks.Application');
+            // @ts-ignore
+            this.swApp = new winax.Object('SldWorks.Application');
             this.swApp.Visible = true;
             logger.info('Connected to SolidWorks');
         }
-        catch (error) {
-            throw new Error(`Failed to connect to SolidWorks: ${error}`);
+        catch (_error) {
+            // Try alternative connection method
+            try {
+                // @ts-ignore
+                this.swApp = winax.Object('SldWorks.Application');
+                this.swApp.Visible = true;
+                logger.info('Connected to SolidWorks (alternative method)');
+            }
+            catch (error2) {
+                logger.error('Failed to connect to SolidWorks', error2);
+                throw new Error(`Failed to connect to SolidWorks: ${error2}`);
+            }
         }
     }
     disconnect() {
@@ -99,9 +63,16 @@ export class SolidWorksAPI {
         if (!this.currentModel) {
             throw new Error(`Failed to open model: ${filePath}`);
         }
+        // Ensure the opened model is set as active
+        try {
+            this.swApp.ActivateDoc2(this.currentModel.GetTitle(), false, errors);
+        }
+        catch (_e) {
+            // ActivateDoc2 might fail but model is still open
+        }
         return {
             path: filePath,
-            name: this.currentModel.GetTitle,
+            name: this.currentModel.GetTitle(),
             type: ['Part', 'Assembly', 'Drawing'][docType - 1],
             isActive: true,
         };
@@ -112,14 +83,14 @@ export class SolidWorksAPI {
         let modelTitle = '';
         try {
             // Safely get the title
-            if ('GetTitle' in this.currentModel) {
-                modelTitle = this.currentModel.GetTitle;
+            if (this.currentModel.GetTitle) {
+                modelTitle = this.currentModel.GetTitle();
             }
-            else if ('GetPathName' in this.currentModel) {
-                modelTitle = this.currentModel.GetPathName;
+            else if (this.currentModel.GetPathName) {
+                modelTitle = this.currentModel.GetPathName();
             }
         }
-        catch (e) {
+        catch (_e) {
             // If we can't get the title, continue anyway
             modelTitle = 'Unknown';
         }
@@ -127,13 +98,13 @@ export class SolidWorksAPI {
             try {
                 this.currentModel.Save3(1, 0, 0); // swSaveAsOptions_Silent
             }
-            catch (e) {
+            catch (_e) {
                 // Save might fail if document is new and has no path
                 try {
                     // Try Save instead
                     this.currentModel.Save();
                 }
-                catch (e2) {
+                catch (_e2) {
                     // Continue even if save fails
                 }
             }
@@ -143,7 +114,7 @@ export class SolidWorksAPI {
             try {
                 this.swApp.CloseDoc(modelTitle);
             }
-            catch (e) {
+            catch (_e) {
                 // Fallback: just clear the reference
             }
         }
@@ -206,7 +177,7 @@ export class SolidWorksAPI {
         return { success: false, error: 'Failed to create extrusion' };
     }
     // Feature operations
-    createExtrude(depth, draft = 0, reverse = false) {
+    createExtrude(depth, _draft = 0, reverse = false) {
         if (!this.currentModel)
             throw new Error('No model open');
         try {
@@ -215,63 +186,200 @@ export class SolidWorksAPI {
             if (!featureMgr) {
                 throw new Error('Cannot access FeatureManager');
             }
-            // Try different extrusion methods based on what's available
+            // Make sure we're not in sketch edit mode
+            try {
+                const sketchMgr = this.currentModel.SketchManager;
+                const activeSketch = sketchMgr.ActiveSketch;
+                if (activeSketch) {
+                    // Exit sketch mode
+                    sketchMgr.InsertSketch(true);
+                }
+            }
+            catch (_e) {
+                // Continue if no active sketch
+            }
+            // Clear selections first
+            try {
+                this.currentModel.ClearSelection2(true);
+            }
+            catch (_e) {
+                // Continue
+            }
+            // Select the sketch - try multiple methods with detailed logging
+            let sketchSelected = false;
+            let selectedSketchName = '';
+            const attemptedSketches = [];
+            // Method 1 (most reliable): Feature tree traversal
+            // This avoids SelectByID2 COM type mismatch issues entirely
+            try {
+                const featureCount = this.currentModel.GetFeatureCount();
+                logger.info(`Searching ${featureCount} features for sketch...`);
+                for (let i = 0; i < Math.min(10, featureCount); i++) {
+                    const feat = this.currentModel.FeatureByPositionReverse(i);
+                    if (feat) {
+                        const typeName = feat.GetTypeName2();
+                        const featName = feat.Name || feat.GetName();
+                        if (typeName === 'ProfileFeature' || typeName?.toLowerCase().includes('sketch')) {
+                            feat.Select2(false, 0);
+                            sketchSelected = true;
+                            selectedSketchName = featName || `Feature at position ${i}`;
+                            logger.info(`Selected sketch by feature tree: ${selectedSketchName}`);
+                            break;
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                logger.warn(`Feature tree search failed: ${e}`);
+            }
+            // Method 2 (fallback): SelectByID2 with undefined for optional params
+            if (!sketchSelected) {
+                const sketchNames = ['Sketch1', 'Sketch2', 'Sketch3', 'Sketch4', 'Sketch5'];
+                for (const name of sketchNames) {
+                    try {
+                        const ext = this.currentModel.Extension;
+                        if (ext) {
+                            const selected = ext.SelectByID2(name, 'SKETCH', 0, 0, 0, false, 0, undefined, 0);
+                            if (selected) {
+                                sketchSelected = true;
+                                selectedSketchName = name;
+                                logger.info(`Selected sketch via SelectByID2: ${name}`);
+                                break;
+                            }
+                            else {
+                                attemptedSketches.push(name);
+                            }
+                        }
+                    }
+                    catch (e) {
+                        attemptedSketches.push(`${name} (error: ${e})`);
+                    }
+                }
+            }
+            if (!sketchSelected) {
+                const errorMessage = `No sketch found to extrude. Attempted sketches: ${attemptedSketches.join(', ')}. ` +
+                    `Please ensure a sketch exists or specify the sketch name explicitly.`;
+                logger.error(errorMessage);
+                throw new Error(errorMessage);
+            }
+            logger.info(`Using sketch: ${selectedSketchName}`);
+            // Convert depth to meters
+            const depthInMeters = depth / 1000;
             let feature = null;
+            // Try different extrusion methods
+            // The winax library has issues with methods that have many parameters
+            // We'll try to use a workaround by creating a variant array
             try {
-                // Method 1: Try FeatureExtrusion3 with all parameters
-                feature = featureMgr.FeatureExtrusion3(true, // SingleEndedFeature
-                reverse, // ReverseDirection
-                false, // UseDirection2
-                0, // EndCondition1 (0 = blind)
-                0, // EndCondition2 
-                depth / 1000, // Depth1 (convert mm to m)
-                0.01, // Depth2
-                false, // RevOffset1
-                false, // RevOffset2
-                false, // ThinFeature
-                draft * Math.PI / 180, // DraftAngle1 (convert to radians)
-                0, // DraftAngle2
-                false, // DraftOutward1
-                false, // DraftOutward2
-                false, // DraftWhileDrag1
-                false, // DraftWhileDrag2
-                false, // ReverseOffset1Dir
-                true, // TranslateSurface1
-                false, // NormalToCurve
-                0, // StartCondition
-                0, // SketchPlane
-                false // FlipStartDirection
-                );
+                // Method 1: Try the basic FeatureExtrusion with minimal params
+                // This uses a different calling convention that might work better
+                const args = [
+                    true, // Sd (single direction)
+                    reverse, // Flip
+                    false, // Dir
+                    0, // T1 (0 = blind)
+                    0, // T2
+                    depthInMeters, // D1 (depth)
+                    0, // D2
+                    false, // Dchk1
+                    false, // Dchk2
+                    false, // Ddir1
+                    false, // Ddir2
+                    0, // Dang1
+                    0, // Dang2
+                ];
+                // Try to invoke the method directly
+                feature = featureMgr.FeatureExtrusion.apply(featureMgr, args);
+                logger.info('FeatureExtrusion succeeded with apply');
             }
             catch (e) {
-                // Method 2: Try FeatureExtrusion2 with fewer parameters
+                logger.warn(`FeatureExtrusion with apply failed: ${e}`);
+                // Method 2: Try using the __methods__ property if available
                 try {
-                    feature = featureMgr.FeatureExtrusion2(true, // SingleEndedFeature
-                    reverse, // ReverseDirection
-                    false, // UseDirection2
-                    0, // EndCondition1
-                    0, // EndCondition2
-                    depth / 1000, // Depth1
-                    0.01, // Depth2
-                    false, // RevOffset1
-                    false, // RevOffset2
-                    false, // ThinFeature
-                    draft * Math.PI / 180, // DraftAngle1
-                    0, // DraftAngle2
-                    false, // DraftOutward1
-                    false // DraftOutward2
-                    );
+                    // Some COM objects expose methods differently
+                    if (featureMgr.__methods__?.FeatureExtrusion) {
+                        feature = featureMgr.__methods__.FeatureExtrusion(true, reverse, false, 0, 0, depthInMeters, 0, false, false, false, false, 0, 0);
+                        logger.info('FeatureExtrusion succeeded via __methods__');
+                    }
+                    else {
+                        throw new Error('__methods__ not available');
+                    }
                 }
                 catch (e2) {
-                    // Method 3: Try the simplest FeatureExtrusion
-                    feature = featureMgr.FeatureExtrusion(true, reverse, 0, depth / 1000, 0, 0, true, false, false, draft * Math.PI / 180, 0, false, false);
+                    logger.warn(`Alternative method failed: ${e2}`);
+                    // Method 3: Try to create the extrusion using automation-compatible approach
+                    try {
+                        // Last resort: Try with explicit VARIANT conversion if available
+                        const variant = winax.Variant;
+                        if (variant) {
+                            const params = new variant([
+                                true,
+                                reverse,
+                                false,
+                                0,
+                                0,
+                                depthInMeters,
+                                0,
+                                false,
+                                false,
+                                false,
+                                false,
+                                0,
+                                0,
+                            ]);
+                            feature = featureMgr.FeatureExtrusion(params);
+                            logger.info('FeatureExtrusion succeeded with VARIANT');
+                        }
+                        else {
+                            // Final fallback: standard call
+                            feature = featureMgr.FeatureExtrusion(true, reverse, false, 0, 0, depthInMeters, 0, false, false, false, false, 0, 0);
+                            logger.info('FeatureExtrusion succeeded with standard call');
+                        }
+                    }
+                    catch (e3) {
+                        logger.warn(`All direct COM extrusion methods failed: ${e3}`);
+                        logger.info('Falling back to VBA macro execution for extrusion...');
+                        // Method 4: VBA macro fallback - bypasses winax parameter limit
+                        feature = this.executeExtrusionViaMacro(depthInMeters, reverse);
+                    }
                 }
             }
             if (!feature) {
-                throw new Error('Failed to create extrusion - ensure a sketch is selected');
+                throw new Error('Failed to create extrusion - feature is null');
+            }
+            // Get feature name
+            let featureName = 'Boss-Extrude1';
+            try {
+                if (feature.Name) {
+                    featureName = feature.Name;
+                }
+                else if (feature.GetName) {
+                    featureName = feature.GetName();
+                }
+            }
+            catch (_e) {
+                // Use default name
+            }
+            // Clear selections
+            try {
+                this.currentModel.ClearSelection2(true);
+            }
+            catch (_e) {
+                // Ignore
+            }
+            // Rebuild
+            try {
+                this.currentModel.EditRebuild3();
+            }
+            catch (_e) {
+                try {
+                    this.currentModel.EditRebuild();
+                }
+                catch (_e2) {
+                    // Continue
+                }
             }
             return {
-                name: feature.Name,
+                name: featureName,
                 type: 'Extrusion',
                 suppressed: false,
             };
@@ -280,24 +388,288 @@ export class SolidWorksAPI {
             throw new Error(`Extrusion failed: ${error}`);
         }
     }
+    /**
+     * Execute extrusion via VBA macro - bypasses winax COM parameter limit.
+     * Used as fallback when direct COM calls fail with type mismatch errors.
+     */
+    executeExtrusionViaMacro(depthInMeters, reverse) {
+        const macroDir = join(tmpdir(), 'solidworks-mcp-macros');
+        const macroPath = join(macroDir, `extrusion_${Date.now()}.swp`);
+        try {
+            mkdirSync(macroDir, { recursive: true });
+        }
+        catch (_e) {
+            // Directory may already exist
+        }
+        // Generate a silent VBA macro (no MsgBox — automation-safe)
+        const vbaCode = `Attribute VB_Name = "Module1"
+Option Explicit
+
+Sub CreateExtrusion()
+    Dim swApp As Object
+    Dim swModel As Object
+    Dim swFeatureMgr As Object
+    Dim swFeature As Object
+
+    On Error GoTo ErrorHandler
+
+    Set swApp = Application.SldWorks
+    Set swModel = swApp.ActiveDoc
+
+    If swModel Is Nothing Then Exit Sub
+
+    Set swFeatureMgr = swModel.FeatureManager
+
+    ' The sketch should already be selected by the caller.
+    ' Create a simple blind extrusion using FeatureExtrusion3
+    Set swFeature = swFeatureMgr.FeatureExtrusion3( _
+        True, _              ' Sd  (single direction)
+        ${reverse ? 'True' : 'False'}, _             ' Flip
+        False, _             ' Dir (both directions)
+        0, _                 ' T1  (blind end condition)
+        0, _                 ' T2
+        ${depthInMeters}, _  ' D1  (depth in meters)
+        0, _                 ' D2
+        False, _             ' Dchk1 (draft while extruding)
+        False, _             ' Dchk2
+        False, _             ' Ddir1 (draft outward)
+        False, _             ' Ddir2
+        0, _                 ' Dang1 (draft angle)
+        0, _                 ' Dang2
+        False, _             ' OffsetReverse1
+        False, _             ' OffsetReverse2
+        False, _             ' TranslateSurface1
+        False, _             ' TranslateSurface2
+        True, _              ' Merge
+        False, _             ' FlipSideToCut
+        True, _              ' UseFeatScope
+        0, _                 ' StartCondition
+        0, _                 ' StartOffset
+        False _              ' FlipStartOffset
+    )
+
+    ' Rebuild the model
+    swModel.EditRebuild3
+
+    Exit Sub
+
+ErrorHandler:
+    ' Silent fail — caller checks for feature creation
+    Debug.Print "Extrusion macro error: " & Err.Description
+End Sub
+`;
+        try {
+            writeFileSync(macroPath, vbaCode, 'utf-8');
+            logger.info(`Wrote extrusion macro to ${macroPath}`);
+            // Execute the macro via SolidWorks RunMacro2
+            const runResult = this.swApp.RunMacro2(macroPath, 'Module1', 'CreateExtrusion', 1, // swRunMacroOption_e.swRunMacroUnloadAfterRun
+            0 // error out param
+            );
+            logger.info(`RunMacro2 returned: ${runResult}`);
+            // Retrieve the newly created feature (should be the most recent)
+            const feature = this.currentModel.FeatureByPositionReverse(0);
+            if (feature) {
+                const typeName = feature.GetTypeName2?.() || '';
+                if (typeName.toLowerCase().includes('extrusion') || typeName.toLowerCase().includes('boss')) {
+                    logger.info(`VBA macro extrusion succeeded: ${feature.Name || feature.GetName?.()}`);
+                    return feature;
+                }
+            }
+            throw new Error('VBA macro executed but no extrusion feature found');
+        }
+        catch (macroError) {
+            logger.error(`VBA macro extrusion failed: ${macroError}`);
+            throw new Error(`Extrusion failed: all direct COM methods and VBA macro fallback failed. Details: ${macroError}`);
+        }
+        finally {
+            // Clean up temp macro file
+            try {
+                unlinkSync(macroPath);
+            }
+            catch (_e) {
+                // Ignore cleanup errors
+            }
+        }
+    }
     // Dimension operations
     getDimension(name) {
         if (!this.currentModel)
             throw new Error('No model open');
-        const dimension = this.currentModel.Parameter(name);
+        let dimension = null;
+        // Method 1: Try Parameter method
+        try {
+            dimension = this.currentModel.Parameter(name);
+        }
+        catch (_e) {
+            // Parameter might not work
+        }
+        // Method 2: Try GetParameter
         if (!dimension) {
-            throw new Error(`Dimension "${name}" not found`);
+            try {
+                dimension = this.currentModel.GetParameter(name);
+            }
+            catch (_e) {
+                // GetParameter might not work
+            }
+        }
+        // Method 3: Try Extension.GetParameter
+        if (!dimension) {
+            try {
+                const ext = this.currentModel.Extension;
+                if (ext) {
+                    dimension = ext.GetParameter(name);
+                }
+            }
+            catch (_e) {
+                // Extension method might not work
+            }
+        }
+        // Method 4: Try SelectByID and get dimension
+        if (!dimension) {
+            try {
+                const selected = this.currentModel.Extension.SelectByID2(name, 'DIMENSION', 0, 0, 0, false, 0, undefined, 0);
+                if (selected) {
+                    const selMgr = this.currentModel.SelectionManager;
+                    if (selMgr && selMgr.GetSelectedObjectCount() > 0) {
+                        const obj = selMgr.GetSelectedObject6(1, -1);
+                        if (obj) {
+                            dimension = obj;
+                        }
+                    }
+                    this.currentModel.ClearSelection2(true);
+                }
+            }
+            catch (_e) {
+                // Selection method failed
+            }
+        }
+        if (!dimension) {
+            throw new Error(`Dimension "${name}" not found. Try format like "D1@Sketch1" or "D1@Boss-Extrude1"`);
+        }
+        // Get the value - try different properties
+        let value = 0;
+        try {
+            if (dimension.SystemValue !== undefined) {
+                value = dimension.SystemValue * 1000; // Convert m to mm
+            }
+            else if (dimension.Value !== undefined) {
+                value = dimension.Value * 1000;
+            }
+            else if (dimension.GetSystemValue) {
+                value = dimension.GetSystemValue() * 1000;
+            }
+            else {
+                throw new Error('Cannot read dimension value');
+            }
+        }
+        catch (_e) {
+            throw new Error(`Cannot read value of dimension "${name}"`);
         }
-        return dimension.SystemValue * 1000; // Convert m to mm
+        return value;
     }
     setDimension(name, value) {
         if (!this.currentModel)
             throw new Error('No model open');
-        const dimension = this.currentModel.Parameter(name);
+        let dimension = null;
+        // Method 1: Try Parameter method
+        try {
+            dimension = this.currentModel.Parameter(name);
+        }
+        catch (_e) {
+            // Parameter might not work
+        }
+        // Method 2: Try GetParameter
+        if (!dimension) {
+            try {
+                dimension = this.currentModel.GetParameter(name);
+            }
+            catch (_e) {
+                // GetParameter might not work
+            }
+        }
+        // Method 3: Try Extension.GetParameter
+        if (!dimension) {
+            try {
+                const ext = this.currentModel.Extension;
+                if (ext) {
+                    dimension = ext.GetParameter(name);
+                }
+            }
+            catch (_e) {
+                // Extension method might not work
+            }
+        }
+        // Method 4: Try SelectByID and get dimension
+        if (!dimension) {
+            try {
+                const selected = this.currentModel.Extension.SelectByID2(name, 'DIMENSION', 0, 0, 0, false, 0, undefined, 0);
+                if (selected) {
+                    const selMgr = this.currentModel.SelectionManager;
+                    if (selMgr && selMgr.GetSelectedObjectCount() > 0) {
+                        const obj = selMgr.GetSelectedObject6(1, -1);
+                        if (obj) {
+                            dimension = obj;
+                        }
+                    }
+                    // Don't clear selection yet - might need it for setting
+                }
+            }
+            catch (_e) {
+                // Selection method failed
+            }
+        }
         if (!dimension) {
-            throw new Error(`Dimension "${name}" not found`);
+            throw new Error(`Dimension "${name}" not found. Try format like "D1@Sketch1" or "D1@Boss-Extrude1"`);
+        }
+        // Set the value - try different methods
+        const newValue = value / 1000; // Convert mm to m
+        let success = false;
+        try {
+            if (dimension.SystemValue !== undefined) {
+                dimension.SystemValue = newValue;
+                success = true;
+            }
+            else if (dimension.Value !== undefined) {
+                dimension.Value = newValue;
+                success = true;
+            }
+            else if (dimension.SetSystemValue) {
+                success = dimension.SetSystemValue(newValue);
+            }
+            else if (dimension.SetValue) {
+                success = dimension.SetValue(newValue);
+            }
+        }
+        catch (_e) {
+            // Try equation manager
+            try {
+                const eqMgr = this.currentModel.GetEquationMgr();
+                if (eqMgr) {
+                    const count = eqMgr.GetCount();
+                    for (let i = 0; i < count; i++) {
+                        const eq = eqMgr.Equation[i];
+                        if (eq?.includes(name)) {
+                            eqMgr.Equation[i] = `"${name}" = ${value}`;
+                            success = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            catch (_e2) {
+                // Equation manager failed
+            }
+        }
+        // Clear selection if we used it
+        try {
+            this.currentModel.ClearSelection2(true);
+        }
+        catch (_e) {
+            // Ignore clear selection errors
+        }
+        if (!success) {
+            throw new Error(`Failed to set dimension "${name}" to ${value}mm`);
         }
-        dimension.SystemValue = value / 1000; // Convert mm to m
         this.currentModel.EditRebuild3();
     }
     // Export operations
@@ -306,100 +678,114 @@ export class SolidWorksAPI {
             throw new Error('No model open');
         try {
             // Ensure the model is saved first
-            const currentPath = this.currentModel.GetPathName;
+            const currentPath = this.currentModel.GetPathName();
             if (!currentPath || currentPath === '') {
                 // Save the model first if it hasn't been saved
-                const docType = this.currentModel.GetType;
+                const docType = this.currentModel.GetType();
                 const ext = docType === 1 ? '.SLDPRT' : docType === 2 ? '.SLDASM' : '.SLDDRW';
                 const tempPath = filePath.replace(/\.[^.]+$/, ext);
                 this.currentModel.SaveAs3(tempPath, 0, 1);
             }
             const ext = format.toLowerCase();
             let success = false;
-            // Try to get export data
-            let exportData = null;
-            try {
-                exportData = this.swApp.GetExportFileData(1); // 1 = current config only
-            }
-            catch (e) {
-                // Export data might not be available for all formats
-            }
+            const errors = 0;
+            const warnings = 0;
+            // Try different export methods based on format
             switch (ext) {
                 case 'step':
                 case 'stp':
-                    if (exportData) {
+                    // Method 1: Try SaveAs3 with proper file extension
+                    try {
+                        success = this.currentModel.SaveAs3(filePath, 0, 2);
+                        if (!success) {
+                            // Method 2: Try Extension.SaveAs with swSaveAsCurrentVersion flag
+                            success = this.currentModel.Extension.SaveAs(filePath, 0, 2, undefined, errors, warnings);
+                        }
+                    }
+                    catch (_e) {
+                        // Method 3: Try GetExportFileData approach
                         try {
-                            exportData.SetStep203(true); // Use STEP AP203
+                            const exportData = this.swApp.GetExportFileData(1);
+                            if (exportData) {
+                                exportData.SetStep203(true);
+                                success = this.currentModel.Extension.SaveAs(filePath, 0, 2, exportData, errors, warnings);
+                            }
                         }
-                        catch (e) {
-                            // Method might not exist
+                        catch (e2) {
+                            throw new Error(`Failed to export to STEP: ${e2}`);
                         }
                     }
-                    // Try Extension.SaveAs first
+                    break;
+                case 'iges':
+                case 'igs':
+                    // Method 1: Try SaveAs3 with proper flags
                     try {
-                        success = this.currentModel.Extension.SaveAs(filePath, 0, // version
-                        1, // options
-                        exportData, 0, // errors
-                        0 // warnings
-                        );
+                        success = this.currentModel.SaveAs3(filePath, 0, 2);
+                        if (!success) {
+                            // Method 2: Try Extension.SaveAs
+                            success = this.currentModel.Extension.SaveAs(filePath, 0, 2, undefined, errors, warnings);
+                        }
                     }
                     catch (e) {
-                        // Fall back to SaveAs3
-                        success = this.currentModel.SaveAs3(filePath, 0, 1);
+                        throw new Error(`Failed to export to IGES: ${e}`);
                     }
                     break;
-                case 'iges':
-                case 'igs':
-                    success = this.currentModel.SaveAs3(filePath, 0, 1);
-                    break;
                 case 'stl':
-                    // STL specific - try SaveAs4 for STL options
+                    // STL specific - try different methods
                     try {
-                        success = this.currentModel.SaveAs4(filePath, 0, // Version
-                        1, // Options
-                        0, // Errors
-                        0 // Warnings
-                        );
+                        // Method 1: SaveAs3 with proper flags
+                        success = this.currentModel.SaveAs3(filePath, 0, 2);
+                        if (!success) {
+                            // Method 2: Try SaveAs4 if available
+                            try {
+                                success = this.currentModel.SaveAs4(filePath, 0, 2, errors, warnings);
+                            }
+                            catch (_e2) {
+                                // Method 3: Try Extension.SaveAs
+                                success = this.currentModel.Extension.SaveAs(filePath, 0, 2, undefined, errors, warnings);
+                            }
+                        }
                     }
                     catch (e) {
-                        success = this.currentModel.SaveAs3(filePath, 0, 1);
+                        throw new Error(`Failed to export to STL: ${e}`);
                     }
                     break;
-                case 'pdf':
+                case 'pdf': {
                     // PDF export requires drawing
                     const docType = this.currentModel.GetType();
-                    if (docType !== 3) { // 3 = swDocDRAWING
+                    if (docType !== 3) {
+                        // 3 = swDocDRAWING
                         throw new Error('PDF export requires a drawing document');
                     }
-                    // Try ExportPdfData if available
                     try {
-                        const pdfData = this.swApp.GetExportFileData(1);
-                        success = this.currentModel.SaveAs3(filePath, 0, 1);
+                        success = this.currentModel.SaveAs3(filePath, 0, 2);
+                        if (!success) {
+                            success = this.currentModel.Extension.SaveAs(filePath, 0, 2, undefined, errors, warnings);
+                        }
                     }
                     catch (e) {
-                        success = this.currentModel.SaveAs3(filePath, 0, 1);
+                        throw new Error(`Failed to export to PDF: ${e}`);
                     }
                     break;
+                }
                 case 'dxf':
                 case 'dwg':
-                    // DXF/DWG export
-                    success = this.currentModel.SaveAs3(filePath, 0, 1);
+                    // DXF/DWG export - mainly for drawings
+                    try {
+                        success = this.currentModel.SaveAs3(filePath, 0, 2);
+                        if (!success) {
+                            success = this.currentModel.Extension.SaveAs(filePath, 0, 2, undefined, errors, warnings);
+                        }
+                    }
+                    catch (e) {
+                        throw new Error(`Failed to export to ${format.toUpperCase()}: ${e}`);
+                    }
                     break;
                 default:
-                    // Try generic export
-                    success = this.currentModel.SaveAs3(filePath, 0, 1);
-            }
-            if (!success) {
-                // Try one more time with SaveAs2
-                try {
-                    success = this.currentModel.SaveAs2(filePath, 0, true, false);
-                }
-                catch (e) {
-                    throw new Error(`Failed to export to ${format}`);
-                }
+                    throw new Error(`Unsupported export format: ${format}`);
             }
             if (!success) {
-                throw new Error(`Failed to export to ${format}`);
+                throw new Error(`Failed to export to ${format.toUpperCase()}: Export returned false`);
             }
         }
         catch (error) {
@@ -407,7 +793,7 @@ export class SolidWorksAPI {
         }
     }
     // VBA operations
-    runMacro(macroPath, moduleName, procedureName, args = []) {
+    runMacro(macroPath, moduleName, procedureName, _args = []) {
         if (!this.swApp)
             throw new Error('Not connected to SolidWorks');
         const result = this.swApp.RunMacro2(macroPath, moduleName, procedureName, 1, // swRunMacroOption
@@ -421,8 +807,9 @@ export class SolidWorksAPI {
         if (!this.currentModel)
             throw new Error('No model open');
         // Check document type - mass properties only work for parts and assemblies
-        const docType = this.currentModel.GetType;
-        if (docType !== 1 && docType !== 2) { // 1=Part, 2=Assembly
+        const docType = this.currentModel.GetType();
+        if (docType !== 1 && docType !== 2) {
+            // 1=Part, 2=Assembly
             throw new Error('Mass properties only available for parts and assemblies');
         }
         try {
@@ -437,12 +824,12 @@ export class SolidWorksAPI {
                 // Method 1: Try CreateMassProperty
                 massProps = modeler.CreateMassProperty();
             }
-            catch (e) {
+            catch (_e) {
                 // Method 2: Try CreateMassProperty2
                 try {
                     massProps = modeler.CreateMassProperty2();
                 }
-                catch (e2) {
+                catch (_e2) {
                     // Method 3: Try getting it from the model directly
                     massProps = this.currentModel.GetMassProperties();
                 }
@@ -462,7 +849,7 @@ export class SolidWorksAPI {
                     }
                 }
             }
-            catch (e) {
+            catch (_e) {
                 // Update might not be needed
             }
             // Get the values with error handling
@@ -470,19 +857,19 @@ export class SolidWorksAPI {
             try {
                 result.mass = massProps.Mass;
             }
-            catch (e) {
+            catch (_e) {
                 result.mass = 0;
             }
             try {
                 result.volume = massProps.Volume;
             }
-            catch (e) {
+            catch (_e) {
                 result.volume = 0;
             }
             try {
                 result.surfaceArea = massProps.SurfaceArea;
             }
-            catch (e) {
+            catch (_e) {
                 result.surfaceArea = 0;
             }
             try {
@@ -498,13 +885,13 @@ export class SolidWorksAPI {
                     result.centerOfMass = { x: 0, y: 0, z: 0 };
                 }
             }
-            catch (e) {
+            catch (_e) {
                 result.centerOfMass = { x: 0, y: 0, z: 0 };
             }
             try {
                 result.density = massProps.Density;
             }
-            catch (e) {
+            catch (_e) {
                 result.density = 0;
             }
             try {
@@ -519,11 +906,11 @@ export class SolidWorksAPI {
                         Iyz: moi[5],
                         Izx: moi[6],
                         Izy: moi[7],
-                        Izz: moi[8]
+                        Izz: moi[8],
                     };
                 }
             }
-            catch (e) {
+            catch (_e) {
                 // Moments of inertia might not be available
             }
             return result;
@@ -534,18 +921,57 @@ export class SolidWorksAPI {
     }
     // Helper to ensure current model is set
     ensureCurrentModel() {
-        if (!this.currentModel && this.swApp) {
-            // Try to get the active document
-            try {
-                this.currentModel = this.swApp.ActiveDoc;
+        if (!this.swApp)
+            return;
+        // Always try to sync with the active document
+        try {
+            const activeDoc = this.swApp.ActiveDoc;
+            if (activeDoc) {
+                // Check if the active doc has changed
+                if (!this.currentModel || this.currentModel !== activeDoc) {
+                    this.currentModel = activeDoc;
+                }
             }
-            catch (e) {
-                // ActiveDoc might not be available
+            else if (!this.currentModel) {
+                // No active doc and no current model - try to get any open doc
+                try {
+                    const docCount = this.swApp.GetDocumentCount();
+                    if (docCount > 0) {
+                        // Get the first document
+                        const docs = this.swApp.GetDocuments();
+                        if (docs && docs.length > 0) {
+                            this.currentModel = docs[0];
+                        }
+                    }
+                }
+                catch (_e2) {
+                    // GetDocumentCount might not be available
+                }
+            }
+        }
+        catch (_e) {
+            // ActiveDoc might throw if no documents are open
+            // Keep the current model if we have one
+            if (!this.currentModel) {
+                // Try alternative methods to get a document
+                try {
+                    const frame = this.swApp.Frame();
+                    if (frame) {
+                        const modelWindow = frame.ModelWindow();
+                        if (modelWindow) {
+                            this.currentModel = modelWindow.ModelDoc;
+                        }
+                    }
+                }
+                catch (_e3) {
+                    // Frame method might not work
+                }
             }
         }
     }
     // Helper to get current model
     getCurrentModel() {
+        this.ensureCurrentModel();
         return this.currentModel;
     }
     // Helper to get SolidWorks app