Altium - the Altium Bridge

@@ -192,8 +192,141 @@ fn ext_dispatch(process: &str, req_lines: &[String], result_file: &str, timeout:         "_hint": format!("No result file. {EXT_STATUS_NOTE}")}) } -/// Headless STEP with real holes/copper/models — Barrett's AdomBridge:ExportStep.+/// Headless STEP export. Default lane `outjob`: Altium's own ExportSTEP output, run from a throwaway+/// project in %TEMP% that points at the board (measured on AD 26.9.1, 2026-10-09: no dialog, no click,+/// the file is written in ~5 s). Lane `extension` is Barrett's AdomBridge:ExportStep, kept for when the+/// .NET extension loads again. pub fn export_step(args: &Value) -> Value {+    match s_or(args, "lane", "outjob").as_str() {+        "extension" => export_step_extension(args),+        _ => export_step_outjob(args),+    }+}++/// ComponentSuffixType in Altium's ExportSTEPView record, measured 2026-10-09 by exporting the same board+/// four times: the component (PRODUCT) name is always the DESIGNATOR, the type only picks the suffix.+/// 0 = none ("J1"), 1 = board name ("J1MpinTest"), 2 = `suffix` ("J1_SFX"), 3 = random id ("J1_ID_LENSEEVK").+fn step_suffix_type(name: &str) -> Option<u8> {+    match name.to_ascii_lowercase().as_str() {+        "none" | "0" => Some(0),+        "board" | "1" => Some(1),+        "custom" | "2" => Some(2),+        "id" | "3" => Some(3),+        _ => None,+    }+}++fn step_outjob_text(args: &Value) -> Result<String, String> {+    let b = |k: &str, d: bool| args.get(k).and_then(|v| v.as_bool()).unwrap_or(d);+    let tf = |v: bool| if v { "True" } else { "False" };+    let holes = b("holes", true);+    let suffix_kind = s_or(args, "suffixType", "none");+    let suffix_type = step_suffix_type(&suffix_kind).ok_or_else(|| format!("suffixType must be none, board, custom or id (got {suffix_kind:?})"))?;+    let suffix = s(args, "suffix").unwrap_or_default();+    if suffix_type == 2 && suffix.is_empty() {+        return Err("suffixType custom needs a non-empty suffix".into());+    }+    if suffix.contains('|') || suffix.contains('\n') || suffix.contains('\r') {+        return Err("suffix may not contain '|' or a line break".into());+    }+    let n = |k: &str, d: u64| args.get(k).and_then(|v| v.as_u64()).unwrap_or(d);+    // The record Altium's own Assembly.OutJob template ships, with pad holes on by default.+    let item = format!(+        "Record=ExportSTEPView|ExportComponentOptions={}|ExportModelsOption={}|ExportHolesOption=0|CanSelectPrimitives=False|IncludeMechanicalPadHoles={}|IncludeElectricalPadHoles={}|IncludeFreePadHoles={}|ExportFoldedBoard={}|ExportFoldedBoardRate=100|ComponentSuffixType={}|ComponentSuffix={}|ExportCopperOption={}|ExportCopperLayer=1|ExportPadAndViaBarrelsOnly=False|IgnoreBoardCopperLayerColors=False|ExportAsSinglePart={}",+        n("componentsOption", 0), n("modelsOption", 2), tf(holes), tf(holes), tf(holes), tf(b("folded", false)),+        suffix_type, if suffix.is_empty() { " ".to_string() } else { suffix }, n("copperOption", 0), tf(b("singlePart", false)));+    let lines = [+        "[OutputJobFile]", "Version=1.0", "Caption=", "Description=Adom altium_export_step", "",+        "[OutputGroup1]", "Name=", "Description=", "TargetOutputMedium=STEP", "VariantName=[No Variations]", "VariantScope=0",+        "CurrentConfigurationName=", "TargetPrinter=",+        "PrinterOptions=Record=PrinterOptions|Copies=1|Duplex=1|TrueTypeOptions=3|Collate=1|PrintJobKind=1|PrintWhat=1",+        "OutputMedium1=STEP", "OutputMedium1_Type=GeneratedFiles",+        "OutputType1=ExportSTEP", "OutputName1=STEP", "OutputCategory1=Export", "OutputDocumentPath1=", "OutputVariantName1=",+        "OutputEnabled1=1", "OutputEnabled1_OutputMedium1=1", "OutputDefault1=0",+        "Configuration1_Name1=OutputConfigurationParameter1",+    ];+    let mut out = lines.join("\r\n");+    out.push_str(&format!("\r\nConfiguration1_Item1={item}\r\n\r\n[PublishSettings]\r\n\r\n[GeneratedFilesSettings]\r\nRelativeOutputPath1=\r\nOpenOutputs1=0\r\nAddToProject1=0\r\nTimestampFolder1=0\r\nUseOutputName1=0\r\nEnableReload1=0\r\n"));+    Ok(out)+}++/// PRODUCT names in a STEP file, so the caller sees how parts are named without opening it.+fn step_product_names(path: &std::path::Path) -> Vec<String> {+    let text = std::fs::read(path).map(|b| String::from_utf8_lossy(&b).to_string()).unwrap_or_default();+    let mut names: Vec<String> = Vec::new();+    for part in text.split("PRODUCT('").skip(1) {+        if let Some(end) = part.find('\'') {+            let n = part[..end].to_string();+            if !n.is_empty() && !n.starts_with("Open CASCADE") && !names.contains(&n) {+                names.push(n);+            }+        }+        if names.len() >= 200 {+            break;+        }+    }+    names+}++fn export_step_outjob(args: &Value) -> Value {+    if let Some(g) = support::need_licensed() {+        return g;+    }+    let t0 = support::now();+    let pcb = s(args, "filePath").unwrap_or_else(support::demo_pcb);+    if !std::path::Path::new(&pcb).is_file() {+        return json!({"success": false, "errorCode": "pcb_not_found", "filePath": pcb,+            "_hint": "filePath must be an absolute path to a .PcbDoc on THIS machine (send it with ab's send_files first)."});+    }+    let out = s(args, "output").unwrap_or_else(|| {+        let stem = pcb.rsplit_once('.').map(|(a, _)| a.to_string()).unwrap_or_else(|| pcb.clone());+        format!("{stem}.step")+    });+    let outjob = match step_outjob_text(args) {+        Ok(t) => t,+        Err(e) => return json!({"success": false, "errorCode": "bad_args", "error": e}),+    };+    // A throwaway project: an OutJob only runs for the project it belongs to (an OutJob outside the+    // project wrote nothing, measured), and the user's own project is never touched.+    let tmp = std::env::temp_dir().join("adom-altium-step").join(format!("{}", (support::now() * 1000.0) as u64));+    let proj = tmp.join("AdomStepExport.PrjPcb");+    let oj = tmp.join("AdomStep.OutJob");+    let prj = format!("[Design]\r\nVersion=1.0\r\nHierarchyMode=0\r\n\r\n[Document1]\r\nDocumentPath={}\r\nAnnotationEnabled=1\r\nDocumentUniqueId=\r\n\r\n[Document2]\r\nDocumentPath=AdomStep.OutJob\r\nAnnotationEnabled=1\r\nDocumentUniqueId=\r\n",+        pcb.replace('/', "\\"));+    if let Err(e) = std::fs::create_dir_all(&tmp).and_then(|_| std::fs::write(&oj, outjob)).and_then(|_| std::fs::write(&proj, prj)) {+        return json!({"success": false, "errorCode": "temp_write_failed", "error": e.to_string()});+    }+    let proj_s = proj.to_string_lossy().to_string();+    let r = run_outjob(&json!({"outjobPath": oj.to_string_lossy(), "medium": "STEP", "projectPath": proj_s, "timeout": timeout_of(args, 300).as_secs()}));+    let gen_dir = tmp.join("Project Outputs for AdomStepExport").join("ExportSTEP");+    let produced = std::fs::read_dir(&gen_dir).ok().and_then(|rd| {+        rd.flatten().map(|e| e.path()).find(|p| p.extension().map(|x| x.eq_ignore_ascii_case("step") || x.eq_ignore_ascii_case("stp")).unwrap_or(false))+    });+    // Close the throwaway project whatever happened, so it does not sit in the user's Projects panel.+    let _ = agent::call("close_document", &[("path", oj.to_string_lossy().to_string())], None, Duration::from_secs(30));+    let _ = agent::call("close_document", &[("path", proj_s.clone())], None, Duration::from_secs(30));+    let Some(src) = produced else {+        return json!({"success": false, "errorCode": "step_not_written", "filePath": pcb, "outjob": r,+            "elapsedSec": support::elapsed_round(t0), "tempDir": tmp.to_string_lossy(),+            "_hint": "Altium ran the STEP output but wrote no .step. Read outjob.dialogs[] (a modal needs a decision) and altium_check_dialogs; a board that is open with unsaved changes exports its SAVED state, so altium_save first."});+    };+    if let Some(parent) = std::path::Path::new(&out).parent() {+        let _ = std::fs::create_dir_all(parent);+    }+    if let Err(e) = std::fs::copy(&src, &out) {+        return json!({"success": false, "errorCode": "copy_failed", "error": e.to_string(), "produced": src.to_string_lossy(), "tempDir": tmp.to_string_lossy()});+    }+    let bytes = std::fs::metadata(&out).map(|m| m.len()).unwrap_or(0);+    let products = step_product_names(std::path::Path::new(&out));+    let _ = std::fs::remove_dir_all(&tmp);+    json!({"success": bytes > 0, "lane": "outjob", "filePath": pcb, "output": out, "outputExists": bytes > 0, "outputBytes": bytes,+        "products": products, "suffixType": s_or(args, "suffixType", "none"), "elapsedSec": support::elapsed_round(t0),+        "windowEtiquette": "background",+        "_hint": "products[] are the STEP part names: Altium names each component by its DESIGNATOR (suffixType only appends none/board/custom/id), and a 3D model keeps the name inside its own STEP. Pull the file with ab's pull_file."})+}++/// Headless STEP with real holes/copper/models — Barrett's AdomBridge:ExportStep.+fn export_step_extension(args: &Value) -> Value {     if let Some(g) = support::need_licensed() {         return g;     }@@ -362,3 +495,38 @@ pub fn run_script(args: &Value) -> Value {     let proc = s_or(args, "proc", "Main");     lifecycle::run_script_lane_in(&proc, Some(&prj), timeout_of(args, 60)) }++#[cfg(test)]+mod step_outjob_tests {+    use super::*;++    #[test]+    fn suffix_types_follow_the_measured_mapping() {+        for (k, v) in [("none", 0), ("board", 1), ("custom", 2), ("id", 3), ("ID", 3), ("2", 2)] {+            assert_eq!(step_suffix_type(k), Some(v), "{k}");+        }+        assert_eq!(step_suffix_type("comment"), None);+    }++    #[test]+    fn default_outjob_exports_holes_without_copper() {+        let t = step_outjob_text(&json!({})).unwrap();+        assert!(t.contains("OutputType1=ExportSTEP"));+        assert!(t.contains("OutputMedium1=STEP\r\nOutputMedium1_Type=GeneratedFiles"));+        assert!(t.contains("IncludeElectricalPadHoles=True"));+        assert!(t.contains("ComponentSuffixType=0|ComponentSuffix= |"));+        assert!(t.contains("ExportCopperOption=0"));+        assert!(t.contains("ExportAsSinglePart=False"));+        assert!(!t.contains("\n\n[OutputGroup1]") || t.contains("\r\n"));+    }++    #[test]+    fn custom_suffix_is_written_and_validated() {+        let t = step_outjob_text(&json!({"suffixType": "custom", "suffix": "_A", "holes": false})).unwrap();+        assert!(t.contains("ComponentSuffixType=2|ComponentSuffix=_A|"));+        assert!(t.contains("IncludeElectricalPadHoles=False"));+        assert!(step_outjob_text(&json!({"suffixType": "custom"})).is_err());+        assert!(step_outjob_text(&json!({"suffixType": "custom", "suffix": "a|b"})).is_err());+        assert!(step_outjob_text(&json!({"suffixType": "designator"})).is_err());+    }+}