@xiboplayer/xmds 0.3.7 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiboplayer/xmds",
-  "version": "0.3.7",
+  "version": "0.4.0",
   "description": "XMDS SOAP client for Xibo CMS communication",
   "type": "module",
   "main": "./src/index.js",
@@ -9,7 +9,7 @@
     "./xmds": "./src/xmds.js"
   },
   "dependencies": {
-    "@xiboplayer/utils": "0.3.7"
+    "@xiboplayer/utils": "0.4.0"
   },
   "devDependencies": {
     "vitest": "^2.0.0"

package/src/rest-client.js

@@ -142,13 +142,14 @@ export class RestClient {
 
     const json = await this.restSend('POST', '/register', {
       displayName: this.config.displayName,
-      clientType: 'chromeOS',
-      clientVersion: '0.1.0',
-      clientCode: 1,
+      clientType: this.config.clientType || 'chromeOS',
+      clientVersion: this.config.clientVersion || '0.1.0',
+      clientCode: this.config.clientCode || 1,
       operatingSystem: os,
       macAddress: this.config.macAddress || 'n/a',
       xmrChannel: this.config.xmrChannel,
       xmrPubKey: this.config.xmrPubKey || '',
+      licenceResult: 'licensed',
     });
 
     return this._parseRegisterDisplayJson(json);
@@ -169,14 +170,42 @@ export class RestClient {
     }
 
     const settings = {};
+    let tags = [];
+    let commands = [];
     for (const [key, value] of Object.entries(display)) {
-      if (key === '@attributes' || key === 'commands' || key === 'file') continue;
+      if (key === '@attributes' || key === 'file') continue;
+      if (key === 'commands') {
+        // Parse commands: array of {code/commandCode, commandString} objects
+        if (Array.isArray(value)) {
+          commands = value.map(c => ({
+            commandCode: c.code || c.commandCode || '',
+            commandString: c.commandString || ''
+          }));
+        }
+        continue;
+      }
+      if (key === 'tags') {
+        // Parse tags: array of strings, or array of {tag: "value"} objects
+        if (Array.isArray(value)) {
+          tags = value.map(t => typeof t === 'object' ? (t.tag || t.value || '') : String(t)).filter(Boolean);
+        }
+        continue;
+      }
       settings[key] = typeof value === 'object' ? JSON.stringify(value) : String(value);
     }
 
     const checkRf = attrs.checkRf || '';
     const checkSchedule = attrs.checkSchedule || '';
 
+    // Extract display-level attributes from CMS (server time, status, version info)
+    const displayAttrs = {
+      date: attrs.date || display.date || null,
+      timezone: attrs.timezone || display.timezone || null,
+      status: attrs.status || display.status || null,
+      localDate: attrs.localDate || display.localDate || null,
+      version_instructions: attrs.version_instructions || display.version_instructions || null,
+    };
+
     // Extract sync group config if present (multi-display sync coordination)
     // syncGroup: "lead" if this display is leader, or leader's LAN IP if follower
     const syncConfig = display.syncGroup ? {
@@ -187,7 +216,7 @@ export class RestClient {
       isLead: String(display.syncGroup) === 'lead',
     } : null;
 
-    return { code, message, settings, checkRf, checkSchedule, syncConfig };
+    return { code, message, settings, tags, commands, displayAttrs, checkRf, checkSchedule, syncConfig };
   }
 
   /**
@@ -221,6 +250,8 @@ export class RestClient {
         md5: attrs.md5 || null,
         download: attrs.download || null,
         path,
+        saveAs: attrs.saveAs || null,
+        fileType: attrs.fileType || null,
         code: attrs.code || null,
         layoutid: attrs.layoutid || null,
         regionid: attrs.regionid || null,
@@ -228,7 +259,19 @@ export class RestClient {
       });
     }
 
-    return files;
+    // Parse purge items — files CMS wants the player to delete
+    const purgeItems = [];
+    let purgeList = json.purge?.item || [];
+    if (!Array.isArray(purgeList)) purgeList = [purgeList];
+    for (const p of purgeList) {
+      const pAttrs = p['@attributes'] || p;
+      purgeItems.push({
+        id: pAttrs.id || null,
+        storedAs: pAttrs.storedAs || null,
+      });
+    }
+
+    return { files, purge: purgeItems };
   }
 
   /**
@@ -272,6 +315,11 @@ export class RestClient {
       status.timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
     }
 
+    // Add statusDialog (summary for CMS display status page) if not provided
+    if (!status.statusDialog) {
+      status.statusDialog = `Current Layout: ${status.currentLayoutId || 'None'}`;
+    }
+
     return this.restSend('PUT', '/status', {
       statusData: status,
     });
@@ -291,13 +339,25 @@ export class RestClient {
 
   /**
    * BlackList - report broken media to CMS
-   *
-   * BlackList has no REST equivalent endpoint.
-   * Log a warning and return false.
+   * POST /blacklist → JSON acknowledgement
+   * @param {string|number} mediaId - The media ID
+   * @param {string} type - File type ('media' or 'layout')
+   * @param {string} reason - Reason for blacklisting
+   * @returns {Promise<boolean>}
    */
   async blackList(mediaId, type, reason) {
-    log.warn(`BlackList not available via REST (${type}/${mediaId}: ${reason})`);
-    return false;
+    try {
+      const result = await this.restSend('POST', '/blacklist', {
+        mediaId: String(mediaId),
+        type: type || 'media',
+        reason: reason || 'Failed to render',
+      });
+      log.info(`BlackListed ${type}/${mediaId}: ${reason}`);
+      return result?.success === true;
+    } catch (error) {
+      log.warn('BlackList failed:', error);
+      return false;
+    }
   }
 
   /**
@@ -337,6 +397,15 @@ export class RestClient {
     return result?.success === true;
   }
 
+  /**
+   * GetWeather - get current weather data for schedule criteria
+   * GET /weather → JSON weather data
+   * @returns {Promise<Object>} Weather data from CMS
+   */
+  async getWeather() {
+    return this.restGet('/weather');
+  }
+
   async submitStats(statsXml) {
     try {
       // Accept array (JSON-native) or string (XML) — send under the right key

package/src/schedule-parser.js

@@ -16,12 +16,13 @@
  */
 function parseCriteria(parentEl) {
   const criteria = [];
-  for (const criteriaEl of parentEl.querySelectorAll(':scope > criteria')) {
+  for (const child of parentEl.children) {
+    if (child.tagName !== 'criteria') continue;
     criteria.push({
-      metric: criteriaEl.getAttribute('metric') || '',
-      condition: criteriaEl.getAttribute('condition') || '',
-      type: criteriaEl.getAttribute('type') || 'string',
-      value: criteriaEl.textContent || ''
+      metric: child.getAttribute('metric') || '',
+      condition: child.getAttribute('condition') || '',
+      type: child.getAttribute('type') || 'string',
+      value: child.textContent || ''
     });
   }
   return criteria;
@@ -39,6 +40,8 @@ export function parseScheduleResponse(xml) {
 
   const schedule = {
     default: null,
+    defaultDependants: [],
+    dependants: [], // Global dependants that gate ALL layouts
     layouts: [],
     campaigns: [],
     overlays: [],
@@ -47,9 +50,29 @@ export function parseScheduleResponse(xml) {
     dataConnectors: []
   };
 
+  // Parse global dependants (root-level <dependants> — must be cached before any layout plays)
+  const scheduleEl = doc.querySelector('schedule');
+  if (scheduleEl) {
+    const globalDeps = Array.from(scheduleEl.children).filter(
+      el => el.tagName === 'dependants'
+    );
+    for (const depContainer of globalDeps) {
+      // Skip if this is nested inside <default>, <layout>, etc.
+      if (depContainer.parentElement !== scheduleEl) continue;
+      for (const fileEl of depContainer.querySelectorAll('file')) {
+        if (fileEl.textContent) schedule.dependants.push(fileEl.textContent);
+      }
+    }
+  }
+
   const defaultEl = doc.querySelector('default');
   if (defaultEl) {
     schedule.default = defaultEl.getAttribute('file');
+    // Parse dependants — files that must be cached before this layout plays
+    const defaultDeps = defaultEl.querySelectorAll('dependants > file');
+    if (defaultDeps.length > 0) {
+      schedule.defaultDependants = [...defaultDeps].map(el => el.textContent);
+    }
   }
 
   // Parse campaigns (groups of layouts with shared priority)
@@ -60,12 +83,23 @@ export function parseScheduleResponse(xml) {
       fromdt: campaignEl.getAttribute('fromdt'),
       todt: campaignEl.getAttribute('todt'),
       scheduleid: campaignEl.getAttribute('scheduleid'),
+      maxPlaysPerHour: parseInt(campaignEl.getAttribute('maxPlaysPerHour') || '0'),
+      shareOfVoice: parseInt(campaignEl.getAttribute('shareOfVoice') || '0'),
+      isGeoAware: campaignEl.getAttribute('isGeoAware') === '1',
+      geoLocation: campaignEl.getAttribute('geoLocation') || '',
+      syncEvent: campaignEl.getAttribute('syncEvent') === '1',
+      recurrenceType: campaignEl.getAttribute('recurrenceType') || null,
+      recurrenceDetail: parseInt(campaignEl.getAttribute('recurrenceDetail') || '0') || null,
+      recurrenceRepeatsOn: campaignEl.getAttribute('recurrenceRepeatsOn') || null,
+      recurrenceRange: campaignEl.getAttribute('recurrenceRange') || null,
+      criteria: parseCriteria(campaignEl),
       layouts: []
     };
 
     // Parse layouts within this campaign
     for (const layoutEl of campaignEl.querySelectorAll('layout')) {
       const fileId = layoutEl.getAttribute('file');
+      const depEls = layoutEl.querySelectorAll('dependants > file');
       campaign.layouts.push({
         id: String(fileId), // Normalized string ID for consistent type usage
         file: fileId,
@@ -80,6 +114,11 @@ export function parseScheduleResponse(xml) {
         geoLocation: layoutEl.getAttribute('geoLocation') || '',
         syncEvent: layoutEl.getAttribute('syncEvent') === '1',
         shareOfVoice: parseInt(layoutEl.getAttribute('shareOfVoice') || '0'),
+        duration: parseInt(layoutEl.getAttribute('duration') || '0'),
+        cyclePlayback: layoutEl.getAttribute('cyclePlayback') === '1',
+        groupKey: layoutEl.getAttribute('groupKey') || null,
+        playCount: parseInt(layoutEl.getAttribute('playCount') || '0'),
+        dependants: depEls.length > 0 ? [...depEls].map(el => el.textContent) : [],
         criteria: parseCriteria(layoutEl)
       });
     }
@@ -90,6 +129,7 @@ export function parseScheduleResponse(xml) {
   // Parse standalone layouts (not in campaigns)
   for (const layoutEl of doc.querySelectorAll('schedule > layout')) {
     const fileId = layoutEl.getAttribute('file');
+    const depEls = layoutEl.querySelectorAll('dependants > file');
     schedule.layouts.push({
       id: String(fileId), // Normalized string ID for consistent type usage
       file: fileId,
@@ -103,6 +143,15 @@ export function parseScheduleResponse(xml) {
       geoLocation: layoutEl.getAttribute('geoLocation') || '',
       syncEvent: layoutEl.getAttribute('syncEvent') === '1',
       shareOfVoice: parseInt(layoutEl.getAttribute('shareOfVoice') || '0'),
+      duration: parseInt(layoutEl.getAttribute('duration') || '0'),
+      cyclePlayback: layoutEl.getAttribute('cyclePlayback') === '1',
+      groupKey: layoutEl.getAttribute('groupKey') || null,
+      playCount: parseInt(layoutEl.getAttribute('playCount') || '0'),
+      recurrenceType: layoutEl.getAttribute('recurrenceType') || null,
+      recurrenceDetail: parseInt(layoutEl.getAttribute('recurrenceDetail') || '0') || null,
+      recurrenceRepeatsOn: layoutEl.getAttribute('recurrenceRepeatsOn') || null,
+      recurrenceRange: layoutEl.getAttribute('recurrenceRange') || null,
+      dependants: depEls.length > 0 ? [...depEls].map(el => el.textContent) : [],
       criteria: parseCriteria(layoutEl)
     });
   }
@@ -116,14 +165,18 @@ export function parseScheduleResponse(xml) {
         id: String(fileId), // Normalized string ID for consistent type usage
         duration: parseInt(overlayEl.getAttribute('duration') || '60'),
         file: fileId,
-        fromDt: overlayEl.getAttribute('fromdt'),
-        toDt: overlayEl.getAttribute('todt'),
+        fromdt: overlayEl.getAttribute('fromdt'),
+        todt: overlayEl.getAttribute('todt'),
         priority: parseInt(overlayEl.getAttribute('priority') || '0'),
-        scheduleId: overlayEl.getAttribute('scheduleid'),
+        scheduleid: overlayEl.getAttribute('scheduleid'),
         isGeoAware: overlayEl.getAttribute('isGeoAware') === '1',
         geoLocation: overlayEl.getAttribute('geoLocation') || '',
         syncEvent: overlayEl.getAttribute('syncEvent') === '1',
         maxPlaysPerHour: parseInt(overlayEl.getAttribute('maxPlaysPerHour') || '0'),
+        recurrenceType: overlayEl.getAttribute('recurrenceType') || null,
+        recurrenceDetail: parseInt(overlayEl.getAttribute('recurrenceDetail') || '0') || null,
+        recurrenceRepeatsOn: overlayEl.getAttribute('recurrenceRepeatsOn') || null,
+        recurrenceRange: overlayEl.getAttribute('recurrenceRange') || null,
         criteria: parseCriteria(overlayEl)
       });
     }
@@ -139,10 +192,10 @@ export function parseScheduleResponse(xml) {
         layoutCode: actionEl.getAttribute('layoutCode') || '',
         commandCode: actionEl.getAttribute('commandCode') || '',
         duration: parseInt(actionEl.getAttribute('duration') || '0'),
-        fromDt: actionEl.getAttribute('fromdt'),
-        toDt: actionEl.getAttribute('todt'),
+        fromdt: actionEl.getAttribute('fromdt'),
+        todt: actionEl.getAttribute('todt'),
         priority: parseInt(actionEl.getAttribute('priority') || '0'),
-        scheduleId: actionEl.getAttribute('scheduleid'),
+        scheduleid: actionEl.getAttribute('scheduleid'),
         isGeoAware: actionEl.getAttribute('isGeoAware') === '1',
         geoLocation: actionEl.getAttribute('geoLocation') || ''
       });
@@ -152,20 +205,27 @@ export function parseScheduleResponse(xml) {
   // Parse server commands (remote control)
   for (const cmdEl of doc.querySelectorAll('schedule > command')) {
     schedule.commands.push({
-      code: cmdEl.getAttribute('command') || '',
+      code: cmdEl.getAttribute('code') || '',
       date: cmdEl.getAttribute('date') || ''
     });
   }
 
   // Parse data connectors (real-time data sources for widgets)
-  for (const dcEl of doc.querySelectorAll('dataconnector')) {
-    schedule.dataConnectors.push({
-      id: dcEl.getAttribute('id') || '',
-      dataConnectorId: dcEl.getAttribute('dataConnectorId') || '',
-      dataKey: dcEl.getAttribute('dataKey') || '',
-      url: dcEl.getAttribute('url') || '',
-      updateInterval: parseInt(dcEl.getAttribute('updateInterval') || '300', 10)
-    });
+  // Spec: <dataConnectors><connector dataSetId="" dataParams="" js=""/></dataConnectors>
+  const dataConnectorsContainer = doc.querySelector('dataConnectors');
+  if (dataConnectorsContainer) {
+    for (const dcEl of dataConnectorsContainer.querySelectorAll('connector')) {
+      schedule.dataConnectors.push({
+        id: dcEl.getAttribute('id') || '',
+        dataConnectorId: dcEl.getAttribute('dataConnectorId') || '',
+        dataSetId: dcEl.getAttribute('dataSetId') || '',
+        dataKey: dcEl.getAttribute('dataKey') || '',
+        dataParams: dcEl.getAttribute('dataParams') || '',
+        js: dcEl.getAttribute('js') || '',
+        url: dcEl.getAttribute('url') || '',
+        updateInterval: parseInt(dcEl.getAttribute('updateInterval') || '300', 10)
+      });
+    }
   }
 
   return schedule;

package/src/schedule-parser.test.js

@@ -0,0 +1,282 @@
+/**
+ * Schedule Parser Tests
+ *
+ * Tests for XML parsing of schedule responses, ensuring all attributes
+ * are correctly extracted — especially recurrence/dayparting fields.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { parseScheduleResponse } from './schedule-parser.js';
+
+describe('parseScheduleResponse', () => {
+  it('should parse default layout', () => {
+    const xml = '<schedule><default file="100.xlf"/></schedule>';
+    const result = parseScheduleResponse(xml);
+    expect(result.default).toBe('100.xlf');
+  });
+
+  it('should parse standalone layout with basic attributes', () => {
+    const xml = `<schedule>
+      <layout file="200.xlf" fromdt="2025-01-01 09:00:00" todt="2025-12-31 17:00:00"
+              scheduleid="5" priority="3"/>
+    </schedule>`;
+    const result = parseScheduleResponse(xml);
+    expect(result.layouts).toHaveLength(1);
+    expect(result.layouts[0].file).toBe('200.xlf');
+    expect(result.layouts[0].priority).toBe(3);
+    expect(result.layouts[0].scheduleid).toBe('5');
+  });
+
+  it('should parse recurrence attributes on standalone layouts', () => {
+    const xml = `<schedule>
+      <layout file="300.xlf" fromdt="2025-01-06 09:00:00" todt="2025-01-06 17:00:00"
+              scheduleid="10" priority="1"
+              recurrenceType="Week"
+              recurrenceRepeatsOn="1,2,3,4,5"
+              recurrenceRange="2025-12-31 23:59:59"/>
+    </schedule>`;
+    const result = parseScheduleResponse(xml);
+    const layout = result.layouts[0];
+
+    expect(layout.recurrenceType).toBe('Week');
+    expect(layout.recurrenceRepeatsOn).toBe('1,2,3,4,5');
+    expect(layout.recurrenceRange).toBe('2025-12-31 23:59:59');
+  });
+
+  it('should set recurrence fields to null when absent', () => {
+    const xml = `<schedule>
+      <layout file="400.xlf" fromdt="2025-01-01 00:00:00" todt="2025-12-31 23:59:59"
+              scheduleid="20" priority="0"/>
+    </schedule>`;
+    const result = parseScheduleResponse(xml);
+    const layout = result.layouts[0];
+
+    expect(layout.recurrenceType).toBeNull();
+    expect(layout.recurrenceRepeatsOn).toBeNull();
+    expect(layout.recurrenceRange).toBeNull();
+  });
+
+  it('should parse recurrence attributes on campaigns', () => {
+    const xml = `<schedule>
+      <campaign id="c1" priority="5" fromdt="2025-01-06 08:00:00" todt="2025-01-06 18:00:00"
+                scheduleid="30"
+                recurrenceType="Week"
+                recurrenceRepeatsOn="6,7">
+        <layout file="500.xlf"/>
+        <layout file="501.xlf"/>
+      </campaign>
+    </schedule>`;
+    const result = parseScheduleResponse(xml);
+
+    expect(result.campaigns).toHaveLength(1);
+    const campaign = result.campaigns[0];
+    expect(campaign.recurrenceType).toBe('Week');
+    expect(campaign.recurrenceRepeatsOn).toBe('6,7');
+    expect(campaign.recurrenceRange).toBeNull();
+    expect(campaign.layouts).toHaveLength(2);
+  });
+
+  it('should parse recurrence attributes on overlays', () => {
+    const xml = `<schedule>
+      <overlays>
+        <overlay file="600.xlf" fromdt="2025-01-01 12:00:00" todt="2025-01-01 13:00:00"
+                 scheduleid="40" priority="2" duration="30"
+                 recurrenceType="Week"
+                 recurrenceRepeatsOn="1,3,5"/>
+      </overlays>
+    </schedule>`;
+    const result = parseScheduleResponse(xml);
+
+    expect(result.overlays).toHaveLength(1);
+    const overlay = result.overlays[0];
+    expect(overlay.recurrenceType).toBe('Week');
+    expect(overlay.recurrenceRepeatsOn).toBe('1,3,5');
+    expect(overlay.recurrenceRange).toBeNull();
+  });
+
+  it('should parse criteria on layouts', () => {
+    const xml = `<schedule>
+      <layout file="700.xlf" fromdt="2025-01-01 00:00:00" todt="2025-12-31 23:59:59"
+              scheduleid="50" priority="1">
+        <criteria metric="dayOfWeek" condition="equals" type="string">Monday</criteria>
+      </layout>
+    </schedule>`;
+    const result = parseScheduleResponse(xml);
+    const layout = result.layouts[0];
+
+    expect(layout.criteria).toHaveLength(1);
+    expect(layout.criteria[0].metric).toBe('dayOfWeek');
+    expect(layout.criteria[0].condition).toBe('equals');
+    expect(layout.criteria[0].value).toBe('Monday');
+  });
+
+  it('should parse dependants on default layout', () => {
+    const xml = `<schedule>
+      <default file="100.xlf">
+        <dependants><file>bg.jpg</file><file>logo.png</file></dependants>
+      </default>
+    </schedule>`;
+    const result = parseScheduleResponse(xml);
+    expect(result.default).toBe('100.xlf');
+    expect(result.defaultDependants).toEqual(['bg.jpg', 'logo.png']);
+  });
+
+  it('should parse dependants on standalone layouts', () => {
+    const xml = `<schedule>
+      <layout file="200.xlf" fromdt="2025-01-01 00:00:00" todt="2025-12-31 23:59:59"
+              scheduleid="5" priority="1">
+        <dependants><file>video.mp4</file></dependants>
+      </layout>
+    </schedule>`;
+    const result = parseScheduleResponse(xml);
+    expect(result.layouts[0].dependants).toEqual(['video.mp4']);
+  });
+
+  it('should parse dependants on campaign layouts', () => {
+    const xml = `<schedule>
+      <campaign id="c1" priority="5" fromdt="2025-01-01 00:00:00" todt="2025-12-31 23:59:59"
+                scheduleid="30">
+        <layout file="300.xlf">
+          <dependants><file>font.woff2</file></dependants>
+        </layout>
+      </campaign>
+    </schedule>`;
+    const result = parseScheduleResponse(xml);
+    expect(result.campaigns[0].layouts[0].dependants).toEqual(['font.woff2']);
+  });
+
+  it('should return empty array when no dependants', () => {
+    const xml = `<schedule>
+      <layout file="400.xlf" fromdt="2025-01-01 00:00:00" todt="2025-12-31 23:59:59"
+              scheduleid="20" priority="0"/>
+    </schedule>`;
+    const result = parseScheduleResponse(xml);
+    expect(result.layouts[0].dependants).toEqual([]);
+  });
+
+  it('should parse duration, cyclePlayback, groupKey, playCount on standalone layouts', () => {
+    const xml = `<schedule>
+      <layout file="500.xlf" fromdt="2025-01-01 00:00:00" todt="2025-12-31 23:59:59"
+              scheduleid="60" priority="1" duration="120"
+              cyclePlayback="1" groupKey="group-A" playCount="3"/>
+    </schedule>`;
+    const result = parseScheduleResponse(xml);
+    const layout = result.layouts[0];
+    expect(layout.duration).toBe(120);
+    expect(layout.cyclePlayback).toBe(true);
+    expect(layout.groupKey).toBe('group-A');
+    expect(layout.playCount).toBe(3);
+  });
+
+  it('should parse command code attribute correctly', () => {
+    const xml = `<schedule>
+      <command code="collectNow" date="2026-01-01"/>
+      <command code="reboot" date="2026-01-02"/>
+    </schedule>`;
+    const result = parseScheduleResponse(xml);
+    expect(result.commands).toHaveLength(2);
+    expect(result.commands[0].code).toBe('collectNow');
+    expect(result.commands[1].code).toBe('reboot');
+  });
+
+  it('should parse dataConnectors with connector child elements', () => {
+    const xml = `<schedule>
+      <dataConnectors>
+        <connector id="dc1" dataSetId="42" dataParams="limit=10" js="render.js"
+                   url="http://cms.example.com/data" updateInterval="60"/>
+      </dataConnectors>
+    </schedule>`;
+    const result = parseScheduleResponse(xml);
+    expect(result.dataConnectors).toHaveLength(1);
+    expect(result.dataConnectors[0].id).toBe('dc1');
+    expect(result.dataConnectors[0].dataSetId).toBe('42');
+    expect(result.dataConnectors[0].dataParams).toBe('limit=10');
+    expect(result.dataConnectors[0].js).toBe('render.js');
+    expect(result.dataConnectors[0].url).toBe('http://cms.example.com/data');
+    expect(result.dataConnectors[0].updateInterval).toBe(60);
+  });
+
+  it('should return empty dataConnectors when no dataConnectors element', () => {
+    const xml = '<schedule><default file="0"/></schedule>';
+    const result = parseScheduleResponse(xml);
+    expect(result.dataConnectors).toEqual([]);
+  });
+
+  it('should parse global dependants from schedule root', () => {
+    const xml = `<schedule>
+      <default file="0"/>
+      <dependants><file>global-font.woff2</file><file>shared-bg.jpg</file></dependants>
+    </schedule>`;
+    const result = parseScheduleResponse(xml);
+    expect(result.dependants).toEqual(['global-font.woff2', 'shared-bg.jpg']);
+  });
+
+  it('should default global dependants to empty array', () => {
+    const xml = '<schedule><default file="0"/></schedule>';
+    const result = parseScheduleResponse(xml);
+    expect(result.dependants).toEqual([]);
+  });
+
+  it('should parse campaign-level geo/sync/shareOfVoice attributes', () => {
+    const xml = `<schedule>
+      <campaign id="c1" priority="5" fromdt="2025-01-01 00:00:00" todt="2025-12-31 23:59:59"
+                scheduleid="30" shareOfVoice="50" isGeoAware="1"
+                geoLocation="51.5,-0.1" syncEvent="1">
+        <layout file="500.xlf"/>
+      </campaign>
+    </schedule>`;
+    const result = parseScheduleResponse(xml);
+    const campaign = result.campaigns[0];
+    expect(campaign.shareOfVoice).toBe(50);
+    expect(campaign.isGeoAware).toBe(true);
+    expect(campaign.geoLocation).toBe('51.5,-0.1');
+    expect(campaign.syncEvent).toBe(true);
+  });
+
+  it('should parse criteria on campaigns', () => {
+    const xml = `<schedule>
+      <campaign id="c1" priority="5" fromdt="2025-01-01 00:00:00" todt="2025-12-31 23:59:59"
+                scheduleid="30">
+        <criteria metric="temperature" condition="gt" type="number">25</criteria>
+        <layout file="500.xlf"/>
+      </campaign>
+    </schedule>`;
+    const result = parseScheduleResponse(xml);
+    expect(result.campaigns[0].criteria).toHaveLength(1);
+    expect(result.campaigns[0].criteria[0].metric).toBe('temperature');
+    expect(result.campaigns[0].criteria[0].value).toBe('25');
+  });
+
+  it('should parse duration, cyclePlayback, groupKey, playCount on campaign layouts', () => {
+    const xml = `<schedule>
+      <campaign id="c1" priority="5" fromdt="2025-01-01 00:00:00" todt="2025-12-31 23:59:59"
+                scheduleid="30">
+        <layout file="500.xlf" duration="90" cyclePlayback="1" groupKey="group-B" playCount="2"/>
+      </campaign>
+    </schedule>`;
+    const result = parseScheduleResponse(xml);
+    const layout = result.campaigns[0].layouts[0];
+    expect(layout.duration).toBe(90);
+    expect(layout.cyclePlayback).toBe(true);
+    expect(layout.groupKey).toBe('group-B');
+    expect(layout.playCount).toBe(2);
+  });
+
+  it('should use consistent lowercase casing for fromdt/todt/scheduleid on overlays', () => {
+    const xml = `<schedule>
+      <overlays>
+        <overlay file="600.xlf" fromdt="2025-01-01 12:00:00" todt="2025-01-01 13:00:00"
+                 scheduleid="40" priority="2"/>
+      </overlays>
+    </schedule>`;
+    const result = parseScheduleResponse(xml);
+    const overlay = result.overlays[0];
+    expect(overlay.fromdt).toBe('2025-01-01 12:00:00');
+    expect(overlay.todt).toBe('2025-01-01 13:00:00');
+    expect(overlay.scheduleid).toBe('40');
+    // Verify old camelCase properties are NOT present
+    expect(overlay.fromDt).toBeUndefined();
+    expect(overlay.toDt).toBeUndefined();
+    expect(overlay.scheduleId).toBeUndefined();
+  });
+});

package/src/xmds-client.js

@@ -149,13 +149,14 @@ export class XmdsClient {
       serverKey: this.config.cmsKey,
       hardwareKey: this.config.hardwareKey,
       displayName: this.config.displayName,
-      clientType: 'chromeOS',
-      clientVersion: '0.1.0',
-      clientCode: '1',
+      clientType: this.config.clientType || 'chromeOS',
+      clientVersion: this.config.clientVersion || '0.1.0',
+      clientCode: this.config.clientCode || '1',
       operatingSystem: os,
       macAddress: this.config.macAddress || 'n/a',
-      xmrChannel: this.config.xmrChannel,
-      xmrPubKey: this.config.xmrPubKey || ''
+      xmrChannel: this.config.xmrChannel || '',
+      xmrPubKey: this.config.xmrPubKey || '',
+      licenceResult: 'licensed'
     });
 
     return this.parseRegisterDisplayResponse(xml);
@@ -181,16 +182,54 @@ export class XmdsClient {
     }
 
     const settings = {};
+    const tags = [];
+    const commands = [];
     for (const child of display.children) {
-      if (!['commands', 'file'].includes(child.tagName.toLowerCase())) {
-        settings[child.tagName] = child.textContent;
+      const name = child.tagName.toLowerCase();
+      if (name === 'file') continue;
+      if (name === 'commands') {
+        // Parse <commands><command code="xyz" commandString="args"/></commands>
+        for (const cmdEl of child.querySelectorAll('command')) {
+          commands.push({
+            commandCode: cmdEl.getAttribute('code') || cmdEl.getAttribute('commandCode') || '',
+            commandString: cmdEl.getAttribute('commandString') || ''
+          });
+        }
+        continue;
       }
+      if (name === 'tags') {
+        // Parse <tags><tag>value</tag>...</tags> into array
+        for (const tagEl of child.querySelectorAll('tag')) {
+          if (tagEl.textContent) tags.push(tagEl.textContent);
+        }
+        continue;
+      }
+      settings[child.tagName] = child.textContent;
     }
 
     const checkRf = display.getAttribute('checkRf') || '';
     const checkSchedule = display.getAttribute('checkSchedule') || '';
 
-    return { code, message, settings, checkRf, checkSchedule };
+    // Extract display-level attributes from CMS (server time, status, version info)
+    const displayAttrs = {
+      date: display.getAttribute('date') || null,
+      timezone: display.getAttribute('timezone') || null,
+      status: display.getAttribute('status') || null,
+      localDate: display.getAttribute('localDate') || null,
+      version_instructions: display.getAttribute('version_instructions') || null,
+    };
+
+    // Extract sync group config if present (multi-display sync coordination)
+    const syncGroupVal = settings.syncGroup || null;
+    const syncConfig = syncGroupVal ? {
+      syncGroup: syncGroupVal,
+      syncPublisherPort: parseInt(settings.syncPublisherPort || '9590', 10),
+      syncSwitchDelay: parseInt(settings.syncSwitchDelay || '750', 10),
+      syncVideoPauseDelay: parseInt(settings.syncVideoPauseDelay || '100', 10),
+      isLead: syncGroupVal === 'lead',
+    } : null;
+
+    return { code, message, settings, tags, commands, displayAttrs, checkRf, checkSchedule, syncConfig };
   }
 
   /**
@@ -221,6 +260,8 @@ export class XmdsClient {
         md5: fileEl.getAttribute('md5'),
         download: fileEl.getAttribute('download'),
         path: fileEl.getAttribute('path'),
+        saveAs: fileEl.getAttribute('saveAs') || null,
+        fileType: fileEl.getAttribute('fileType') || null,
         code: fileEl.getAttribute('code'),
         layoutid: fileEl.getAttribute('layoutid'),
         regionid: fileEl.getAttribute('regionid'),
@@ -228,7 +269,19 @@ export class XmdsClient {
       });
     }
 
-    return files;
+    // Parse purge block — files CMS wants the player to delete
+    const purgeItems = [];
+    const purgeEl = doc.querySelector('purge');
+    if (purgeEl) {
+      for (const itemEl of purgeEl.querySelectorAll('item')) {
+        purgeItems.push({
+          id: itemEl.getAttribute('id'),
+          storedAs: itemEl.getAttribute('storedAs')
+        });
+      }
+    }
+
+    return { files, purge: purgeItems };
   }
 
   /**
@@ -277,6 +330,11 @@ export class XmdsClient {
       status.timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
     }
 
+    // Add statusDialog (summary for CMS display status page) if not provided
+    if (!status.statusDialog) {
+      status.statusDialog = `Current Layout: ${status.currentLayoutId || 'None'}`;
+    }
+
     return await this.call('NotifyStatus', {
       serverKey: this.config.cmsKey,
       hardwareKey: this.config.hardwareKey,
@@ -367,6 +425,17 @@ export class XmdsClient {
     });
   }
 
+  /**
+   * GetWeather - get current weather data for schedule criteria
+   * @returns {Promise<string>} Weather data XML from CMS
+   */
+  async getWeather() {
+    return this.call('GetWeather', {
+      serverKey: this.config.cmsKey,
+      hardwareKey: this.config.hardwareKey
+    });
+  }
+
   async submitStats(statsXml) {
     try {
       const xml = await this.call('SubmitStats', {

package/src/xmds.overlays.test.js

@@ -25,8 +25,8 @@ describe('Schedule Parsing - Overlays', () => {
       expect(schedule.overlays[0].file).toBe('101.xlf');
       expect(schedule.overlays[0].duration).toBe(60);
       expect(schedule.overlays[0].priority).toBe(10);
-      expect(schedule.overlays[0].fromDt).toBe('2026-01-01 00:00:00');
-      expect(schedule.overlays[0].toDt).toBe('2026-12-31 23:59:59');
+      expect(schedule.overlays[0].fromdt).toBe('2026-01-01 00:00:00');
+      expect(schedule.overlays[0].todt).toBe('2026-12-31 23:59:59');
     });
 
     it('should parse multiple overlays', () => {

package/src/xmds.rest.test.js

@@ -353,17 +353,18 @@ describe('RestClient - RequiredFiles', () => {
       ]
     }, { etag: '"files-v1"' }));
 
-    const files = await client.requiredFiles();
+    const result = await client.requiredFiles();
 
-    expect(files).toHaveLength(3);
-    expect(files[0]).toEqual({
+    expect(result.files).toHaveLength(3);
+    expect(result.files[0]).toEqual(expect.objectContaining({
       type: 'media', id: '42', size: 1024, md5: 'abc', download: 'http',
       path: '/media/42.jpg', code: null, layoutid: null, regionid: null, mediaid: null,
-    });
-    expect(files[1].type).toBe('layout');
-    expect(files[2].layoutid).toBe('10');
-    expect(files[2].regionid).toBe('5');
-    expect(files[2].mediaid).toBe('99');
+    }));
+    expect(result.files[1].type).toBe('layout');
+    expect(result.files[2].layoutid).toBe('10');
+    expect(result.files[2].regionid).toBe('5');
+    expect(result.files[2].mediaid).toBe('99');
+    expect(result.purge).toEqual([]);
   });
 
   it('should handle single file (not array)', async () => {
@@ -371,16 +372,16 @@ describe('RestClient - RequiredFiles', () => {
       file: { '@attributes': { type: 'media', id: '1', size: '100', md5: 'x' } }
     }));
 
-    const files = await client.requiredFiles();
-    expect(files).toHaveLength(1);
-    expect(files[0].id).toBe('1');
+    const result = await client.requiredFiles();
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0].id).toBe('1');
   });
 
   it('should handle empty file list', async () => {
     mockFetch.mockResolvedValue(jsonResponse({}));
 
-    const files = await client.requiredFiles();
-    expect(files).toHaveLength(0);
+    const result = await client.requiredFiles();
+    expect(result.files).toHaveLength(0);
   });
 
   it('should use ETag caching', async () => {
@@ -407,12 +408,12 @@ describe('RestClient - RequiredFiles', () => {
 
     const result = client._parseRequiredFilesJson(json);
 
-    expect(result[0].type).toBe('media');
-    expect(result[0].id).toBe('42');
-    expect(result[0].size).toBe(1024);
-    expect(result[0].md5).toBe('abc');
-    expect(result[0].download).toBe('http');
-    expect(result[0].path).toBe('/media/42.jpg');
+    expect(result.files[0].type).toBe('media');
+    expect(result.files[0].id).toBe('42');
+    expect(result.files[0].size).toBe(1024);
+    expect(result.files[0].md5).toBe('abc');
+    expect(result.files[0].download).toBe('http');
+    expect(result.files[0].path).toBe('/media/42.jpg');
   });
 });
 
@@ -676,10 +677,41 @@ describe('RestClient - MediaInventory', () => {
   });
 });
 
-// ─── BlackList (always SOAP) ─────────────────────────────────────────
+// ─── BlackList ───────────────────────────────────────────────────────
 
 describe('RestClient - BlackList', () => {
-  it('should return false since REST has no BlackList endpoint', async () => {
+  let mockFetch;
+
+  beforeEach(() => {
+    mockFetch = vi.fn();
+    global.fetch = mockFetch;
+  });
+
+  it('should POST to /blacklist endpoint', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      headers: { get: () => 'application/json' },
+      json: () => Promise.resolve({ success: true }),
+    });
+
+    const client = createRestClient();
+    const result = await client.blackList('42', 'media', 'Broken file');
+
+    expect(result).toBe(true);
+    expect(mockFetch).toHaveBeenCalledWith(
+      expect.stringContaining('/blacklist'),
+      expect.objectContaining({ method: 'POST' })
+    );
+    const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+    expect(body.mediaId).toBe('42');
+    expect(body.type).toBe('media');
+    expect(body.reason).toBe('Broken file');
+  });
+
+  it('should return false on failure', async () => {
+    mockFetch.mockRejectedValue(new Error('Network error'));
+
     const client = createRestClient();
     const result = await client.blackList('42', 'media', 'Broken');
     expect(result).toBe(false);

package/src/xmds.test.js

@@ -883,6 +883,105 @@ describe('XmdsClient - NotifyStatus', () => {
   });
 });
 
+describe('XmdsClient - GetWeather', () => {
+  let client;
+  let mockFetch;
+
+  beforeEach(() => {
+    client = new XmdsClient({
+      cmsAddress: 'https://cms.example.com',
+      cmsKey: 'test-server-key',
+      hardwareKey: 'test-hardware-key',
+      retryOptions: { maxRetries: 0 }
+    });
+
+    mockFetch = vi.fn();
+    global.fetch = mockFetch;
+  });
+
+  it('should build correct SOAP envelope for GetWeather', async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      text: async () => `<?xml version="1.0"?>
+<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
+  <soap:Body>
+    <GetWeatherResponse>
+      <weather>{"temperature":22,"humidity":65,"windSpeed":10,"condition":"Clear","cloudCover":15}</weather>
+    </GetWeatherResponse>
+  </soap:Body>
+</soap:Envelope>`
+    });
+
+    await client.getWeather();
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'https://cms.example.com/xmds.php?v=5&method=GetWeather',
+      expect.objectContaining({
+        method: 'POST',
+        headers: {
+          'Content-Type': 'text/xml; charset=utf-8'
+        }
+      })
+    );
+
+    const body = mockFetch.mock.calls[0][1].body;
+    expect(body).toContain('<tns:GetWeather>');
+    expect(body).toContain('<serverKey xsi:type="xsd:string">test-server-key</serverKey>');
+    expect(body).toContain('<hardwareKey xsi:type="xsd:string">test-hardware-key</hardwareKey>');
+  });
+
+  it('should return weather data from SOAP response', async () => {
+    const weatherJson = '{"temperature":22,"humidity":65,"windSpeed":10,"condition":"Clear","cloudCover":15}';
+    mockFetch.mockResolvedValue({
+      ok: true,
+      text: async () => `<?xml version="1.0"?>
+<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
+  <soap:Body>
+    <GetWeatherResponse>
+      <weather>${weatherJson}</weather>
+    </GetWeatherResponse>
+  </soap:Body>
+</soap:Envelope>`
+    });
+
+    const result = await client.getWeather();
+    expect(result).toBe(weatherJson);
+  });
+
+  it('should handle SOAP fault', async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      text: async () => `<?xml version="1.0"?>
+<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
+  <soap:Body>
+    <soap:Fault>
+      <faultcode>Server</faultcode>
+      <faultstring>Weather service unavailable</faultstring>
+    </soap:Fault>
+  </soap:Body>
+</soap:Envelope>`
+    });
+
+    await expect(client.getWeather()).rejects.toThrow('SOAP Fault: Weather service unavailable');
+  });
+
+  it('should handle HTTP errors', async () => {
+    mockFetch.mockResolvedValue({
+      ok: false,
+      status: 500,
+      statusText: 'Internal Server Error'
+    });
+
+    await expect(client.getWeather()).rejects.toThrow('XMDS GetWeather failed: 500 Internal Server Error');
+  });
+
+  it('should handle network errors', async () => {
+    mockFetch.mockRejectedValue(new Error('Network error'));
+
+    await expect(client.getWeather()).rejects.toThrow('Network error');
+  });
+});
+
 describe('XmdsClient - MediaInventory', () => {
   let client;
   let mockFetch;