bambu-printer-mcp 1.1.32 → 1.1.34

package/dist/slicer/orca-profile-cache.js

@@ -0,0 +1,460 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { profileJsonFiles } from './profile-files.js';
+// OrcaSlicer 14da40e3a7b82aa8fc88593c2cf880e66560028f:
+// PresetCacheFormat.{hpp,cpp}, Config.hpp, Config.cpp::save_to_json,
+// Preset.hpp::VendorProfile and Semver.hpp. Only the named v2 format is read;
+// the old ordinal-based cache must never be interpreted as this format.
+const MAX_CACHE_BYTES = 64 * 1024 * 1024;
+const MAX_ITEMS = 100000;
+const VECTOR = 0x4000;
+// Nullable declarations in the same pinned PrintConfig.cpp; unknown nil values fail closed.
+const NULLABLE_KEYS = new Set([
+    "bridge_acceleration",
+    "bridge_speed",
+    "default_acceleration",
+    "default_jerk",
+    "default_junction_deviation",
+    "deretract_speed_extruder_change",
+    "enable_overhang_speed",
+    "extruder_max_nozzle_count",
+    "filament_adaptive_volumetric_speed",
+    "filament_cooling_before_tower",
+    "filament_deretraction_speed",
+    "filament_flow_ratio",
+    "filament_flush_temp",
+    "filament_flush_temp_fast",
+    "filament_flush_volumetric_speed",
+    "filament_ironing_flow",
+    "filament_ironing_inset",
+    "filament_ironing_spacing",
+    "filament_ironing_speed",
+    "filament_long_retractions_when_cut",
+    "filament_pre_cooling_temperature",
+    "filament_pre_cooling_temperature_nc",
+    "filament_preheat_temperature_delta",
+    "filament_ramming_travel_time",
+    "filament_ramming_travel_time_nc",
+    "filament_ramming_volumetric_speed",
+    "filament_ramming_volumetric_speed_nc",
+    "filament_retract_after_wipe",
+    "filament_retract_before_wipe",
+    "filament_retract_length_nc",
+    "filament_retract_length_toolchange",
+    "filament_retract_lift_above",
+    "filament_retract_lift_below",
+    "filament_retract_lift_enforce",
+    "filament_retract_restart_extra",
+    "filament_retract_restart_extra_toolchange",
+    "filament_retract_when_changing_layer",
+    "filament_retraction_distances_when_cut",
+    "filament_retraction_length",
+    "filament_retraction_minimum_travel",
+    "filament_retraction_speed",
+    "filament_wipe",
+    "filament_wipe_distance",
+    "filament_z_hop",
+    "filament_z_hop_types",
+    "gap_infill_speed",
+    "hotend_cooling_rate",
+    "hotend_heating_rate",
+    "infill_jerk",
+    "initial_layer_acceleration",
+    "initial_layer_infill_speed",
+    "initial_layer_jerk",
+    "initial_layer_speed",
+    "initial_layer_travel_acceleration",
+    "initial_layer_travel_jerk",
+    "initial_layer_travel_speed",
+    "inner_wall_acceleration",
+    "inner_wall_jerk",
+    "inner_wall_speed",
+    "internal_bridge_speed",
+    "internal_solid_infill_acceleration",
+    "internal_solid_infill_speed",
+    "long_retractions_when_ec",
+    "nozzle_flush_dataset",
+    "nozzle_type",
+    "nozzle_volume",
+    "outer_wall_acceleration",
+    "outer_wall_jerk",
+    "outer_wall_speed",
+    "overhang_1_4_speed",
+    "overhang_2_4_speed",
+    "overhang_3_4_speed",
+    "overhang_4_4_speed",
+    "retraction_distances_when_ec",
+    "slowdown_for_curled_perimeters",
+    "small_perimeter_speed",
+    "small_perimeter_threshold",
+    "sparse_infill_acceleration",
+    "sparse_infill_speed",
+    "support_interface_speed",
+    "support_speed",
+    "top_solid_infill_flow_ratio",
+    "top_surface_acceleration",
+    "top_surface_jerk",
+    "top_surface_speed",
+    "travel_acceleration",
+    "travel_jerk",
+    "travel_speed",
+    "travel_speed_z",
+]);
+const fail = (message) => { throw new Error(`Orca profile cache: ${message}`); };
+class Reader {
+    constructor(bytes) {
+        this.bytes = bytes;
+        this.offset = 0;
+    }
+    take(size) {
+        if (!Number.isSafeInteger(size) || size < 0 || size > this.bytes.length - this.offset)
+            fail('truncated or invalid length');
+        const result = this.bytes.subarray(this.offset, this.offset + size);
+        this.offset += size;
+        return result;
+    }
+    u8() { return this.take(1).readUInt8(); }
+    u16() { return this.take(2).readUInt16LE(); }
+    u32() { return this.take(4).readUInt32LE(); }
+    i32() { return this.take(4).readInt32LE(); }
+    u64() {
+        const value = this.take(8).readBigUInt64LE();
+        if (value > BigInt(Number.MAX_SAFE_INTEGER))
+            fail('length exceeds safe range');
+        return Number(value);
+    }
+    count() {
+        const n = this.u64();
+        if (n > MAX_ITEMS || n > this.bytes.length - this.offset)
+            fail('collection length out of bounds');
+        return n;
+    }
+    string() {
+        const raw = this.take(this.u64());
+        try {
+            return new TextDecoder('utf-8', { fatal: true }).decode(raw);
+        }
+        catch {
+            return fail('invalid UTF-8');
+        }
+    }
+    strings() { return this.array(() => this.string()); }
+    array(read) { return Array.from({ length: this.count() }, read); }
+    double() { return this.take(8).readDoubleLE(); }
+}
+function crc32(bytes) {
+    let crc = 0xffffffff;
+    for (const byte of bytes) {
+        crc ^= byte;
+        for (let bit = 0; bit < 8; bit++)
+            crc = (crc >>> 1) ^ ((crc & 1) ? 0xedb88320 : 0);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+/** Read raw source diffs, not merged profiles: inheritance/includes still use the shared resolver. */
+export function decodeOrcaBblCache(bytes) {
+    if (bytes.length < 20 || bytes.length > MAX_CACHE_BYTES)
+        fail('file size out of bounds');
+    const header = new Reader(bytes);
+    if (header.u32() !== 0x4f52435a)
+        fail('unknown magic');
+    if (header.u32() !== 2)
+        fail('unsupported format version');
+    if (header.u64() !== bytes.length - 20)
+        fail('body size does not match file');
+    const expectedCrc = header.u32();
+    const body = bytes.subarray(20);
+    if (crc32(body) !== expectedCrc)
+        fail('CRC checksum mismatch');
+    const r = new Reader(body);
+    if (r.u32() !== 2)
+        fail('unsupported body version');
+    if (r.string() !== 'BBL')
+        fail('expected BBL vendor');
+    const version = r.string();
+    if (!/^\d+(?:\.\d+){2,3}(?:[-+][\w.-]+)?$/.test(version))
+        fail('invalid vendor version');
+    const keys = r.strings();
+    const types = r.array(() => r.u16());
+    const enums = r.strings();
+    if (keys.length !== types.length || keys.length > 65535 || enums.length > 65535 || enums[0] !== '')
+        fail('invalid option dictionary');
+    if (new Set(keys).size !== keys.length || keys.some(key => !key || ['__proto__', 'constructor', 'prototype'].includes(key)))
+        fail('invalid option name');
+    // VendorMap is std::map<string, VendorProfile>, serialized by cereal in declaration order.
+    const modelsMetadata = [];
+    const vendors = r.count();
+    let ownVendor = false;
+    let vendorProfileVersion = "";
+    for (let i = 0; i < vendors; i++) {
+        const mapKey = r.string();
+        r.string(); // display name
+        const id = r.string();
+        const profileVersion = r.string();
+        if (mapKey === 'BBL' && id === 'BBL' && profileVersion) {
+            ownVendor = true;
+            vendorProfileVersion = profileVersion;
+        }
+        r.string();
+        r.string(); // update/changelog URLs
+        const models = r.count();
+        for (let j = 0; j < models; j++) {
+            const modelId = r.string();
+            const modelName = r.string();
+            r.string();
+            r.u8();
+            r.string();
+            r.strings();
+            r.strings();
+            const unsupportedBeds = r.strings();
+            r.string();
+            r.string();
+            const imageBedType = r.string();
+            for (let k = 0; k < 6; k++)
+                r.string();
+            if (mapKey === 'BBL' && modelName) {
+                modelsMetadata.push({ subPath: `machine/__models__/${encodeURIComponent(modelId)}.json`,
+                    data: { name: modelName, type: 'machine_model',
+                        ...(imageBedType ? { image_bed_type: imageBedType } : {}),
+                        ...(unsupportedBeds.length ? { not_support_bed_type: unsupportedBeds.join(';') } : {}) } });
+            }
+        }
+        r.strings();
+        r.strings(); // default filament/material sets
+    }
+    if (!ownVendor)
+        fail('cache does not carry its BBL vendor profile');
+    const number = (value, nullable = false) => {
+        if (nullable && Number.isNaN(value))
+            return 'nil';
+        if (!Number.isFinite(value))
+            return fail('non-finite numeric option');
+        return String(value);
+    };
+    const point = (dimension, separator) => Array.from({ length: dimension }, () => number(r.double())).join(separator);
+    const scalar = (type, vector) => {
+        switch (type) {
+            case 1: return number(r.double(), vector);
+            case 2: {
+                const n = r.i32();
+                return vector && n === 2147483647 ? 'nil' : String(n);
+            }
+            case 3: return r.string();
+            case 4: {
+                const n = r.double();
+                return Number.isNaN(n) && vector ? 'nil' : `${number(n)}%`;
+            }
+            case 5: {
+                const n = r.double();
+                const percent = r.u8();
+                if (percent > 1)
+                    return fail('invalid percent flag');
+                return Number.isNaN(n) && vector ? 'nil' : number(n) + (percent ? '%' : '');
+            }
+            case 6: return point(2, vector ? 'x' : ',');
+            case 7: return point(3, ',');
+            case 8: {
+                const n = r.u8();
+                if (vector && n === 255)
+                    return 'nil';
+                if (n > 1)
+                    return fail('invalid boolean option');
+                return String(n);
+            }
+            default: return fail(`unsupported option type ${type}`);
+        }
+    };
+    const option = (type) => {
+        if (type === 9 || type === VECTOR + 9) {
+            const count = r.u32();
+            if (count > MAX_ITEMS || (type === 9 && count !== 1))
+                fail('invalid enum count');
+            const values = Array.from({ length: count }, () => {
+                const index = r.u16();
+                if (index >= enums.length)
+                    return fail('enum index out of bounds');
+                if (index !== 0)
+                    return enums[index];
+                const value = r.i32();
+                if (type === VECTOR + 9 && value === 2147483647)
+                    return 'nil';
+                return fail('unnamed enum cannot be exported safely');
+            });
+            return type === 9 ? values[0] : values;
+        }
+        if (type === VECTOR + 10)
+            return r.array(() => r.array(() => point(2, 'x')).join(','));
+        if (type === VECTOR + 11)
+            return r.array(() => r.array(() => String(r.i32())).join(','));
+        if (type & VECTOR)
+            return r.array(() => scalar(type - VECTOR, true));
+        return scalar(type, false);
+    };
+    const profiles = [...modelsMetadata];
+    const names = new Set(profiles.map(p => String(p.data.name)));
+    const paths = new Set(profiles.map(p => p.subPath.toLowerCase()));
+    for (const kind of ['process', 'filament', 'machine']) {
+        const count = r.u32();
+        if (count > MAX_ITEMS)
+            fail('preset count out of bounds');
+        for (let i = 0; i < count; i++) {
+            const name = r.string();
+            const subPath = r.string();
+            if (!name || names.has(name))
+                fail('duplicate/empty preset name');
+            const normalized = subPath.replace(/\\/g, '/');
+            if (!normalized.startsWith(`${kind}/`) || !normalized.endsWith('.json') || normalized.split('/').some(p => !p || p === '.' || p === '..') || normalized.includes(':') || paths.has(normalized.toLowerCase()))
+                fail('invalid or colliding preset path');
+            names.add(name);
+            paths.add(normalized.toLowerCase());
+            const data = Object.create(null);
+            const configCount = r.u32();
+            const seen = new Set();
+            if (configCount > keys.length)
+                fail('option count out of bounds');
+            for (let j = 0; j < configCount; j++) {
+                const key = r.u16();
+                if (key >= keys.length || seen.has(key))
+                    fail('invalid/duplicate option index');
+                seen.add(key);
+                const value = option(types[key]);
+                if (types[key] !== VECTOR + 3 && Array.isArray(value) && value.includes('nil') && !NULLABLE_KEYS.has(keys[key]))
+                    fail(`unexpected nil for ${keys[key]}`);
+                data[keys[key]] = value;
+            }
+            const inherits = r.string();
+            const includes = r.strings();
+            const description = r.string();
+            const instantiation = r.string();
+            const settingId = r.string();
+            const filamentId = r.string();
+            const renamed = r.strings();
+            Object.assign(data, { name, type: kind, from: 'system', version: vendorProfileVersion, instantiation, inherits });
+            if (includes.length)
+                data.include = includes;
+            if (description)
+                data.description = description;
+            if (settingId)
+                data.setting_id = settingId;
+            if (filamentId)
+                data.filament_id = filamentId;
+            if (renamed.length)
+                data.renamed_from = renamed.map(value => JSON.stringify(value)).join(';');
+            profiles.push({ subPath: normalized, data });
+        }
+    }
+    if (r.u64() !== 0)
+        fail('vendor cache records profile parse errors');
+    if (r.offset !== body.length)
+        fail('unexpected trailing cache data');
+    return profiles;
+}
+/** Expand only the selected installation's cache in the owning server's private temp directory. */
+export async function materializeOrcaProfilesRoot(profilesRoot, tempDir) {
+    if (profileJsonFiles(path.join(profilesRoot, 'BBL', 'machine')).length)
+        return profilesRoot;
+    const cachePath = path.join(profilesRoot, 'BBL.opc');
+    let stat;
+    try {
+        stat = await fs.stat(cachePath);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return profilesRoot;
+        throw error;
+    }
+    if (stat.size > MAX_CACHE_BYTES)
+        fail('file size out of bounds');
+    let cli;
+    try {
+        cli = await fs.readFile(path.join(profilesRoot, 'BBL', 'cli_config.json'));
+    }
+    catch {
+        return fail('selected installation is missing BBL/cli_config.json; update Orca or supply its exact matching profile tree');
+    }
+    const parsed = JSON.parse(cli.toString('utf8'));
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        fail('invalid BBL/cli_config.json');
+    const cache = await fs.readFile(cachePath);
+    const profiles = decodeOrcaBblCache(cache);
+    const digest = createHash('sha256').update(cache).update(cli).digest('hex');
+    const output = await fs.mkdtemp(path.join(tempDir, `orca-profiles-${digest.slice(0, 16)}-`));
+    try {
+        await fs.mkdir(path.join(output, 'BBL'), { recursive: true });
+        await fs.writeFile(path.join(output, 'BBL', 'cli_config.json'), cli, { flag: 'wx' });
+        await fs.writeFile(path.join(output, 'BBL.opc'), cache, { flag: 'wx' });
+        for (const profile of profiles) {
+            const file = path.join(output, 'BBL', profile.subPath);
+            await fs.mkdir(path.dirname(file), { recursive: true });
+            await fs.writeFile(file, JSON.stringify(profile.data), { flag: 'wx' });
+        }
+        return output;
+    }
+    catch (error) {
+        await fs.rm(output, { recursive: true, force: true });
+        throw error;
+    }
+}
+/** Orca v2 cache builds resolve User presets by loaded file identity, not just inherits. */
+export async function stageOrcaCliProfiles(profilesRoot, tempDir, bundle) {
+    const settings = bundle.settingsArg?.split(';') ?? [];
+    if (settings.length !== 2)
+        fail('complete machine and process settings are required');
+    const root = await fs.mkdtemp(path.join(tempDir, 'orca-cli-'));
+    try {
+        await fs.mkdir(path.join(root, 'system'));
+        await fs.copyFile(path.join(profilesRoot, 'BBL.opc'), path.join(root, 'system', 'BBL.opc'));
+        const profiles = decodeOrcaBblCache(await fs.readFile(path.join(profilesRoot, 'BBL.opc')));
+        const parents = new Set(profiles.map(p => `${p.data.type}:${p.data.name}`));
+        const version = profiles.find(p => p.data.type === 'machine')?.data.version;
+        if (typeof version !== 'string')
+            fail('missing vendor profile version');
+        const output = [];
+        const colours = [];
+        const extras = [];
+        for (const [index, file] of [...settings, ...bundle.filamentPaths].entries()) {
+            const kind = index === 0 ? 'machine' : index === 1 ? 'process' : 'filament';
+            const data = JSON.parse(await fs.readFile(file, 'utf8'));
+            if (kind === 'filament') {
+                const colour = Array.isArray(data.filament_colour) ? data.filament_colour[0] : undefined;
+                if (typeof colour !== 'string' || !/^#[0-9a-f]{6}(?:[0-9a-f]{2})?$/i.test(colour))
+                    fail('missing positional filament colour');
+                colours.push(colour);
+            }
+            if (kind === 'process') {
+                if (typeof data.curr_bed_type === 'string')
+                    extras.push('--curr-bed-type', data.curr_bed_type);
+                for (const key of ['wipe_tower_x', 'wipe_tower_y']) {
+                    if (data[key] === undefined)
+                        continue;
+                    const values = Array.isArray(data[key]) ? data[key] : [data[key]];
+                    if (!values.length || values.some(v => !Number.isFinite(Number(v))))
+                        fail('invalid saved tower position');
+                    extras.push(`--${key.replace(/_/g, '-')}`, values.join(','));
+                }
+            }
+            // The selected machine's system identity remains the validated cache leaf.
+            // A fully resolved custom process/filament may be a standalone User root.
+            if (!parents.has(`${kind}:${data.inherits}`)) {
+                if (kind === 'machine')
+                    fail('selected machine parent is absent from the exact cache');
+                delete data.inherits;
+            }
+            const digest = createHash('sha256').update(JSON.stringify(data)).digest('hex').slice(0, 16);
+            const name = `mcp_${kind}_${index}_${digest}`;
+            Object.assign(data, { name, from: 'User', version });
+            const directory = path.join(root, 'user', 'default', kind);
+            await fs.mkdir(directory, { recursive: true });
+            const staged = path.join(directory, `${name}.json`);
+            await fs.writeFile(staged, JSON.stringify(data), { flag: 'wx' });
+            output.push(staged);
+        }
+        return { settingsArg: output.slice(0, 2).join(';'), filamentPaths: output.slice(2),
+            extraArgs: ['--datadir', root, ...extras, '--filament-colour', colours.join(';')], dataDir: root };
+    }
+    catch (error) {
+        await fs.rm(root, { recursive: true, force: true });
+        throw error;
+    }
+}

package/dist/slicer/profile-flatten.js

@@ -674,7 +674,7 @@ export function detectProfilesRoot(slicerPath, slicerType = 'bambustudio') {
                     path.resolve(bin, '..', 'share', name, 'resources', 'profiles'),
                 ]),
             ];
-        const found = candidates.find(root => existsSync(path.join(root, 'BBL', 'machine')));
+        const found = candidates.find(root => (existsSync(path.join(root, 'BBL', 'machine')) || existsSync(path.join(root, 'BBL.opc'))));
         // Do not select another installation if this executable has no profile tree.
         // flattenForCli reports the missing tree and asks for BAMBU_PROFILES_ROOT.
         return found ?? candidates[0];

package/dist/stl/stl-manipulator.d.ts

@@ -114,6 +114,14 @@ export declare class STLManipulator extends EventEmitter {
      * Scale an STL model uniformly or along specific axes
      */
     scaleSTL(stlFilePath: string, scaleFactors: number | [number, number, number], progressCallback?: ProgressCallback): Promise<string>;
+    /**
+     * Apply slice_stl's scale and rotations to a copy of the mesh as OrcaSlicer's
+     * CLI would, about the model's centre. Orca adds each --rotate* to the
+     * object's Euler angles (ModelVolume::rotate), so the result rotates about X,
+     * then Y, then Z whatever the argument order, after scaling. The slicer then
+     * places the result on the plate.
+     */
+    private transformMeshForCli;
     /**
      * Rotate an STL model around specific axes
      */