abb-rws-client 0.2.0 → 0.7.1

package/dist/RWS1Adapter.js

@@ -0,0 +1,870 @@
+import * as http from 'http';
+import * as crypto from 'crypto';
+/**
+ * RWS 1.0 adapter — thin wrapper around RwsClient (abb-rws-client).
+ * Every method delegates directly; zero logic change from pre-adapter behavior.
+ * Targets ABB IRC5 controllers running RobotWare 6.x.
+ */
+export class RWS1Adapter {
+    client;
+    creds;
+    constructor(client, creds) {
+        this.client = client;
+        this.creds = creds;
+    }
+    // ── Connection ──────────────────────────────────────────────────────────
+    connect() { return this.client.connect(); }
+    disconnect() { return this.client.disconnect(); }
+    getSessionCookie() { return this.client.getSessionCookie(); }
+    // ── Panel ───────────────────────────────────────────────────────────────
+    getControllerState() { return this.client.getControllerState(); }
+    setControllerState(s) { return this.client.setControllerState(s); }
+    getOperationMode() { return this.client.getOperationMode(); }
+    getSpeedRatio() { return this.client.getSpeedRatio(); }
+    setSpeedRatio(r) { return this.client.setSpeedRatio(r); }
+    getCollisionDetectionState() { return this.client.getCollisionDetectionState(); }
+    lockOperationMode(pin, p) { return this.client.lockOperationMode(pin, p); }
+    unlockOperationMode() { return this.client.unlockOperationMode(); }
+    setOperationMode(mode) { return this.client.setOperationMode(mode); }
+    // ── RAPID execution ─────────────────────────────────────────────────────
+    getRapidExecutionState() { return this.client.getRapidExecutionState(); }
+    getRapidExecutionInfo() { return this.client.getRapidExecutionInfo(); }
+    startRapid() { return this.client.startRapid(); }
+    stopRapid() { return this.client.stopRapid(); }
+    resetRapid() { return this.client.resetRapid(); }
+    setExecutionCycle(c) { return this.client.setExecutionCycle(c); }
+    getRapidTasks() { return this.client.getRapidTasks(); }
+    activateRapidTask(t) { return this.client.activateRapidTask(t); }
+    deactivateRapidTask(t) { return this.client.deactivateRapidTask(t); }
+    activateAllRapidTasks() { return this.client.activateAllRapidTasks(); }
+    deactivateAllRapidTasks() { return this.client.deactivateAllRapidTasks(); }
+    // ── RAPID modules & variables ───────────────────────────────────────────
+    listModules(task) { return this.client.listModules(task); }
+    /** RWS 1.0 module-list also exposes name + type (SysMod / ProgMod) per entry. */
+    async listModulesDetailed(task) {
+        const r = await this.rws1Get(`/rw/rapid/modules?task=${encodeURIComponent(task)}`);
+        return r.states
+            .map(s => ({ name: s['name'] ?? '', type: s['type'] ?? '' }))
+            .filter(m => m.name);
+    }
+    loadModule(task, path, r) { return this.client.loadModule(task, path, r); }
+    unloadModule(task, name) { return this.client.unloadModule(task, name); }
+    getRapidVariable(t, m, s) { return this.client.getRapidVariable(t, m, s); }
+    setRapidVariable(t, m, s, v) { return this.client.setRapidVariable(t, m, s, v); }
+    validateRapidValue(t, v, d) { return this.client.validateRapidValue(t, v, d); }
+    getRapidSymbolProperties(t, m, s) { return this.client.getRapidSymbolProperties(t, m, s); }
+    searchRapidSymbols(p) { return this.client.searchRapidSymbols(p); }
+    getActiveUiInstruction() { return this.client.getActiveUiInstruction(); }
+    setUiInstructionParam(su, up, v) { return this.client.setUiInstructionParam(su, up, v); }
+    // ── Motion ──────────────────────────────────────────────────────────────
+    getJointPositions(u) { return this.client.getJointPositions(u); }
+    getCartesianFull(u) { return this.client.getCartesianFull(u); }
+    /** RwsClient has no listMechunits — IRC5 always has ROB_1 as the standard mechunit. */
+    async listMechunits() { return ['ROB_1']; }
+    // ── System info ─────────────────────────────────────────────────────────
+    getSystemInfo() { return this.client.getSystemInfo(); }
+    getControllerIdentity() { return this.client.getControllerIdentity(); }
+    getControllerClock() { return this.client.getControllerClock(); }
+    setControllerClock(Y, Mo, D, H, Mi, S) {
+        return this.client.setControllerClock(Y, Mo, D, H, Mi, S);
+    }
+    restartController(m) { return this.client.restartController(m); }
+    // ── Event log ───────────────────────────────────────────────────────────
+    getEventLog(d, l) { return this.client.getEventLog(d, l); }
+    clearEventLog(d) { return this.client.clearEventLog(d); }
+    clearAllEventLogs() { return this.client.clearAllEventLogs(); }
+    // ── I/O ────────────────────────────────────────────────────────────────
+    listAllSignals(s, l) { return this.client.listAllSignals(s, l); }
+    readSignal(n, d, name) { return this.client.readSignal(n, d, name); }
+    writeSignal(n, d, name, v) { return this.client.writeSignal(n, d, name, v); }
+    listNetworks() { return this.client.listNetworks(); }
+    listDevices(network) { return this.client.listDevices(network); }
+    // ── File system ─────────────────────────────────────────────────────────
+    listDirectory(path) { return this.client.listDirectory(path); }
+    readFile(path) { return this.client.readFile(path); }
+    uploadFile(path, content) { return this.client.uploadModule(path, content); }
+    deleteFile(path) { return this.client.deleteFile(path); }
+    createDirectory(parent, dir) { return this.client.createDirectory(parent, dir); }
+    copyFile(src, dst) { return this.client.copyFile(src, dst); }
+    // ── Mastership ──────────────────────────────────────────────────────────
+    requestMastership(d) { return this.client.requestMastership(d); }
+    releaseMastership(d) { return this.client.releaseMastership(d); }
+    /** Request mastership on all domains (cfg + motion + rapid) at once. */
+    async requestMastershipAll() {
+        await this.rws1Post('/rw/mastership?action=request', '');
+    }
+    /** Release mastership on all domains at once. */
+    async releaseMastershipAll() {
+        await this.rws1Post('/rw/mastership?action=release', '');
+    }
+    /**
+     * RWS 1.0 doesn't expose `request-with-id` / `release-with-id` — those are
+     * RWS 2.0 / RobotWare 7+ additions. The `?` in the IRWSAdapter signature
+     * means we don't have to implement on this side; calls just throw.
+     */
+    /**
+     * RWS 1.0 doesn't expose a watchdog endpoint — heartbeat is RWS 2.0 only.
+     * The optional method on IRWSAdapter is left undefined here so callers can
+     * feature-detect (`if ('resetMastershipWatchdog' in adapter)`).
+     */
+    /** Read mastership status for one domain. */
+    async getMastershipStatus(d) {
+        const r = await this.rws1Get(`/rw/mastership/${d}`);
+        const s = r.state;
+        return { mastership: s?.mastership ?? 'unknown', uid: s?.uid, application: s?.application };
+    }
+    /** List mastership domains (RWS 1.0: ['cfg', 'motion', 'rapid']). */
+    async listMastershipDomains() {
+        const r = await this.rws1Get('/rw/mastership');
+        return r.states.map(s => s['_title']).filter(Boolean);
+    }
+    // ── Devices ────────────────────────────────────────────────────────────
+    async listSystemDevices() {
+        // RWS 1.0 nests the dev-id-li array inside _state[0].devices (different from the
+        // RWS 2.0 XHTML layout where each <li class="dev-id-li"> is a top-level child).
+        const r = await this.rws1Get('/rw/devices');
+        const devices = r.state?.devices ?? [];
+        return devices.map(d => ({
+            id: d['_title'] ?? '',
+            name: d['name'] ?? '',
+        }));
+    }
+    async getDeviceTree(group) {
+        const res = await this.client.request('GET', `/rw/devices/${encodeURIComponent(group)}?json=1`);
+        return res.body;
+    }
+    async listAllIoDevices() {
+        const r = await this.rws1Get('/rw/iosystem/devices');
+        return r.states.map(state => {
+            const s = state;
+            const title = s['_title'] ?? '';
+            return {
+                name: s['name'] ?? '',
+                network: title.split('/')[0] ?? '',
+                lstate: s['lstate'] ?? '',
+                pstate: s['pstate'] ?? '',
+                address: s['address'] ?? '',
+            };
+        });
+    }
+    // ── Forward kinematics ──────────────────────────────────────────────────
+    /**
+     * Forward kinematics on RWS 1.0. Same VC-license caveat as IK.
+     */
+    async calcCartesianFromJoints(joints, mechunit = 'ROB_1', tool = 'tool0', wobj = 'wobj0') {
+        if (!this.creds) {
+            throw new Error('FK requires credentials in adapter constructor');
+        }
+        const { host, port, username, password } = this.creds;
+        const body = [
+            `curr_joints=[${joints.rax_1},${joints.rax_2},${joints.rax_3},${joints.rax_4},${joints.rax_5},${joints.rax_6}]`,
+            `curr_ext_joints=[9E9,9E9,9E9,9E9,9E9,9E9]`,
+            `tool=${tool}`,
+            `wobj=${wobj}`,
+        ].join('&');
+        const path = `/rw/motionsystem/mechunits/${mechunit}?action=CalcRobTFromJoints&json=1`;
+        const result = await this.digestPost(host, port, path, body, username, password);
+        const state = result._embedded?._state?.[0];
+        if (!state) {
+            throw new Error('FK: no result in response');
+        }
+        return {
+            x: +state.x, y: +state.y, z: +state.z,
+            q1: +state.q1, q2: +state.q2, q3: +state.q3, q4: +state.q4,
+        };
+    }
+    subscribe(resources, handler) {
+        return this.client.subscribe(resources, handler);
+    }
+    // ── Jogging ─────────────────────────────────────────────────────────────
+    /** Monotonic counter required by RWS jog endpoint (rejects duplicate ccount values). */
+    jogCcount = 0;
+    async jog(params) {
+        if (!this.creds) {
+            throw new Error('Jog requires credentials — reconnect to enable');
+        }
+        const { mode, axes, speed } = params;
+        const mechunit = params.mechunit ?? 'ROB_1';
+        this.jogCcount++;
+        const bodyStr = [
+            `jogmode=${mode}`,
+            `mechunit=${mechunit}`,
+            ...axes.map((v, i) => `axis${i + 1}=${v}`),
+            `cjogspeed=${speed}`,
+            `ccount=${this.jogCcount}`,
+        ].join('&');
+        const { host, port, username, password } = this.creds;
+        const path = `/rw/motionsystem?action=jog&json=1`;
+        const result = await this.digestPost(host, port, path, bodyStr, username, password);
+        // Successful jog has no useful body — only check for error status.
+        const status = result._embedded?.status;
+        if (status?.msg && status.msg.length > 0 && /error|fail/i.test(status.msg)) {
+            throw new Error(status.msg);
+        }
+    }
+    // ── RWS 1.0 helper — typed wrapper around client.request() with JSON parsing ──
+    /**
+     * Generic GET that returns `_embedded._state[0]` (single resource) or [] (list).
+     * Most RWS 1.0 endpoints with `?json=1` return this HAL-like envelope.
+     * Returns empty result for HTTP 204 (no content) — common on /ctrl/options etc.
+     */
+    async rws1Get(path) {
+        const url = path + (path.includes('?') ? '&' : '?') + 'json=1';
+        const res = await this.client.request('GET', url);
+        if (res.status === 204 || !res.body) {
+            return { status: res.status, state: null, states: [], raw: null };
+        }
+        if (res.status >= 400) {
+            let msg = `HTTP ${res.status}`;
+            try {
+                msg = JSON.parse(res.body)._embedded?.status?.msg ?? msg;
+            }
+            catch { /* ok */ }
+            throw new Error(msg);
+        }
+        let parsed = {};
+        try {
+            parsed = JSON.parse(res.body);
+        }
+        catch { /* non-JSON ok */ }
+        const states = parsed._embedded?._state ?? [];
+        return { status: res.status, state: states[0] ?? null, states, raw: parsed };
+    }
+    /** Generic POST that throws on >=400, returns the parsed JSON body. */
+    async rws1Post(path, body) {
+        const url = path + (path.includes('?') ? '&' : '?') + 'json=1';
+        const res = await this.client.request('POST', url, body);
+        if (res.status >= 400) {
+            let msg = `HTTP ${res.status}`;
+            try {
+                msg = JSON.parse(res.body)._embedded?.status?.msg ?? msg;
+            }
+            catch { /* ok */ }
+            throw new Error(msg);
+        }
+        try {
+            return JSON.parse(res.body);
+        }
+        catch {
+            return null;
+        }
+    }
+    // ── System detail ───────────────────────────────────────────────────────
+    async getRobotType() {
+        const r = await this.rws1Get('/rw/system/robottype');
+        const s = r.state;
+        return { type: s?.['robot-type'] ?? s?.type ?? '', variant: s?.variant };
+    }
+    async getLicenseInfo() {
+        // RWS 1.0 path is singular `/license`. Doc 6.8 has it as plural `/licenses`
+        // but live IRC5 returns 404 for that — singular works.
+        const r = await this.rws1Get('/rw/system/license');
+        return { entries: r.states };
+    }
+    async listProducts() {
+        const r = await this.rws1Get('/rw/system/products');
+        return r.states;
+    }
+    async getEnergyStats() {
+        try {
+            const r = await this.rws1Get('/rw/system/energy');
+            return r.state ?? {};
+        }
+        catch {
+            return {};
+        }
+    }
+    // ── Return code lookup ─────────────────────────────────────────────────
+    async getReturnCode(code, lang = 'en') {
+        try {
+            const r = await this.rws1Get(`/rw/retcode?code=${code}&lang=${lang}`);
+            const s = r.state;
+            if (!s) {
+                return null;
+            }
+            return { code, title: s.title ?? '', desc: s.desc ?? '' };
+        }
+        catch {
+            return null;
+        }
+    }
+    // ── Controller detail ──────────────────────────────────────────────────
+    async listControllerOptions() {
+        try {
+            const r = await this.rws1Get('/ctrl/options');
+            return r.states.map(o => ({
+                name: (o.option ?? o.name ?? ''),
+                description: o.description,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    // ── Motion detail ──────────────────────────────────────────────────────
+    async getMotionChangeCount() {
+        const r = await this.rws1Get('/rw/motionsystem');
+        const s = r.state;
+        return Number(s?.['change-count'] ?? 0);
+    }
+    async getMotionErrorState() {
+        const r = await this.rws1Get('/rw/motionsystem/errorstate');
+        const s = r.state;
+        return { state: s?.['err-state'] ?? s?.state ?? 'unknown', details: s ?? undefined };
+    }
+    async getNonMotionExecution() {
+        const r = await this.rws1Get('/rw/motionsystem/nonmotionexecution');
+        const s = r.state;
+        return (s?.mode ?? '').toUpperCase() === 'ON';
+    }
+    async setNonMotionExecution(enabled) {
+        await this.rws1Post('/rw/motionsystem/nonmotionexecution?action=set', `mode=${enabled ? 'ON' : 'OFF'}`);
+    }
+    async getMechunitInfo(mechunit = 'ROB_1') {
+        const r = await this.rws1Get(`/rw/motionsystem/mechunits/${mechunit}`);
+        return r.state ?? {};
+    }
+    async getMechunitBaseFrame(mechunit = 'ROB_1') {
+        const r = await this.rws1Get(`/rw/motionsystem/mechunits/${mechunit}/baseframe`);
+        const s = r.state ?? {};
+        return { x: +s.x, y: +s.y, z: +s.z, q1: +s.q1, q2: +s.q2, q3: +s.q3, q4: +s.q4 };
+    }
+    async getMechunitAxes(mechunit = 'ROB_1') {
+        // RWS 1.0 returns 2 entries: an axis-count summary and a sub-resource link list.
+        // Fetch each axis individually to get its real data.
+        const r = await this.rws1Get(`/rw/motionsystem/mechunits/${mechunit}/axes`);
+        const summary = r.states.find(s => s._type === 'ms-mechunit-axes');
+        const count = +(summary?.axes ?? '0');
+        if (count === 0) {
+            return [];
+        }
+        const axes = [];
+        for (let i = 1; i <= count; i++) {
+            try {
+                const ar = await this.rws1Get(`/rw/motionsystem/mechunits/${mechunit}/axes/${i}`);
+                axes.push({ axis: String(i), ...(ar.state ?? {}) });
+            }
+            catch {
+                axes.push({ axis: String(i), error: 'unreachable' });
+            }
+        }
+        return axes;
+    }
+    async getActiveTool(mechunit = 'ROB_1') {
+        const r = await this.rws1Get(`/rw/motionsystem/mechunits/${mechunit}`);
+        const s = r.state ?? {};
+        return { name: s['tool-name'] ?? 'tool0' };
+    }
+    async getActiveWobj(mechunit = 'ROB_1') {
+        const r = await this.rws1Get(`/rw/motionsystem/mechunits/${mechunit}`);
+        const s = r.state ?? {};
+        return { name: s['wobj-name'] ?? 'wobj0' };
+    }
+    async getActivePayload(mechunit = 'ROB_1') {
+        const r = await this.rws1Get(`/rw/motionsystem/mechunits/${mechunit}`);
+        const s = r.state ?? {};
+        return { name: s['total-payload-name'] ?? s['payload-name'] ?? 'load0' };
+    }
+    // ── RAPID detail ───────────────────────────────────────────────────────
+    async listAliasIO() {
+        try {
+            const r = await this.rws1Get('/rw/rapid/aliasio');
+            return r.states.map(a => ({
+                alias: (a.name ?? a.alias ?? ''),
+                signal: (a.signal ?? a._title ?? ''),
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    async getProgramPointer(task) {
+        try {
+            const r = await this.rws1Get(`/rw/rapid/tasks/${task}/pcp`);
+            const s = r.state ?? {};
+            const begin = (s.beginposition ?? '').split(',');
+            return {
+                module: s.modulename ?? s.modulemame ?? s.module,
+                routine: s.routinename ?? s.routine,
+                row: begin[0] ? +begin[0] : undefined,
+                col: begin[1] ? +begin[1] : undefined,
+            };
+        }
+        catch {
+            return {};
+        }
+    }
+    async getMotionPointer(task) {
+        // RWS 1.0 path is /rw/rapid/tasks/{task}/motion (per official doc 6.7)
+        try {
+            const r = await this.rws1Get(`/rw/rapid/tasks/${task}/motion`);
+            const s = r.state ?? {};
+            return {
+                module: s.modulename ?? s.modulemame ?? s.module,
+                routine: s.routinename ?? s.routine,
+            };
+        }
+        catch {
+            return {};
+        }
+    }
+    // ── CFG database ───────────────────────────────────────────────────────
+    async listCfgDomains() {
+        const r = await this.rws1Get('/rw/cfg');
+        return r.states.map(d => (d._title ?? d.name)).filter(Boolean);
+    }
+    async listCfgTypes(domain) {
+        const types = [];
+        let path = `/rw/cfg/${domain}`;
+        let pages = 0;
+        while (path && pages < 50) {
+            const r = await this.rws1Get(path);
+            const ts = r.states.map(t => (t._title ?? t.name)).filter(Boolean);
+            types.push(...ts);
+            // RWS 1.0 pagination: `_links.next.href` in the response
+            const links = r.raw?._links;
+            const next = links?.next?.href;
+            if (next && pages < 49) {
+                path = '/rw/cfg/' + next.replace(/^\/+/, '').replace(/^cfg\//, '').replace(/&amp;/g, '&').replace(/[?&]json=1/, '');
+            }
+            else {
+                path = '';
+            }
+            pages++;
+        }
+        return types;
+    }
+    async listCfgInstances(domain, type) {
+        try {
+            const r = await this.rws1Get(`/rw/cfg/${domain}/${type}/instances`);
+            return r.states.map(i => (i._title ?? i.name)).filter(Boolean);
+        }
+        catch {
+            return [];
+        }
+    }
+    async getCfgInstance(domain, type, instance) {
+        // RWS 1.0 inlines all attribute data in the instance-list response. The single-instance
+        // GET also works at `/instances/{name}`. Use the list call (one HTTP request) and find
+        // by _title — also handles instance names with spaces/special chars correctly.
+        const r = await this.rws1Get(`/rw/cfg/${domain}/${type}/instances`);
+        const target = r.states.find(s => s._title === instance);
+        if (!target) {
+            return {};
+        }
+        const out = {};
+        // Attributes can come in two shapes on RWS 1.0:
+        //   1. Inline `attrib` array of { _title: name, value }
+        //   2. Direct keyed properties on the state object
+        const attribs = target.attrib;
+        if (Array.isArray(attribs)) {
+            for (const a of attribs) {
+                if (a._title) {
+                    out[a._title] = String(a.value ?? '');
+                }
+            }
+        }
+        // Always include direct properties (rdonly, instanceid, etc.) — useful metadata.
+        for (const [k, v] of Object.entries(target)) {
+            if (k.startsWith('_') || k === 'attrib') {
+                continue;
+            }
+            if (typeof v === 'string') {
+                out[k] = v;
+            }
+        }
+        return out;
+    }
+    // ── Backup ─────────────────────────────────────────────────────────────
+    async listBackups() {
+        try {
+            const entries = await this.client.listDirectory('$BACKUP');
+            return entries.filter(e => e.type === 'dir').map(e => ({
+                name: e.name,
+                created: e.created,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    async getBackupStatus() {
+        try {
+            const r = await this.rws1Get('/ctrl/backup');
+            const s = r.state ?? {};
+            const phase = s['progress-state'] ?? s.phase ?? '';
+            return {
+                active: phase !== '' && phase !== 'idle' && phase !== 'finished',
+                progress: s.progress ? +s.progress : undefined,
+                phase,
+            };
+        }
+        catch {
+            return { active: false };
+        }
+    }
+    // ── RMMP ───────────────────────────────────────────────────────────────
+    async getRmmpPrivilege() {
+        try {
+            const r = await this.rws1Get('/users/rmmp');
+            const s = r.state ?? {};
+            const priv = s.privilege ?? 'none';
+            const heldByMe = (s.rmmpheldbyme ?? 'false').toLowerCase() === 'true';
+            if (priv === 'none' || priv.startsWith('pending')) {
+                return priv;
+            }
+            return heldByMe ? priv : 'none';
+        }
+        catch {
+            return 'none';
+        }
+    }
+    async requestRmmp(level = 'modify') {
+        await this.rws1Post('/users/rmmp', `privilege=${level}`);
+    }
+    // ── Stage 7: Backup / Restore / Progress (5 methods) ───────────────────
+    async createBackup(name) {
+        // Async — controller returns 202 + Location header pointing to /progress/{id}.
+        // Caller polls getProgress() to track completion.
+        await this.rws1Post('/ctrl/backup?action=backup', `backup=$BACKUP/${encodeURIComponent(name)}`);
+    }
+    async restoreBackup(name) {
+        await this.rws1Post('/ctrl/backup?action=restore', `backup=$BACKUP/${encodeURIComponent(name)}`);
+    }
+    async listProgress() {
+        try {
+            const r = await this.rws1Get('/progress');
+            return r.states.map(p => ({
+                id: (p._title ?? p.id ?? ''),
+                state: (p.state ?? ''),
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    async getProgress(id) {
+        try {
+            const r = await this.rws1Get(`/progress/${encodeURIComponent(id)}`);
+            const s = r.state;
+            if (!s) {
+                return null;
+            }
+            return { state: s.state ?? '', details: s };
+        }
+        catch {
+            return null;
+        }
+    }
+    // ── Stage 8: DIPC (6 methods) ──────────────────────────────────────────
+    async listDipcQueues() {
+        try {
+            const r = await this.rws1Get('/rw/dipc');
+            return r.states.map(q => ({
+                name: (q._title ?? q['queue-name'] ?? ''),
+                size: q['queue-size'] !== undefined ? +q['queue-size'] : undefined,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    async createDipcQueue(name, options = {}) {
+        const parts = [`dipc-queue-name=${encodeURIComponent(name)}`];
+        if (options.maxsize) {
+            parts.push(`dipc-max-size=${options.maxsize}`);
+        }
+        if (options.maxmessages) {
+            parts.push(`dipc-max-number-of-messages=${options.maxmessages}`);
+        }
+        await this.rws1Post('/rw/dipc?action=create', parts.join('&'));
+    }
+    async sendDipcMessage(queue, payload, type = 'string') {
+        const typeCode = type === 'string' ? '0' : type === 'num' ? '1' : type === 'dnum' ? '2' : '3';
+        await this.rws1Post(`/rw/dipc/${encodeURIComponent(queue)}?action=send`, `dipc-src-queue-name=${encodeURIComponent(queue)}&dipc-cmd=111&dipc-data=${encodeURIComponent(payload)}&dipc-msgtype=${typeCode}`);
+    }
+    async readDipcMessage(queue) {
+        try {
+            const r = await this.rws1Get(`/rw/dipc/${encodeURIComponent(queue)}?action=read`);
+            const s = r.state;
+            if (!s || !s['dipc-data']) {
+                return null;
+            }
+            return { payload: s['dipc-data'], type: s['dipc-msgtype'] ?? 'string' };
+        }
+        catch {
+            return null;
+        }
+    }
+    async removeDipcQueue(name) {
+        await this.client.request('DELETE', `/rw/dipc/${encodeURIComponent(name)}?json=1`);
+    }
+    // ── Stage 9: Safety (5 methods) ────────────────────────────────────────
+    async getSafetyStatus() {
+        try {
+            const r = await this.rws1Get('/ctrl/safety');
+            const s = r.state;
+            return { state: s?.state ?? 'unavailable', details: s ?? undefined };
+        }
+        catch {
+            return { state: 'unavailable' };
+        }
+    }
+    async listSafetyZones() {
+        try {
+            const r = await this.rws1Get('/ctrl/safety/zones');
+            return r.states;
+        }
+        catch {
+            return [];
+        }
+    }
+    async runCyclicBrakeCheck() {
+        await this.rws1Post('/ctrl/safety/cyclic-brake-check', '');
+    }
+    // ── Stage 10: Virtual time (3 methods, VC-only) ────────────────────────
+    async getVirtualTime() {
+        try {
+            // RWS 1.0 has /ctrl/virtualtime as a directory; query each sub-resource.
+            const fetch = async (sub) => {
+                try {
+                    const r = await this.rws1Get(`/ctrl/virtualtime/${sub}`);
+                    return r.state ?? {};
+                }
+                catch {
+                    return {};
+                }
+            };
+            const [time, state, speed] = await Promise.all([fetch('vttime'), fetch('vtstate'), fetch('vtspeed')]);
+            return {
+                time: Number(time.vtcounter ?? time.time ?? 0),
+                running: (state.vtcurrstate ?? state.state ?? '').toLowerCase() === 'running',
+                speed: speed.vtcurrspeed !== undefined ? +speed.vtcurrspeed : undefined,
+            };
+        }
+        catch {
+            return { time: 0, running: false };
+        }
+    }
+    async setVirtualTimeRunning(running) {
+        await this.rws1Post(`/ctrl/virtualtime/vtstate?action=${running ? 'run' : 'pause'}`, '');
+    }
+    async setVirtualTimeScale(scale) {
+        await this.rws1Post('/ctrl/virtualtime/vtspeed?action=set', `vtcurrspeed=${scale}`);
+    }
+    // ── Stage 11: Vision (5 methods) ───────────────────────────────────────
+    async listVisionSystems() {
+        try {
+            const r = await this.rws1Get('/rw/vision');
+            return r.states.map(v => ({
+                name: (v._title ?? v.name ?? ''),
+                status: v.status,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    async getVisionSystemInfo(name) {
+        try {
+            const r = await this.rws1Get(`/rw/vision/${encodeURIComponent(name)}`);
+            return r.state ?? {};
+        }
+        catch {
+            return {};
+        }
+    }
+    async triggerVisionJob(system) {
+        await this.rws1Post(`/rw/vision/${encodeURIComponent(system)}?action=trigger`, '');
+    }
+    // ── Stage 12: RAPID extras (4 methods) ─────────────────────────────────
+    async saveModule(task, moduleName, filepath) {
+        await this.rws1Post(`/rw/rapid/tasks/${task}?action=savemod`, `name=${encodeURIComponent(moduleName)}&filepath=${encodeURIComponent(filepath)}`);
+    }
+    async listModuleRoutines(task, moduleName) {
+        try {
+            const r = await this.rws1Get(`/rw/rapid/modules/${task}/${moduleName}/routines`);
+            return r.states.map(rt => ({
+                name: (rt.name ?? rt._title ?? ''),
+                type: (rt.type ?? ''),
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    async listBreakpoints(task) {
+        try {
+            // Per official doc: CCRapidBreakPointResource — exact path varies by RW version.
+            const r = await this.rws1Get(`/rw/rapid/tasks/${task}/breakpoints`);
+            return r.states.map(b => ({
+                module: (b.module ?? b.modulename ?? ''),
+                row: +(b['begin-position-row'] ?? b.row ?? 0),
+                col: b['begin-position-col'] !== undefined ? +b['begin-position-col'] : undefined,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    async holdToRun(task, action) {
+        await this.rws1Post(`/rw/rapid/tasks/${task}?action=holdtorun`, `action=${action}`);
+    }
+    async startProductionMode() {
+        await this.rws1Post('/rw/rapid/execution?action=start-prod', '');
+    }
+    // ── Stage 13: Network / time / compatibility (5 methods) ──────────────
+    async getNetworkConfig() {
+        try {
+            const r = await this.rws1Get('/ctrl/network');
+            return r.state ?? {};
+        }
+        catch {
+            return {};
+        }
+    }
+    async getDnsConfig() {
+        try {
+            const r = await this.rws1Get('/ctrl/network/dns');
+            return r.state ?? {};
+        }
+        catch {
+            return {};
+        }
+    }
+    async getRoutingTable() {
+        try {
+            const r = await this.rws1Get('/ctrl/network/routes');
+            return r.states;
+        }
+        catch {
+            return [];
+        }
+    }
+    async getTimezone() {
+        try {
+            const r = await this.rws1Get('/ctrl/clock/timezone');
+            const s = r.state ?? {};
+            return { tz: s.timezone ?? '', raw: s };
+        }
+        catch {
+            return { tz: '', raw: {} };
+        }
+    }
+    async getCompatibility() {
+        try {
+            const r = await this.rws1Get('/ctrl/compatible');
+            const s = r.state ?? {};
+            return { compatible: (s.compatible ?? '').toLowerCase() === 'true', details: s };
+        }
+        catch {
+            return { compatible: false };
+        }
+    }
+    // ── Stage 14: Set mechunit / robtarget for jogging (2 methods) ────────
+    async setMechunitForJogging(mechunit) {
+        await this.rws1Post('/rw/motionsystem?action=set-mechunit', `mechunit=${encodeURIComponent(mechunit)}`);
+    }
+    async setRobtargetForJogging(target) {
+        const t = target;
+        await this.rws1Post('/rw/motionsystem?action=set-target', `x=${t.x}&y=${t.y}&z=${t.z}&q1=${t.q1}&q2=${t.q2}&q3=${t.q3}&q4=${t.q4}`);
+    }
+    // ── Inverse kinematics ──────────────────────────────────────────────────
+    async calcJointsFromCartesian(pos, seedJoints, mechunit = 'ROB_1') {
+        if (!this.creds) {
+            throw new Error('IK requires credentials — reconnect to enable');
+        }
+        const { host, port, username, password } = this.creds;
+        const seed = seedJoints
+            ? `[${seedJoints.rax_1},${seedJoints.rax_2},${seedJoints.rax_3},${seedJoints.rax_4},${seedJoints.rax_5},${seedJoints.rax_6}]`
+            : '[0,0,0,0,0,0]';
+        const bodyStr = [
+            `curr_position=[${pos.x},${pos.y},${pos.z}]`,
+            `curr_orientation=[${pos.q1},${pos.q2},${pos.q3},${pos.q4}]`,
+            `curr_ext_joints=[9E9,9E9,9E9,9E9,9E9,9E9]`,
+            `old_rob_joints=${seed}`,
+            `old_ext_joints=[9E9,9E9,9E9,9E9,9E9,9E9]`,
+            `robot_fixed_object=false`,
+            `tool_frame_position=[0,0,0]`,
+            `tool_frame_orientation=[1,0,0,0]`,
+            `wobj_frame_position=[0,0,0]`,
+            `wobj_frame_orientation=[1,0,0,0]`,
+            `robot_configuration=[0,0,0,0]`,
+            `elog_at_error=false`,
+        ].join('&');
+        const path = `/rw/motionsystem/mechunits/${mechunit}?action=CalcJointsFromPose&json=1`;
+        const result = await this.digestPost(host, port, path, bodyStr, username, password);
+        // RWS 1.0 IK response shape: { _embedded: { _state: [{ rax_1, rax_2, ... }] } }
+        const state = result._embedded?._state?.[0];
+        if (!state) {
+            throw new Error('IK: no result in response');
+        }
+        return {
+            rax_1: +state.rax_1, rax_2: +state.rax_2, rax_3: +state.rax_3,
+            rax_4: +state.rax_4, rax_5: +state.rax_5, rax_6: +state.rax_6,
+        };
+    }
+    digestPost(host, port, path, body, user, pass) {
+        // Two-step Digest: first GET challenge, then POST with auth header
+        return new Promise((resolve, reject) => {
+            // Step 1: send no-auth POST to get the 401 challenge
+            const challenge = http.request({ method: 'POST', hostname: host, port, path, headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }, res1 => {
+                const wwwAuth = (res1.headers['www-authenticate'] ?? '');
+                res1.resume();
+                if (res1.statusCode !== 401) {
+                    reject(new Error(`IK: expected 401 challenge, got ${res1.statusCode}`));
+                    return;
+                }
+                // Parse Digest challenge
+                const realm = wwwAuth.match(/realm="([^"]+)"/)?.[1] ?? '';
+                const nonce = wwwAuth.match(/nonce="([^"]+)"/)?.[1] ?? '';
+                const qop = wwwAuth.match(/qop="([^"]+)"/)?.[1] ?? 'auth';
+                // Build auth header (RFC 2617)
+                const cnonce = crypto.randomBytes(8).toString('hex');
+                const nc = '00000001';
+                const ha1 = crypto.createHash('md5').update(`${user}:${realm}:${pass}`).digest('hex');
+                const ha2 = crypto.createHash('md5').update(`POST:${path.split('?')[0]}`).digest('hex');
+                const respH = crypto.createHash('md5').update(`${ha1}:${nonce}:${nc}:${cnonce}:${qop}:${ha2}`).digest('hex');
+                const authH = `Digest username="${user}", realm="${realm}", nonce="${nonce}", uri="${path.split('?')[0]}", qop=${qop}, nc=${nc}, cnonce="${cnonce}", response="${respH}"`;
+                // Step 2: POST with Digest auth
+                const encoded = Buffer.from(body);
+                const req2 = http.request({
+                    method: 'POST', hostname: host, port, path,
+                    headers: {
+                        Authorization: authH,
+                        'Content-Type': 'application/x-www-form-urlencoded',
+                        'Content-Length': String(encoded.length),
+                        Accept: 'application/json',
+                    },
+                }, res2 => {
+                    const chunks = [];
+                    res2.on('data', (c) => chunks.push(c));
+                    res2.on('end', () => {
+                        const raw = Buffer.concat(chunks).toString('utf8');
+                        if ((res2.statusCode ?? 0) >= 400) {
+                            let msg = `IK HTTP ${res2.statusCode}`;
+                            try {
+                                msg = JSON.parse(raw)._embedded?.status?.msg ?? msg;
+                            }
+                            catch { /* ok */ }
+                            reject(new Error(msg));
+                            return;
+                        }
+                        try {
+                            resolve(JSON.parse(raw));
+                        }
+                        catch {
+                            reject(new Error('IK: could not parse response'));
+                        }
+                    });
+                });
+                req2.on('error', reject);
+                req2.write(encoded);
+                req2.end();
+            });
+            challenge.on('error', reject);
+            challenge.end();
+        });
+    }
+}
+//# sourceMappingURL=RWS1Adapter.js.map