zenitel-client 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { ZenitelClient } from './client.js';
+export { scanNetwork } from './scanner.js';
+export type { ZenitelClientOptions, ZenitelDevice, ScanOptions, DeviceInfo, RelayOptions, RelayStatus, CallStatus, SIPConfig, ProvisionConfig, AudioSettings, AudioOutputDevice, AudioInputDevice, AECSettings, ANCSettings, FESSSettings, DRCSettings, AVCSettings, } from './types.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { ZenitelClient } from './client.js';
+export { scanNetwork } from './scanner.js';

package/dist/scanner.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Network scanner — Discover Zenitel intercoms on the local network
+ *
+ * Strategy A: ARP table + OUI filter (MAC prefix 00:13:cb = Zenitel)
+ * Strategy B: HTTP probe with fingerprinting (zenitel.js in HTML)
+ *
+ * Both strategies run in parallel and results are merged by IP.
+ */
+import type { ZenitelDevice, ScanOptions } from './types.js';
+export declare function scanNetwork(opts?: ScanOptions): Promise<ZenitelDevice[]>;

package/dist/scanner.js

@@ -0,0 +1,198 @@
+/**
+ * Network scanner — Discover Zenitel intercoms on the local network
+ *
+ * Strategy A: ARP table + OUI filter (MAC prefix 00:13:cb = Zenitel)
+ * Strategy B: HTTP probe with fingerprinting (zenitel.js in HTML)
+ *
+ * Both strategies run in parallel and results are merged by IP.
+ */
+import { execFile } from 'node:child_process';
+import { platform } from 'node:os';
+import { networkInterfaces } from 'node:os';
+import { ZenitelClient } from './client.js';
+const ZENITEL_OUI = '00:13:cb';
+// ── Public API ────────────────────────────────────────────────────────────
+export async function scanNetwork(opts) {
+    const timeout = opts?.timeout ?? 5000;
+    const strategies = opts?.strategies ?? ['arp-oui', 'http-probe'];
+    const subnet = opts?.subnet ?? detectSubnet();
+    const results = new Map();
+    const tasks = [];
+    if (strategies.includes('arp-oui')) {
+        tasks.push(arpOuiScan().catch(() => []));
+    }
+    if (strategies.includes('http-probe') && subnet) {
+        tasks.push(httpProbeScan(subnet, timeout).catch(() => []));
+    }
+    const all = await Promise.all(tasks);
+    // Merge by IP (prefer entries with more data)
+    for (const batch of all) {
+        for (const dev of batch) {
+            const existing = results.get(dev.ip);
+            if (!existing || (!existing.model && dev.model)) {
+                results.set(dev.ip, { ...existing, ...dev });
+            }
+        }
+    }
+    return Array.from(results.values());
+}
+// ── Strategy A: ARP + OUI ────────────────────────────────────────────────
+async function arpOuiScan() {
+    const entries = await getArpTable();
+    const zenitels = entries.filter((e) => e.mac.toLowerCase().startsWith(ZENITEL_OUI));
+    // For each candidate, try to get device info
+    const results = await Promise.all(zenitels.map(async (entry) => {
+        const client = new ZenitelClient({ host: entry.ip, timeout: 3000 });
+        try {
+            const info = await client.getDeviceInfo();
+            return {
+                ip: entry.ip,
+                mac: entry.mac,
+                model: info.model,
+                firmware: info.firmware,
+                hasCamera: info.hasCamera,
+                hostname: info.hostname,
+                mode: info.mode,
+                serialNumber: info.serialNumber,
+                hardwareType: info.hardwareType,
+            };
+        }
+        catch {
+            // Device unreachable or auth failed — return basic info
+            return {
+                ip: entry.ip,
+                mac: entry.mac,
+                hasCamera: false,
+            };
+        }
+    }));
+    return results;
+}
+async function getArpTable() {
+    const os = platform();
+    if (os === 'darwin' || os === 'linux') {
+        return new Promise((resolve, reject) => {
+            execFile('arp', ['-a'], (err, stdout) => {
+                if (err)
+                    return reject(err);
+                const entries = [];
+                for (const line of stdout.split('\n')) {
+                    // macOS: ? (192.168.1.143) at 0:13:cb:28:35:ca on en0 ifscope [ethernet]
+                    // Linux: ? (192.168.1.143) at 00:13:cb:28:35:ca [ether] on eth0
+                    const match = line.match(/\((\d+\.\d+\.\d+\.\d+)\)\s+at\s+([0-9a-f:]+)/i);
+                    if (match) {
+                        // Normalize MAC: "0:13:cb:28:35:ca" → "00:13:cb:28:35:ca"
+                        const mac = match[2]
+                            .split(':')
+                            .map((p) => p.padStart(2, '0'))
+                            .join(':')
+                            .toLowerCase();
+                        entries.push({ ip: match[1], mac });
+                    }
+                }
+                resolve(entries);
+            });
+        });
+    }
+    if (os === 'win32') {
+        return new Promise((resolve, reject) => {
+            execFile('powershell', [
+                '-Command',
+                `Get-NetNeighbor -AddressFamily IPv4 | Where-Object { $_.State -ne "Unreachable" } | Select-Object IPAddress,LinkLayerAddress | ConvertTo-Json`,
+            ], (err, stdout) => {
+                if (err)
+                    return reject(err);
+                try {
+                    const raw = JSON.parse(stdout);
+                    const items = Array.isArray(raw) ? raw : [raw];
+                    const entries = items
+                        .filter((item) => item.LinkLayerAddress)
+                        .map((item) => ({
+                        ip: item.IPAddress,
+                        // Windows uses "00-13-CB-28-35-CA" format
+                        mac: item.LinkLayerAddress.replace(/-/g, ':').toLowerCase(),
+                    }));
+                    resolve(entries);
+                }
+                catch {
+                    resolve([]);
+                }
+            });
+        });
+    }
+    return [];
+}
+// ── Strategy B: HTTP Probe ───────────────────────────────────────────────
+async function httpProbeScan(subnet, timeout) {
+    const ips = expandSubnet(subnet);
+    const results = [];
+    // Probe all IPs in parallel with short timeout
+    const probeTimeout = Math.min(timeout, 1500);
+    const batches = chunk(ips, 50); // 50 concurrent
+    for (const batch of batches) {
+        const probes = batch.map(async (ip) => {
+            try {
+                const controller = new AbortController();
+                const timer = setTimeout(() => controller.abort(), probeTimeout);
+                const res = await fetch(`http://${ip}/`, {
+                    signal: controller.signal,
+                    redirect: 'follow',
+                });
+                clearTimeout(timer);
+                const html = await res.text();
+                // Fingerprint: look for zenitel.js or Stentofon
+                if (html.includes('zenitel.js') ||
+                    html.includes('Stentofon') ||
+                    html.includes('zForm_header')) {
+                    // Extract firmware from "zenitel.js?version=X.X.X.X"
+                    const fwMatch = html.match(/version=(\d+\.\d+\.\d+\.\d+)/);
+                    results.push({
+                        ip,
+                        mac: '',
+                        firmware: fwMatch?.[1],
+                        hasCamera: false,
+                    });
+                }
+            }
+            catch {
+                // Unreachable — skip
+            }
+        });
+        await Promise.all(probes);
+    }
+    return results;
+}
+// ── Helpers ──────────────────────────────────────────────────────────────
+function detectSubnet() {
+    const interfaces = networkInterfaces();
+    for (const iface of Object.values(interfaces)) {
+        if (!iface)
+            continue;
+        for (const addr of iface) {
+            if (addr.family === 'IPv4' && !addr.internal) {
+                // e.g. "192.168.1.42" + netmask "255.255.255.0" → "192.168.1.0/24"
+                const parts = addr.address.split('.');
+                parts[3] = '0';
+                return `${parts.join('.')}/24`;
+            }
+        }
+    }
+    return undefined;
+}
+function expandSubnet(cidr) {
+    // Simple /24 expansion — covers 99% of home/office networks
+    const base = cidr.split('/')[0];
+    const parts = base.split('.');
+    const ips = [];
+    for (let i = 1; i <= 254; i++) {
+        ips.push(`${parts[0]}.${parts[1]}.${parts[2]}.${i}`);
+    }
+    return ips;
+}
+function chunk(arr, size) {
+    const chunks = [];
+    for (let i = 0; i < arr.length; i += size) {
+        chunks.push(arr.slice(i, i + size));
+    }
+    return chunks;
+}

package/dist/types.d.ts

@@ -0,0 +1,193 @@
+/**
+ * @pinecall/zenitel-client — Type definitions
+ *
+ * All interfaces for the Zenitel HTTP scraper, scanner, and CLI.
+ */
+export interface ZenitelClientOptions {
+    /** IP or hostname of the Zenitel intercom (e.g. "192.168.1.143") */
+    host: string;
+    /** Web UI username. Default: "admin" */
+    user?: string;
+    /** Web UI password. Default: "alphaadmin" */
+    password?: string;
+    /** Protocol. Default: "http" */
+    protocol?: 'http' | 'https';
+    /** HTTP request timeout in ms. Default: 5000 */
+    timeout?: number;
+}
+export interface ZenitelDevice {
+    ip: string;
+    mac: string;
+    model?: string;
+    firmware?: string;
+    hasCamera: boolean;
+    hostname?: string;
+    mode?: 'sip' | 'edge' | 'pulse';
+    serialNumber?: string;
+    hardwareType?: string;
+}
+export interface ScanOptions {
+    /** Scan timeout in ms. Default: 5000 */
+    timeout?: number;
+    /** Subnet CIDR (e.g. "192.168.1.0/24"). Auto-detected if omitted. */
+    subnet?: string;
+    /** Which strategies to run. Default: all three. */
+    strategies?: ('arp-oui' | 'http-probe')[];
+}
+export interface DeviceInfo {
+    model: string;
+    firmware: string;
+    mac: string;
+    ip: string;
+    hostname: string;
+    serialNumber: string;
+    hardwareType: string;
+    mode: 'sip' | 'edge' | 'pulse';
+    hasCamera: boolean;
+    sipDomain?: string;
+    sipRegistered?: boolean;
+    sipNumber?: string;
+    outboundProxy?: string;
+    uptime?: string;
+    webcallEnabled: boolean;
+    platform: string;
+    systemModelName?: string;
+}
+export interface RelayOptions {
+    /** Relay ID. Default: "relay1". Options: relay1, gpio1-gpio6 */
+    relayId?: string;
+    /** Timer in seconds. 0 = toggle (stays active until deactivated). Default: 3 */
+    timer?: number;
+}
+export interface RelayStatus {
+    relay1: 'Activated' | 'Deactivated';
+    gpio1: 'Activated' | 'Deactivated';
+    gpio2: 'Activated' | 'Deactivated';
+    gpio3: 'Activated' | 'Deactivated';
+    gpio4: 'Activated' | 'Deactivated';
+    gpio5: 'Activated' | 'Deactivated';
+    gpio6: 'Activated' | 'Deactivated';
+}
+export interface SIPConfig {
+    domain?: string;
+    outboundProxy?: string;
+    transport?: 'udp' | 'tcp' | 'tls';
+    displayName?: string;
+    directoryNumber?: string;
+    authUsername?: string;
+    authPassword?: string;
+}
+export type CallStatus = 'Idle' | 'Calling' | 'Connected' | 'Ringing';
+/** Full provisioning config for a factory-reset Zenitel */
+export interface ProvisionConfig {
+    /** SIP registration domain (e.g. "testing-mo16m3gw.sip.twilio.com") */
+    sipDomain: string;
+    /** SIP auth username (e.g. "zenitel01") */
+    sipAuthUser: string;
+    /** SIP auth password */
+    sipAuthPassword: string;
+    /** Outbound proxy address. Defaults to sipDomain if omitted. */
+    sipProxy?: string;
+    /** SIP transport. Default: "UDP" */
+    sipTransport?: 'UDP' | 'TCP' | 'TLS';
+    /** Station display name (e.g. "Lobby Intercom"). Defaults to agentNumber. */
+    stationName?: string;
+    /** The SIP number the call button will dial (e.g. "portia-ae3c") */
+    agentNumber: string;
+    /** Enable webcall + relay HTTP API. Default: true */
+    enableWebcall?: boolean;
+    /** Enable auto-answer mode (for AI agent). Default: true */
+    autoAnswer?: boolean;
+}
+/** Speaker / Line Out output device */
+export interface AudioOutputDevice {
+    /** Device identifier: "internal_speaker" or "line_out" */
+    kid: string;
+    /** Playback gain in dB. Speaker: -10..+13, Line Out: -20..+20 */
+    gain: number;
+    /** Override gain for priority calls in dB. Speaker: -10..+23, Line Out: -20..+21 */
+    overrideGain: number;
+    /** Signal source (default: "main_audio_line") */
+    signalSource: string;
+    /** Output type (e.g. "standard_loudspeaker", "line_out_professional") */
+    outputType: string;
+}
+/** Microphone input device */
+export interface AudioInputDevice {
+    /** Device identifier: "internal_mic" */
+    kid: string;
+    /** Mic gain in dB. Range: -10..+10 */
+    gain: number;
+    /** Input type (e.g. "digital_mic") */
+    inputType: string;
+}
+/** AEC — Acoustic Echo Cancellation */
+export interface AECSettings {
+    /** Enable echo cancellation */
+    enabled: boolean;
+    /** Suppression level */
+    mode: 'moderate' | 'aggressive';
+}
+/** ANC — Active Noise Cancellation */
+export interface ANCSettings {
+    /** Enable noise cancellation */
+    enabled: boolean;
+    /** Suppression level */
+    mode: 'moderate' | 'aggressive';
+}
+/** FESS — Far-End Signal Squelch */
+export interface FESSSettings {
+    /** Enable squelch on weak signals */
+    enabled: boolean;
+    /** Threshold in dBFS (-92..0). Signals below this are silenced. */
+    threshold: number;
+    /** Activation delay in ms (0..10000) */
+    delay: number;
+}
+/** DRC — Dynamic Range Compression (Loudspeaker) */
+export interface DRCSettings {
+    /** Enable compression */
+    enabled: boolean;
+    /** Added gain in dBA (0..20) */
+    gain: number;
+}
+/** AVC — Automatic Volume Control */
+export interface AVCSettings {
+    /** Enable automatic volume adjustment based on ambient noise */
+    enabled: boolean;
+    /** Enable digital AVC variant */
+    digitalEnabled: boolean;
+    /** Ambient noise level (dB) to start adjusting */
+    threshold: number;
+    /** Maximum noise level (dB) — stops adjusting above this */
+    upperThreshold: number;
+    /** How fast volume increases (1..100) */
+    attackRate: number;
+    /** How fast volume decreases (1..100) */
+    decayRate: number;
+    /** dB margin to prevent volume bouncing */
+    hysteresis: number;
+    /** Seconds to ignore noise when speaker is active */
+    farEndLockoutTime: number;
+}
+/** Complete audio configuration for the Zenitel intercom */
+export interface AudioSettings {
+    /** Internal speaker output */
+    speaker: AudioOutputDevice;
+    /** Line out (auxiliary connector) */
+    lineOut: AudioOutputDevice;
+    /** Internal microphone */
+    mic: AudioInputDevice;
+    /** Acoustic Echo Cancellation */
+    aec: AECSettings;
+    /** Active Noise Cancellation */
+    anc: ANCSettings;
+    /** Far-End Signal Squelch */
+    fess: FESSSettings;
+    /** Dynamic Range Compression */
+    drc: DRCSettings;
+    /** Automatic Volume Control */
+    avc: AVCSettings;
+    /** Audio mode: "Voice" or "Music" */
+    mode: string;
+}

package/dist/types.js

@@ -0,0 +1,6 @@
+/**
+ * @pinecall/zenitel-client — Type definitions
+ *
+ * All interfaces for the Zenitel HTTP scraper, scanner, and CLI.
+ */
+export {};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "zenitel-client",
+  "version": "0.1.0",
+  "description": "HTTP client + network scanner for Zenitel intercom systems (TCIV-2+, TCIV-3). Control relays, SIP configuration, DAK provisioning, webcall, and camera feeds.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": { "types": "./dist/index.d.ts", "default": "./dist/index.js" },
+      "require": { "types": "./dist/index.d.ts", "default": "./dist/index.js" }
+    },
+    "./scanner": {
+      "import": { "types": "./dist/scanner.d.ts", "default": "./dist/scanner.js" },
+      "require": { "types": "./dist/scanner.d.ts", "default": "./dist/scanner.js" }
+    }
+  },
+  "bin": {
+    "zenitel": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build",
+    "cli": "tsx src/cli.ts"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.0",
+    "tsx": "^4.21.0",
+    "@types/node": "^22.0.0"
+  },
+  "files": ["dist", "README.md"],
+  "keywords": [
+    "zenitel", "intercom", "TCIV", "SIP", "door-access",
+    "relay", "DTMF", "webcall", "building-automation"
+  ],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pinecall/zenitel-client"
+  },
+  "homepage": "https://github.com/pinecall/zenitel-client#readme",
+  "bugs": {
+    "url": "https://github.com/pinecall/zenitel-client/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}