zenitel-client 0.1.0

package/dist/client.js

@@ -0,0 +1,709 @@
+/**
+ * ZenitelClient — HTTP scraper for Zenitel intercom web UI
+ *
+ * All methods use the goform endpoints documented in the Zenitel wiki
+ * and confirmed against a real TCIV-2+ (FW 9.2.3.0) at 192.168.1.143.
+ *
+ * Auth: HTTP Basic Auth (admin/alphaadmin by default).
+ * All goform endpoints use POST with form-urlencoded bodies.
+ */
+export class ZenitelClient {
+    opts;
+    baseUrl;
+    authHeader;
+    timeout;
+    constructor(opts) {
+        this.opts = opts;
+        const proto = opts.protocol ?? 'http';
+        this.baseUrl = `${proto}://${opts.host}`;
+        const user = opts.user ?? 'admin';
+        const pass = opts.password ?? 'alphaadmin';
+        this.authHeader = 'Basic ' + Buffer.from(`${user}:${pass}`).toString('base64');
+        this.timeout = opts.timeout ?? 5000;
+    }
+    // ── Connectivity ────────────────────────────────────────────────────────
+    /** Check if the Zenitel is reachable */
+    async isReachable() {
+        try {
+            const res = await this._fetch('/', 'GET', 2000);
+            return res.ok || res.status === 302;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ── Device Info ─────────────────────────────────────────────────────────
+    /** Scrape station info + header for full device data */
+    async getDeviceInfo() {
+        // 1. Get hidden fields from header (sigmode, frontboard, platform, hwtype)
+        const headerHtml = await this._html('/goform/zForm_header');
+        const sigmode = this._hidden(headerHtml, 'global_sigmode') || 'sip';
+        const frontboard = this._hidden(headerHtml, 'global_frontboard') || '';
+        const platform = this._hidden(headerHtml, 'global_platform') || '';
+        const hwtype = this._hidden(headerHtml, 'global_hwtype') || '';
+        // 2. Get station info table
+        const infoHtml = await this._html('/goform/zForm_stn_info');
+        // Parse the info table — rows are <td class='header_left'>Label:</td><td>Value</td>
+        const field = (label) => {
+            const re = new RegExp(`header_left'>\\s*${label}[:\\s]*</td>\\s*<td[^>]*>([^<]+)`, 'i');
+            return infoHtml.match(re)?.[1]?.trim() ?? '';
+        };
+        // Model is in the <h2> tag: "TCIV-2+ Information"
+        const modelMatch = infoHtml.match(/<h2>([^<]+)\s+Information/i);
+        const model = modelMatch?.[1]?.trim() ?? '';
+        // SIP domain includes registration status: "domain.com, Registered - ..."
+        const sipDomainRaw = field('Server Domain \\(SIP\\)');
+        const sipDomain = sipDomainRaw.split(',')[0]?.trim();
+        const sipRegistered = sipDomainRaw.toLowerCase().includes('registered');
+        // 3. Check if webcall is enabled
+        const webcallHtml = await this._html('/goform/zForm_webcall');
+        const webcallEnabled = webcallHtml.includes('checked');
+        return {
+            model,
+            firmware: field('Software Version'),
+            mac: field('MAC Address'),
+            ip: field('IP Address') || this.opts.host,
+            hostname: field('Name'),
+            serialNumber: field('Serial Number'),
+            hardwareType: hwtype,
+            mode: sigmode,
+            hasCamera: frontboard === 'video',
+            sipDomain,
+            sipRegistered,
+            sipNumber: field('Number \\(SIP ID\\)'),
+            outboundProxy: field('Outbound Proxy'),
+            uptime: field('Uptime'),
+            webcallEnabled,
+            platform,
+            systemModelName: field('System Model Name'),
+        };
+    }
+    // ── Webcall API ─────────────────────────────────────────────────────────
+    /** Place a call to a number/SIP URI */
+    async placeCall(number) {
+        await this._post('/goform/zForm_webcall', {
+            webcall: number,
+            message: 'PLACE CALL',
+        });
+    }
+    /** Stop the current call */
+    async stopCall() {
+        await this._post('/goform/zForm_webcall', { message: 'STOP' });
+    }
+    /** Answer an incoming call */
+    async answerCall() {
+        await this._post('/goform/zForm_webcall', { message: 'ANSWER' });
+    }
+    /** Get current call status by scraping the webcall page */
+    async getCallStatus() {
+        const html = await this._html('/goform/zForm_webcall');
+        const match = html.match(/Call status:<\/td>\s*<td>(\w+)/i);
+        return match?.[1] ?? 'Idle';
+    }
+    // ── Relay / Door Control ────────────────────────────────────────────────
+    /** Activate a relay (default: relay1, 3 seconds) */
+    async activateRelay(opts) {
+        const body = {
+            activate: 'ACTIVATE',
+            relayId: opts?.relayId ?? 'relay1',
+        };
+        if (opts?.timer !== undefined) {
+            body.relaytimer = String(opts.timer);
+        }
+        await this._post('/goform/zForm_webcall', body);
+    }
+    /** Deactivate a relay */
+    async deactivateRelay(relayId = 'relay1') {
+        await this._post('/goform/zForm_webcall', {
+            deactivate: 'DEACTIVATE',
+            relayId,
+        });
+    }
+    /** Get status of all relays by scraping the webcall page */
+    async getRelayStatus() {
+        const html = await this._html('/goform/zForm_webcall');
+        const parse = (label) => {
+            const re = new RegExp(`${label} status:</td>\\s*<td>(\\w+)`, 'i');
+            const m = html.match(re);
+            return m?.[1] === 'Activated' ? 'Activated' : 'Deactivated';
+        };
+        return {
+            relay1: parse('Relay 1'),
+            gpio1: parse('Output 1'),
+            gpio2: parse('Output 2'),
+            gpio3: parse('Output 3'),
+            gpio4: parse('Output 4'),
+            gpio5: parse('Output 5'),
+            gpio6: parse('Output 6'),
+        };
+    }
+    // ── Video ───────────────────────────────────────────────────────────────
+    /** Get the MJPG stream URL (port 80, same as web UI — confirmed on TCIV-2+) */
+    getMJPGUrl() {
+        return `http://${this.opts.host}/mjpg/video.mjpg`;
+    }
+    /** Get RTSP stream URL */
+    getRTSPUrl() {
+        return `rtsp://${this.opts.host}:554/1/RTSP`;
+    }
+    /** Get auth credentials for MJPG (for Electron protocol handler) */
+    getVideoAuth() {
+        return {
+            user: this.opts.user ?? 'admin',
+            password: this.opts.password ?? 'alphaadmin',
+        };
+    }
+    // ── SIP Configuration ──────────────────────────────────────────────────
+    // All fields from POST /goform/zForm_save_changes (confirmed on FW 9.2.3.0)
+    //
+    // Field map (HTML name → SIPConfig key):
+    //   sip_nick        → displayName
+    //   sip_id          → directoryNumber
+    //   sip_domain      → domain
+    //   sip_auth_user   → authUsername
+    //   sip_auth_pwd    → authPassword
+    //   sip_ppa         → outboundProxy (address)
+    //   sip_ppp         → outboundProxy (port)
+    //   sip_outbound_transport → transport
+    /** Read current SIP config by scraping the form fields */
+    async getSIPConfig() {
+        const html = await this._html('/goform/zForm_sip_configuration');
+        const input = (name) => {
+            const re = new RegExp(`name=${name}\\s+value="([^"]*)"`, 'i');
+            return html.match(re)?.[1] ?? '';
+        };
+        const select = (name) => {
+            const re = new RegExp(`name=${name}[^>]*>([\\s\\S]*?)</select>`, 'i');
+            const block = html.match(re)?.[1] ?? '';
+            const sel = block.match(/SELECTED\s+value='([^']*)'/i);
+            return sel?.[1] ?? '';
+        };
+        return {
+            displayName: input('sip_nick'),
+            directoryNumber: input('sip_id'),
+            domain: input('sip_domain'),
+            authUsername: input('sip_auth_user'),
+            authPassword: input('sip_auth_pwd'),
+            outboundProxy: input('sip_ppa'),
+            transport: select('sip_outbound_transport'),
+        };
+    }
+    /** Write SIP config via POST to zForm_save_changes */
+    async setSIPConfig(config) {
+        const fields = {};
+        if (config.displayName !== undefined)
+            fields.sip_nick = config.displayName;
+        if (config.directoryNumber !== undefined)
+            fields.sip_id = config.directoryNumber;
+        if (config.domain !== undefined)
+            fields.sip_domain = config.domain;
+        if (config.authUsername !== undefined)
+            fields.sip_auth_user = config.authUsername;
+        if (config.authPassword !== undefined)
+            fields.sip_auth_pwd = config.authPassword;
+        if (config.outboundProxy !== undefined)
+            fields.sip_ppa = config.outboundProxy;
+        if (config.transport !== undefined)
+            fields.sip_outbound_transport = config.transport.toUpperCase();
+        fields.save_changes = 'Save';
+        await this._post('/goform/zForm_save_changes', fields);
+    }
+    // ── Webcall Enable/Disable ─────────────────────────────────────────────
+    /** Enable webcall + relay HTTP API (required for FW ≥4.11.3.1) */
+    async enableWebcall() {
+        await this._post('/goform/zForm_webcall', {
+            enable_wc_r_node: 'on',
+            savewcr: 'Save',
+        });
+    }
+    /** Disable webcall + relay HTTP API */
+    async disableWebcall() {
+        await this._post('/goform/zForm_webcall', {
+            savewcr: 'Save',
+            // checkbox not sent = disabled
+        });
+    }
+    // ── Direct Access Key (DAK) — call button config ──────────────────────
+    /**
+     * Set the DAK (call button) to dial a specific SIP address.
+     * Button index 0 = physical button 1 on the intercom.
+     * @param sipAddress - Full SIP address, e.g. "portia-xxxx@sip.twilio.com"
+     * @param buttonIndex - DAK button index (default 0 = Button 1)
+     */
+    async setDAK(sipAddress, buttonIndex = 0) {
+        await this._post('/goform/zForm_speeddial_configuration_basic_auth', {
+            [`dak_fun${buttonIndex}`]: '0', // 0 = normal call
+            [`dak_value${buttonIndex}`]: sipAddress,
+            [`dak_in_call_func${buttonIndex}`]: '5', // 5 = End Call on button press during call
+            message: 'SAVE',
+        });
+    }
+    /** Read the current DAK value for a button */
+    async getDAK(buttonIndex = 0) {
+        const res = await this._fetch('/goform/zForm_speeddial_configuration_basic_auth');
+        const html = await res.text();
+        const match = html.match(new RegExp(`name='dak_value${buttonIndex}'[^>]*value='([^']*)'`));
+        return match?.[1] || '';
+    }
+    // ── Config Backup / Restore ────────────────────────────────────────────
+    /** Download complete config as tar.gz binary */
+    async downloadConfig() {
+        const res = await this._fetch('/ipst_config.tar.gz');
+        if (!res.ok)
+            throw new Error(`Download config failed: HTTP ${res.status}`);
+        const ab = await res.arrayBuffer();
+        return Buffer.from(ab);
+    }
+    /** Upload config tar.gz (triggers restore on reboot) */
+    async uploadConfig(tarGz) {
+        // The form uses multipart/form-data with field name "binary"
+        const boundary = '----PortiaUpload' + Date.now();
+        const header = `--${boundary}\r\nContent-Disposition: form-data; name="binary"; filename="ipst_config.tar.gz"\r\nContent-Type: application/gzip\r\n\r\n`;
+        const submit = `\r\n--${boundary}\r\nContent-Disposition: form-data; name="WebRestore"\r\n\r\nUPLOAD\r\n--${boundary}--\r\n`;
+        const body = Buffer.concat([
+            Buffer.from(header),
+            tarGz,
+            Buffer.from(submit),
+        ]);
+        await this._fetch('/goform/zForm_config_backup', 'POST', 30000, body.toString('binary'), `multipart/form-data; boundary=${boundary}`);
+    }
+    // ── DAK (Call Button) Configuration ─────────────────────────────────────
+    // The DAK (Direct Access Key) controls what number the intercom calls
+    // when someone presses the call button. Stored in ipst_config.xml.
+    //
+    // Flow: download backup → modify XML → re-upload → reboot
+    //
+    // XML structure:
+    //   <dak1><fun>0</fun><val>222@domain.sip.twilio.com</val>...</dak1>
+    /** Read current DAK1 value from the config backup */
+    async readDAK() {
+        const backup = await this.downloadConfig();
+        const xml = await this._extractXmlFromTarGz(backup);
+        const match = xml.match(/<dak1>[\s\S]*?<val>([^<]*)<\/val>/);
+        const raw = match?.[1] ?? '';
+        const [number, domain] = raw.includes('@') ? raw.split('@') : [raw, ''];
+        return { number, domain, raw };
+    }
+    /**
+     * Configure the call button (DAK1) to dial a specific number.
+     * Downloads backup, modifies XML, re-uploads, optionally reboots.
+     *
+     * @param number - The SIP number to dial (e.g. "portia-ae3c")
+     * @param domain - SIP domain (auto-detected from current config if omitted)
+     * @param autoReboot - Reboot after upload (default: true)
+     */
+    async configureCallButton(number, domain, autoReboot = true) {
+        // 1. Get current SIP domain if not provided
+        if (!domain) {
+            const sip = await this.getSIPConfig();
+            domain = sip.domain;
+        }
+        const dialValue = domain ? `${number}@${domain}` : number;
+        // 2. Download current config
+        const backup = await this.downloadConfig();
+        // 3. Extract, modify, re-pack
+        const modified = await this._modifyTarGzXml(backup, (xml) => {
+            // Replace DAK1 value
+            return xml.replace(/(<dak1>[\s\S]*?<val>)[^<]*(<\/val>)/, `$1${dialValue}$2`);
+        });
+        // 4. Upload modified config
+        await this.uploadConfig(modified);
+        // 5. Reboot to apply
+        if (autoReboot) {
+            await this.reboot();
+        }
+    }
+    // ── Full Provisioning ──────────────────────────────────────────────────
+    // One-shot setup for a factory-reset Zenitel. Configures everything
+    // in a single backup → modify XML → upload → reboot cycle.
+    //
+    // XML fields modified:
+    //   <sip_nick>       → stationName
+    //   <sip_id>         → stationName
+    //   <sip_domain>     → sipDomain
+    //   <sip_auth_user>  → sipAuthUser
+    //   <sip_auth_password> → sipAuthPassword
+    //   <sip_outbound_transport> → sipTransport
+    //   <dak1><val>      → agentNumber@sipDomain
+    //   <enable_wc_r>    → 1 (webcall enabled)
+    //   <auto_answer_mode> → 1 (auto-answer for AI)
+    /**
+     * Provision a factory-reset Zenitel in one operation.
+     * Downloads config, modifies all SIP + DAK + webcall fields in XML,
+     * uploads, and reboots. Device will be fully configured after ~30s.
+     */
+    async provisionDevice(config) {
+        const proxy = config.sipProxy ?? config.sipDomain;
+        const name = config.stationName ?? config.agentNumber;
+        const transport = config.sipTransport ?? 'UDP';
+        const webcall = config.enableWebcall !== false ? '1' : '0';
+        const autoAnswer = config.autoAnswer !== false ? '1' : '0';
+        const dakValue = `${config.agentNumber}@${config.sipDomain}`;
+        // 1. Download current config backup
+        const backup = await this.downloadConfig();
+        // 2. Modify all fields in ipst_config.xml
+        const modified = await this._modifyTarGzXml(backup, (xml) => {
+            return xml
+                // SIP identity
+                .replace(/(<sip_nick>)[^<]*(<\/sip_nick>)/, `$1${name}$2`)
+                .replace(/(<sip_id>)[^<]*(<\/sip_id>)/, `$1${name}$2`)
+                // SIP server
+                .replace(/(<sip_domain>)[^<]*(<\/sip_domain>)/, `$1${config.sipDomain}$2`)
+                .replace(/(<sip_auth_user>)[^<]*(<\/sip_auth_user>)/, `$1${config.sipAuthUser}$2`)
+                .replace(/(<sip_auth_password>)[^<]*(<\/sip_auth_password>)/, `$1${config.sipAuthPassword}$2`)
+                .replace(/(<sip_outbound_transport>)[^<]*(<\/sip_outbound_transport>)/, `$1${transport}$2`)
+                // Outbound proxy (match first occurrence)
+                .replace(/(<sip_outbound_proxy_address>)[^<]*/, `$1${proxy}`)
+                // Call button → agent number
+                .replace(/(\<dak1\>[\s\S]*?\<val\>)[^<]*(\<\/val\>)/, `$1${dakValue}$2`)
+                // Enable webcall + relay API
+                .replace(/(<enable_wc_r>)[^<]*(<\/enable_wc_r>)/, `$1${webcall}$2`)
+                // Auto-answer (AI agent needs this)
+                .replace(/(<auto_answer_mode>)[^<]*(<\/auto_answer_mode>)/, `$1${autoAnswer}$2`);
+        });
+        // 3. Upload modified config
+        await this.uploadConfig(modified);
+        // 4. Reboot to apply
+        await this.reboot();
+    }
+    // ── Audio Settings ─────────────────────────────────────────────────────
+    // Full audio config via /goform/zForm_auto_config (AngularJS JSON endpoint).
+    // The POST expects the complete JSON — partial updates are not supported.
+    // Read → merge → write pattern required.
+    /** Get current audio settings (parsed from goform JSON) */
+    async getAudioSettings() {
+        const raw = await this.getAudioSettingsRaw();
+        return this._parseAudioJson(raw);
+    }
+    /**
+     * Update audio settings. Reads current config, deep-merges with the
+     * provided partial, and writes the complete JSON back.
+     *
+     * @example
+     * // Set speaker to +3 dB
+     * await z.setAudioSettings({ speaker: { gain: 3 } })
+     *
+     * // Enable DRC with 8 dBA gain
+     * await z.setAudioSettings({ drc: { enabled: true, gain: 8 } })
+     */
+    async setAudioSettings(partial) {
+        // 1. Read current raw JSON
+        const raw = await this.getAudioSettingsRaw();
+        // 2. Apply changes
+        const audio = raw.audio;
+        const outputs = audio.io.output_devices.output_device;
+        const speaker = outputs.find((d) => d.kid === 'internal_speaker');
+        const lineOut = outputs.find((d) => d.kid === 'line_out');
+        const mic = audio.io.input_devices.input_device[0];
+        const dsp = audio.lines.line[0].dsp;
+        if (partial.speaker && speaker) {
+            if (partial.speaker.gain !== undefined)
+                speaker.gain = partial.speaker.gain;
+            if (partial.speaker.overrideGain !== undefined)
+                speaker.override_gain = partial.speaker.overrideGain;
+        }
+        if (partial.lineOut && lineOut) {
+            if (partial.lineOut.gain !== undefined)
+                lineOut.gain = partial.lineOut.gain;
+            if (partial.lineOut.overrideGain !== undefined)
+                lineOut.override_gain = partial.lineOut.overrideGain;
+        }
+        if (partial.mic && mic) {
+            if (partial.mic.gain !== undefined)
+                mic.gain = partial.mic.gain;
+        }
+        if (partial.aec) {
+            if (partial.aec.enabled !== undefined)
+                dsp.aec.enable = partial.aec.enabled;
+            if (partial.aec.mode !== undefined)
+                dsp.aec.aec_mode = partial.aec.mode;
+        }
+        if (partial.anc) {
+            if (partial.anc.enabled !== undefined)
+                dsp.anc.enable = partial.anc.enabled;
+            if (partial.anc.mode !== undefined)
+                dsp.anc.anc_mode = partial.anc.mode;
+        }
+        if (partial.fess) {
+            if (partial.fess.enabled !== undefined)
+                dsp.fess.enable = partial.fess.enabled;
+            if (partial.fess.threshold !== undefined)
+                dsp.fess.gain = partial.fess.threshold;
+            if (partial.fess.delay !== undefined)
+                dsp.fess.delay = partial.fess.delay;
+        }
+        if (partial.drc) {
+            if (partial.drc.enabled !== undefined)
+                dsp.drc.enable = partial.drc.enabled;
+            if (partial.drc.gain !== undefined)
+                dsp.drc.gain = partial.drc.gain;
+        }
+        if (partial.avc) {
+            const avc = audio.avc;
+            const algo = avc.algorithm_avc || avc.algorithm;
+            if (partial.avc.enabled !== undefined)
+                avc.enable_avc = partial.avc.enabled;
+            if (partial.avc.digitalEnabled !== undefined)
+                avc.enable_davc = partial.avc.digitalEnabled;
+            if (algo) {
+                if (partial.avc.threshold !== undefined)
+                    algo.threshold = partial.avc.threshold;
+                if (partial.avc.upperThreshold !== undefined)
+                    algo.upper_threshold = partial.avc.upperThreshold;
+                if (partial.avc.attackRate !== undefined)
+                    algo.attack_rate = partial.avc.attackRate;
+                if (partial.avc.decayRate !== undefined)
+                    algo.decay_rate = partial.avc.decayRate;
+                if (partial.avc.hysteresis !== undefined)
+                    algo.hysteresis = partial.avc.hysteresis;
+                if (partial.avc.farEndLockoutTime !== undefined)
+                    algo.far_end_lockout_time = partial.avc.farEndLockoutTime;
+            }
+        }
+        if (partial.mode !== undefined)
+            audio.mode = partial.mode;
+        // 3. POST full JSON
+        const body = new URLSearchParams({ audio: JSON.stringify(raw) }).toString();
+        await this._fetch('/goform/zForm_auto_config', 'POST', undefined, body, 'application/x-www-form-urlencoded');
+    }
+    /** Get raw audio config JSON from the device (for backup/debug) */
+    async getAudioSettingsRaw() {
+        // The audio config page embeds JSON in an AngularJS scope.
+        // We fetch the page and extract the JSON from the script block.
+        const html = await this._html('/goform/zForm_audio_configuration');
+        // Strategy 1: Look for ng-init or inline JSON assignment
+        // The page typically has: $scope.audio = {...} or data in a form field
+        let jsonStr = '';
+        // Try to extract from a script block: audio = {...}
+        const scriptMatch = html.match(/audio\s*=\s*(\{[\s\S]*?\});\s*(?:\n|<\/script>)/)
+            || html.match(/ng-init=['"]\s*init\(([\s\S]*?)\)['"]/);
+        if (scriptMatch) {
+            jsonStr = scriptMatch[1];
+        }
+        else {
+            // Strategy 2: POST to get the JSON directly (some FW versions)
+            const res = await this._fetch('/goform/zForm_auto_config', 'GET');
+            const text = await res.text();
+            // The response may be JSON directly
+            try {
+                const parsed = JSON.parse(text);
+                if (parsed.audio)
+                    return parsed;
+            }
+            catch { /* not JSON */ }
+            // Strategy 3: Look for hidden input or textarea with JSON
+            const inputMatch = html.match(/value='(\{&quot;audio&quot;[^']*)'/);
+            if (inputMatch) {
+                jsonStr = inputMatch[1]
+                    .replace(/&quot;/g, '"')
+                    .replace(/&amp;/g, '&');
+            }
+        }
+        if (!jsonStr) {
+            throw new Error('Could not extract audio config JSON from device. Firmware may not support this endpoint.');
+        }
+        return JSON.parse(jsonStr);
+    }
+    /** Parse the raw goform JSON into our typed AudioSettings */
+    _parseAudioJson(raw) {
+        const audio = raw.audio;
+        const outputs = audio.io.output_devices.output_device;
+        const speaker = outputs.find((d) => d.kid === 'internal_speaker') || outputs[1];
+        const lineOut = outputs.find((d) => d.kid === 'line_out') || outputs[0];
+        const mic = audio.io.input_devices.input_device[0];
+        const dsp = audio.lines.line[0].dsp;
+        const avc = audio.avc;
+        const algo = avc.algorithm_avc || avc.algorithm || {};
+        return {
+            speaker: {
+                kid: speaker.kid,
+                gain: speaker.gain,
+                overrideGain: speaker.override_gain,
+                signalSource: speaker.signal_source,
+                outputType: speaker.output_type,
+            },
+            lineOut: {
+                kid: lineOut.kid,
+                gain: lineOut.gain,
+                overrideGain: lineOut.override_gain,
+                signalSource: lineOut.signal_source,
+                outputType: lineOut.output_type,
+            },
+            mic: {
+                kid: mic.kid,
+                gain: mic.gain,
+                inputType: mic.input_type,
+            },
+            aec: {
+                enabled: dsp.aec.enable,
+                mode: dsp.aec.aec_mode,
+            },
+            anc: {
+                enabled: dsp.anc.enable,
+                mode: dsp.anc.anc_mode,
+            },
+            fess: {
+                enabled: dsp.fess.enable,
+                threshold: dsp.fess.gain,
+                delay: dsp.fess.delay,
+            },
+            drc: {
+                enabled: dsp.drc.enable,
+                gain: dsp.drc.gain,
+            },
+            avc: {
+                enabled: avc.enable_avc,
+                digitalEnabled: avc.enable_davc,
+                threshold: algo.threshold ?? 55,
+                upperThreshold: algo.upper_threshold ?? 100,
+                attackRate: algo.attack_rate ?? 10,
+                decayRate: algo.decay_rate ?? 10,
+                hysteresis: algo.hysteresis ?? 3,
+                farEndLockoutTime: algo.far_end_lockout_time ?? 1,
+            },
+            mode: audio.mode,
+        };
+    }
+    // ── Tar.gz helpers (Node built-in zlib, no deps) ──────────────────────
+    async _extractXmlFromTarGz(tarGz) {
+        const { gunzipSync } = await import('node:zlib');
+        const tar = gunzipSync(tarGz);
+        // Simple tar parser — find ipst_config.xml
+        return this._findFileInTar(tar, 'ipst_config.xml');
+    }
+    async _modifyTarGzXml(tarGz, modify) {
+        const { gunzipSync, gzipSync } = await import('node:zlib');
+        const tar = gunzipSync(tarGz);
+        // Find and modify ipst_config.xml in the tar
+        const modified = this._replaceFileInTar(tar, 'ipst_config.xml', modify);
+        return gzipSync(modified);
+    }
+    /**
+     * Minimal tar file finder — tar format:
+     * Each file: 512-byte header + data padded to 512 bytes
+     * Header: name at offset 0 (100 bytes), size at offset 124 (12 bytes, octal)
+     */
+    _findFileInTar(tar, filename) {
+        let offset = 0;
+        while (offset < tar.length - 512) {
+            const header = tar.subarray(offset, offset + 512);
+            const name = header.subarray(0, 100).toString('utf8').replace(/\0/g, '');
+            if (!name)
+                break; // End of tar
+            const sizeStr = header.subarray(124, 136).toString('utf8').replace(/\0/g, '').trim();
+            const size = parseInt(sizeStr, 8) || 0;
+            if (name.includes(filename)) {
+                return tar.subarray(offset + 512, offset + 512 + size).toString('utf8');
+            }
+            // Next entry: header (512) + data padded to 512
+            offset += 512 + Math.ceil(size / 512) * 512;
+        }
+        throw new Error(`File ${filename} not found in tar`);
+    }
+    /**
+     * Replace a file's content inside a tar buffer.
+     * If the new content is a different size, we rebuild the entry.
+     */
+    _replaceFileInTar(tar, filename, modify) {
+        const chunks = [];
+        let offset = 0;
+        let replaced = false;
+        while (offset < tar.length - 512) {
+            const header = Buffer.from(tar.subarray(offset, offset + 512));
+            const name = header.subarray(0, 100).toString('utf8').replace(/\0/g, '');
+            if (!name) {
+                // Copy remaining (end-of-archive markers)
+                chunks.push(Buffer.from(tar.subarray(offset)));
+                break;
+            }
+            const sizeStr = header.subarray(124, 136).toString('utf8').replace(/\0/g, '').trim();
+            const size = parseInt(sizeStr, 8) || 0;
+            const dataStart = offset + 512;
+            const paddedSize = Math.ceil(size / 512) * 512;
+            if (name.includes(filename) && !replaced) {
+                const original = tar.subarray(dataStart, dataStart + size).toString('utf8');
+                const modified = modify(original);
+                const newData = Buffer.from(modified, 'utf8');
+                const newPaddedSize = Math.ceil(newData.length / 512) * 512;
+                // Update size in header (octal, 11 chars + null)
+                const newSizeStr = newData.length.toString(8).padStart(11, '0') + '\0';
+                Buffer.from(newSizeStr).copy(header, 124);
+                // Recalculate header checksum
+                this._updateTarChecksum(header);
+                chunks.push(header);
+                chunks.push(newData);
+                // Pad to 512 boundary
+                if (newPaddedSize > newData.length) {
+                    chunks.push(Buffer.alloc(newPaddedSize - newData.length));
+                }
+                replaced = true;
+            }
+            else {
+                chunks.push(Buffer.from(tar.subarray(offset, dataStart + paddedSize)));
+            }
+            offset = dataStart + paddedSize;
+        }
+        return Buffer.concat(chunks);
+    }
+    /** Recalculate tar header checksum (sum of all header bytes with checksum field as spaces) */
+    _updateTarChecksum(header) {
+        // Clear checksum field (offset 148, 8 bytes) with spaces
+        for (let i = 148; i < 156; i++)
+            header[i] = 0x20;
+        // Sum all bytes
+        let sum = 0;
+        for (let i = 0; i < 512; i++)
+            sum += header[i];
+        // Write checksum (6 octal digits + null + space)
+        const checksumStr = sum.toString(8).padStart(6, '0') + '\0 ';
+        Buffer.from(checksumStr).copy(header, 148);
+    }
+    // ── Reboot ─────────────────────────────────────────────────────────────
+    /** Reboot the Zenitel (required after config changes) */
+    async reboot() {
+        try {
+            await this._post('/goform/zForm_system_prefs', { reboot: 'Reboot' });
+        }
+        catch {
+            // May disconnect before response — that's expected
+        }
+    }
+    // ── Internal helpers ────────────────────────────────────────────────────
+    async _fetch(path, method = 'GET', timeout, body, contentType) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeout ?? this.timeout);
+        try {
+            const headers = {
+                Authorization: this.authHeader,
+            };
+            if (contentType)
+                headers['Content-Type'] = contentType;
+            return await fetch(`${this.baseUrl}${path}`, {
+                method,
+                headers,
+                body,
+                signal: controller.signal,
+                redirect: 'follow',
+            });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async _html(path) {
+        const res = await this._fetch(path);
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status} from ${path}`);
+        return res.text();
+    }
+    async _post(path, fields) {
+        const body = new URLSearchParams(fields).toString();
+        const res = await this._fetch(path, 'POST', undefined, body, 'application/x-www-form-urlencoded');
+        return res.text();
+    }
+    /** Extract value from <input type=hidden id='name' value='val'> */
+    _hidden(html, id) {
+        const re = new RegExp(`id='${id}'\\s+value='([^']*)'`, 'i');
+        return html.match(re)?.[1] ?? '';
+    }
+}