@tomorrowos/sdk 0.2.4 → 0.3.0

package/dist/tomorrowos.js

@@ -4,6 +4,8 @@ import fs from "fs/promises";
 import http from "http";
 import path from "path";
 import { WebSocket, WebSocketServer } from "ws";
+import { generateRandomPairingCode, isValidPairingCodeFormat, normalizePairingCode } from "./pairing-code.js";
+import { PlaylistCatalog } from "./playlist-catalog.js";
 import { MemoryStore } from "./store/memory-store.js";
 function formatDurationMs(ms) {
     if (!Number.isFinite(ms) || ms < 0)
@@ -23,8 +25,16 @@ function formatDurationMs(ms) {
     parts.push(`${seconds}s`);
     return parts.join(" ");
 }
-function createSixDigitCode() {
-    return Math.floor(100000 + Math.random() * 900000).toString();
+function resolveHelloDeviceId(msg) {
+    const serial = typeof msg.serialNumber === "string" && msg.serialNumber.trim()
+        ? msg.serialNumber.trim()
+        : null;
+    if (serial)
+        return serial;
+    const deviceId = typeof msg.deviceId === "string" && msg.deviceId.trim()
+        ? msg.deviceId.trim()
+        : null;
+    return deviceId;
 }
 const MAX_MEDIA_UPLOAD_BYTES = 100 * 1024 * 1024;
 async function readJsonBody(req) {
@@ -71,6 +81,7 @@ function parseDevicePath(pathname) {
 export class TomorrowOS extends EventEmitter {
     brand;
     store;
+    playlists;
     devices = new Map();
     pendingDeviceMeta = new Map();
     httpServer = null;
@@ -81,42 +92,81 @@ export class TomorrowOS extends EventEmitter {
         super();
         this.brand = options.brand;
         this.store = options.store ?? new MemoryStore();
+        this.playlists = new PlaylistCatalog(this.store);
     }
-    /** Verify a 6-digit pairing code (same as POST /pairing/verify). */
+    /** Push all device assignments using latest playlist definitions (e.g. after reboot). */
+    async pushLatestPolicyToDevice(deviceId) {
+        const id = String(deviceId || "").trim();
+        const assignments = await this.store.getDeviceAssignments(id);
+        if (assignments.length === 0)
+            return { pushed: false };
+        const built = await this.playlists.buildPolicyForDevice(id, { useLatest: true });
+        const ws = this.devices.get(id);
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            return { pushed: false, policy: built.policy };
+        }
+        await this.sendDeviceCommand(id, "device.content.setPolicy", {
+            policy: built.policy
+        });
+        await this.recordPolicyPush(id);
+        return { pushed: true, policy: built.policy };
+    }
+    async sendDeviceCommand(deviceId, method, params) {
+        const ws = this.devices.get(deviceId);
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            throw Object.assign(new Error("Device not connected"), { code: "DEVICE_OFFLINE" });
+        }
+        return this.sendCommandToSocket(ws, deviceId, method, params);
+    }
+    /** Verify a 6-character alphanumeric pairing code (POST /pairing/verify). */
     async pairingVerify(code) {
-        const record = await this.store.getPendingCode(code);
-        if (!record) {
-            const err = new Error("Invalid or expired code");
+        const normalized = normalizePairingCode(code);
+        if (!isValidPairingCodeFormat(normalized)) {
+            const err = new Error("Invalid pairing code format");
+            err.code = "PAIRING_INVALID";
+            throw err;
+        }
+        let deviceId;
+        const registry = await this.store.getDeviceRegistryByCode(normalized);
+        if (registry) {
+            deviceId = registry.deviceId;
+        }
+        else {
+            const pending = await this.store.getPendingCode(normalized);
+            deviceId = pending?.deviceId;
+        }
+        if (!deviceId) {
+            const err = new Error("Invalid or unknown pairing code");
             err.code = "PAIRING_INVALID";
             throw err;
         }
         const pairingToken = randomBytes(32).toString("hex");
         const pairedAt = new Date().toISOString();
-        const meta = this.pendingDeviceMeta.get(record.deviceId);
+        const meta = this.pendingDeviceMeta.get(deviceId);
         const now = pairedAt;
-        await this.store.setPairedDevice(record.deviceId, {
+        await this.store.setPairedDevice(deviceId, {
             pairingToken,
             pairedAt,
             deviceName: meta?.deviceName,
             platform: meta?.platform,
             system: meta?.system,
             lastBootAt: meta?.bootedAt ?? now,
-            lastOnlineAt: this.isDeviceConnected(record.deviceId) ? now : undefined,
-            lastOfflineAt: this.isDeviceConnected(record.deviceId) ? undefined : now
+            lastOnlineAt: this.isDeviceConnected(deviceId) ? now : undefined,
+            lastOfflineAt: this.isDeviceConnected(deviceId) ? undefined : now
         });
-        await this.store.deletePendingCode(code);
-        const ws = this.devices.get(record.deviceId);
+        await this.store.deletePendingCode(normalized);
+        const ws = this.devices.get(deviceId);
         if (ws && ws.readyState === WebSocket.OPEN) {
             ws.send(JSON.stringify({
                 type: "pairing.verified",
                 method: "tomorrowos.pairing.verify",
-                deviceId: record.deviceId,
+                deviceId,
                 pairingToken
             }));
-            void this.refreshPairedDeviceInfo(record.deviceId);
+            void this.refreshPairedDeviceInfo(deviceId);
         }
-        this.emit("device.paired", { deviceId: record.deviceId });
-        return { deviceId: record.deviceId };
+        this.emit("device.paired", { deviceId });
+        return { deviceId };
     }
     /** Remove pairing for a device and notify it over WebSocket if connected. */
     async pairingUnpair(deviceId) {
@@ -149,8 +199,10 @@ export class TomorrowOS extends EventEmitter {
     async listDevices() {
         const entries = await this.store.listPairedDevices();
         const now = Date.now();
-        return entries.map(({ deviceId, record }) => {
+        return Promise.all(entries.map(async ({ deviceId, record }) => {
             const connected = this.isDeviceConnected(deviceId);
+            const reg = await this.store.getDeviceRegistry(deviceId);
+            const assignments = await this.store.getDeviceAssignments(deviceId);
             let screenOnlineActive = false;
             let screenOnlineLabel = "Not active";
             if (connected && record.lastBootAt) {
@@ -163,10 +215,18 @@ export class TomorrowOS extends EventEmitter {
             const screenOnlineSince = connected && record.lastBootAt ? record.lastBootAt : null;
             return {
                 deviceId,
+                pairingCode: reg?.permanentPairingCode ?? null,
+                publishedPlaylists: assignments.map((a) => ({
+                    playlistId: a.playlistId,
+                    name: a.snapshot.name,
+                    version: a.publishedVersion,
+                    publishedAt: a.publishedAt
+                })),
                 connected,
                 deviceName: record.deviceName ?? null,
                 platform: record.platform ?? null,
                 system: record.system ?? null,
+                serialNumber: reg?.serialNumber ?? deviceId,
                 pairedAt: record.pairedAt,
                 lastBootAt: record.lastBootAt ?? null,
                 lastOnlineAt: record.lastOnlineAt ?? null,
@@ -176,7 +236,7 @@ export class TomorrowOS extends EventEmitter {
                 screenOnlineLabel,
                 screenOnlineSince
             };
-        });
+        }));
     }
     isDeviceConnected(deviceId) {
         const ws = this.devices.get(deviceId);
@@ -188,9 +248,37 @@ export class TomorrowOS extends EventEmitter {
             deviceName: typeof msg.deviceName === "string" ? msg.deviceName : undefined,
             system: typeof msg.system === "string" ? msg.system : undefined,
             bootedAt: typeof msg.bootedAt === "string" ? msg.bootedAt : undefined,
-            playerVersion: typeof msg.playerVersion === "string" ? msg.playerVersion : undefined
+            playerVersion: typeof msg.playerVersion === "string" ? msg.playerVersion : undefined,
+            serialNumber: typeof msg.serialNumber === "string" ? msg.serialNumber : deviceId
         });
     }
+    async getOrCreatePermanentPairingCode(deviceId, serialNumber) {
+        const existing = await this.store.getDeviceRegistry(deviceId);
+        if (existing?.permanentPairingCode) {
+            await this.store.setDeviceRegistry(deviceId, {
+                ...existing,
+                serialNumber: serialNumber ?? existing.serialNumber ?? deviceId,
+                lastHelloAt: Date.now()
+            });
+            return existing.permanentPairingCode;
+        }
+        for (let attempt = 0; attempt < 32; attempt += 1) {
+            const code = generateRandomPairingCode();
+            const collision = await this.store.getDeviceRegistryByCode(code);
+            if (collision && collision.deviceId !== deviceId)
+                continue;
+            const now = Date.now();
+            await this.store.setDeviceRegistry(deviceId, {
+                permanentPairingCode: code,
+                codeCreatedAt: now,
+                serialNumber: serialNumber ?? deviceId,
+                firstSeenAt: now,
+                lastHelloAt: now
+            });
+            return code;
+        }
+        throw new Error("Failed to allocate unique pairing code");
+    }
     async mergePairedRecord(deviceId, patch) {
         const existing = await this.store.getPairedDevice(deviceId);
         if (!existing)
@@ -496,6 +584,105 @@ export class TomorrowOS extends EventEmitter {
                 sendJson(res, 200, { status: "success", devices });
                 return;
             }
+            if (req.method === "GET" && pathname === "/playlists") {
+                const playlists = await this.playlists.listPlaylists();
+                sendJson(res, 200, { status: "success", playlists });
+                return;
+            }
+            if (req.method === "POST" && pathname === "/playlists") {
+                const body = (await readJsonBody(req));
+                try {
+                    const saved = await this.playlists.savePlaylist({
+                        id: typeof body.id === "string" ? body.id : undefined,
+                        name: String(body.name ?? ""),
+                        schedule: body.schedule && typeof body.schedule === "object"
+                            ? body.schedule
+                            : undefined,
+                        items: Array.isArray(body.items) ? body.items : []
+                    });
+                    sendJson(res, 200, { status: "success", playlist: saved });
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : "Save failed";
+                    sendJson(res, 400, { status: "failed", error: msg });
+                }
+                return;
+            }
+            const playlistDelete = /^\/playlists\/([^/]+)$/.exec(pathname);
+            if (req.method === "DELETE" && playlistDelete) {
+                const playlistId = decodeURIComponent(playlistDelete[1]);
+                try {
+                    const retired = await this.playlists.retirePlaylist(playlistId);
+                    sendJson(res, 200, { status: "success", playlist: retired });
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : "Delete failed";
+                    sendJson(res, 400, { status: "failed", error: msg });
+                }
+                return;
+            }
+            const deviceAssignmentsGet = /^\/device\/([^/]+)\/assignments$/.exec(pathname);
+            if (req.method === "GET" && deviceAssignmentsGet) {
+                const deviceId = decodeURIComponent(deviceAssignmentsGet[1]);
+                const assignments = await this.playlists.getDeviceAssignments(deviceId);
+                sendJson(res, 200, { status: "success", assignments });
+                return;
+            }
+            const deviceAssignmentsPost = /^\/device\/([^/]+)\/assignments$/.exec(pathname);
+            if (req.method === "POST" && deviceAssignmentsPost) {
+                const deviceId = decodeURIComponent(deviceAssignmentsPost[1]);
+                const body = (await readJsonBody(req));
+                const ws = this.devices.get(deviceId);
+                if (!ws || ws.readyState !== WebSocket.OPEN) {
+                    sendJson(res, 404, { status: "failed", error: "Device not connected" });
+                    return;
+                }
+                try {
+                    let built;
+                    if (body.useLatest === true) {
+                        built = await this.playlists.buildPolicyForDevice(deviceId, {
+                            useLatest: true
+                        });
+                    }
+                    else {
+                        const ids = Array.isArray(body.playlistIds) ? body.playlistIds : [];
+                        built = await this.playlists.publishPlaylistsToDevice(deviceId, ids);
+                    }
+                    const result = await this.sendDeviceCommand(deviceId, "device.content.setPolicy", {
+                        policy: built.policy
+                    });
+                    await this.recordPolicyPush(deviceId);
+                    sendJson(res, 200, { status: "success", policy: built.policy, result });
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : "Publish failed";
+                    sendJson(res, 400, { status: "failed", error: msg });
+                }
+                return;
+            }
+            const deviceAssignmentDelete = /^\/device\/([^/]+)\/assignments\/([^/]+)$/.exec(pathname);
+            if (req.method === "DELETE" && deviceAssignmentDelete) {
+                const deviceId = decodeURIComponent(deviceAssignmentDelete[1]);
+                const playlistId = decodeURIComponent(deviceAssignmentDelete[2]);
+                const ws = this.devices.get(deviceId);
+                if (!ws || ws.readyState !== WebSocket.OPEN) {
+                    sendJson(res, 404, { status: "failed", error: "Device not connected" });
+                    return;
+                }
+                try {
+                    const built = await this.playlists.removePlaylistFromDevice(deviceId, playlistId);
+                    const result = await this.sendDeviceCommand(deviceId, "device.content.setPolicy", {
+                        policy: built.policy
+                    });
+                    await this.recordPolicyPush(deviceId);
+                    sendJson(res, 200, { status: "success", policy: built.policy, result });
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : "Remove failed";
+                    sendJson(res, 400, { status: "failed", error: msg });
+                }
+                return;
+            }
             if (req.method === "POST") {
                 const parsed = parseDevicePath(pathname);
                 if (parsed) {
@@ -593,25 +780,34 @@ export class TomorrowOS extends EventEmitter {
             }
             const type = msg.type;
             if (type === "device.hello") {
-                const deviceId = typeof msg.deviceId === "string" && msg.deviceId
-                    ? msg.deviceId
-                    : randomUUID();
-                const code = createSixDigitCode();
-                this.captureHelloMeta(deviceId, msg);
-                this.devices.set(deviceId, ws);
-                void this.store.setPendingCode(code, {
-                    deviceId,
-                    createdAt: Date.now()
-                });
-                ws.deviceId = deviceId;
-                ws.send(JSON.stringify({
-                    type: "pairing.code",
-                    method: "tomorrowos.pairing.createCode",
-                    code,
-                    deviceId
-                }));
-                this.sendBrandSnapshot(ws);
-                this.emit("device.online", { deviceId });
+                const deviceId = resolveHelloDeviceId(msg) ?? randomUUID();
+                const serialNumber = typeof msg.serialNumber === "string" && msg.serialNumber.trim()
+                    ? msg.serialNumber.trim()
+                    : deviceId;
+                void (async () => {
+                    try {
+                        const code = await this.getOrCreatePermanentPairingCode(deviceId, serialNumber);
+                        this.captureHelloMeta(deviceId, msg);
+                        this.devices.set(deviceId, ws);
+                        void this.store.setPendingCode(code, {
+                            deviceId,
+                            createdAt: Date.now()
+                        });
+                        ws.deviceId = deviceId;
+                        ws.send(JSON.stringify({
+                            type: "pairing.code",
+                            method: "tomorrowos.pairing.createCode",
+                            code,
+                            deviceId,
+                            serialNumber
+                        }));
+                        this.sendBrandSnapshot(ws);
+                        this.emit("device.online", { deviceId });
+                    }
+                    catch (err) {
+                        console.error("[TomorrowOS] device.hello failed:", err);
+                    }
+                })();
                 return;
             }
             if (type === "device.resume") {
@@ -638,6 +834,9 @@ export class TomorrowOS extends EventEmitter {
                     this.sendBrandSnapshot(ws);
                     void this.refreshPairedDeviceInfo(deviceId);
                     this.emit("device.online", { deviceId });
+                    void this.pushLatestPolicyToDevice(deviceId).catch((err) => {
+                        console.error("[TomorrowOS] pushLatestPolicy on resume failed:", err);
+                    });
                 })();
             }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomorrowos/sdk",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "TomorrowOS CMS server SDK — WebSocket transport, pairing, device commands, optional static CMS UI. Includes CLI (tomorrowos init / build) and starter templates.",
   "type": "module",
   "main": "./dist/index.js",

package/templates/cms-starter/policy.example.json

@@ -1,30 +1,30 @@
-{
-  "policy": {
-    "playlists": [
-      {
-        "id": "weekday-promo",
-        "name": "Weekday promo",
-        "schedule": {
-          "startDate": "2026-05-01",
-          "endDate": "2026-05-31",
-          "daysOfWeek": [1, 2, 3, 4, 5],
-          "start": "09:00",
-          "end": "17:00"
-        },
-        "items": [
-          {
-            "url": "https://example.com/hero.jpg",
-            "type": "image",
-            "durationMs": 10000
-          },
-          {
-            "url": "https://example.com/spot.mp4",
-            "type": "video",
-            "durationMs": 30000
-          }
-        ]
-      }
-    ],
-    "fallback": { "type": "brand" }
-  }
-}
+{
+  "policy": {
+    "playlists": [
+      {
+        "id": "weekday-promo",
+        "name": "Weekday promo",
+        "schedule": {
+          "startDate": "2026-05-01",
+          "endDate": "2026-05-31",
+          "daysOfWeek": [1, 2, 3, 4, 5],
+          "start": "09:00",
+          "end": "17:00"
+        },
+        "items": [
+          {
+            "url": "https://example.com/hero.jpg",
+            "type": "image",
+            "durationMs": 10000
+          },
+          {
+            "url": "https://example.com/spot.mp4",
+            "type": "video",
+            "durationMs": 30000
+          }
+        ]
+      }
+    ],
+    "fallback": { "type": "brand" }
+  }
+}

package/templates/cms-starter/public/index.html

@@ -9,16 +9,24 @@
   <body>
     <header class="app-header">
       <h1>TomorrowOS Control Panel</h1>
-      <p>Pair multiple screens, build a playlist, then publish per device.</p>
+      <p>Create playlists, save with confirm, then publish selected playlists per device.</p>
     </header>
 
     <div class="layout">
+      <aside class="panel-playlist-nav">
+        <div class="playlist-nav-header">
+          <h2>Playlists</h2>
+          <button type="button" class="primary" id="newPlaylistBtn" title="New playlist">+</button>
+        </div>
+        <ul id="playlistCatalog" class="playlist-catalog"></ul>
+      </aside>
+
       <main class="panel-main">
         <section class="card">
           <h2>Pair device</h2>
-          <p class="hint">Enter the 6-digit code shown on a screen. Each verified device gets its own card below.</p>
+          <p class="hint">Enter the 6-character code on the screen (A–Z or 0–9).</p>
           <div class="row">
-            <input id="code" maxlength="6" placeholder="6-digit code" />
+            <input id="code" maxlength="6" placeholder="e.g. A3K9Z1" autocapitalize="characters" />
             <button type="button" onclick="verify()">Verify</button>
           </div>
         </section>
@@ -26,17 +34,14 @@
         <section class="card" id="pairedDevicesSection">
           <h2>Paired devices</h2>
           <div id="devicesGrid" class="devices-grid">
-            <p class="devices-empty" id="devicesEmpty">No paired devices yet. Enter a code above.</p>
+            <p class="devices-empty" id="devicesEmpty">No paired devices yet.</p>
           </div>
         </section>
 
         <section class="card" id="cmsUrlSection">
           <h2>CMS URL for screens</h2>
           <p class="hint">
-            <strong>Local development only.</strong> Fill this in when you run the CMS on your PC and
-            TVs are on the same LAN (e.g. <code>http://192.168.1.105:3000</code> — same machine as your
-            <code>ws://</code> address, not <code>localhost</code>). On hosted CMS (Replit, etc.) you
-            normally do <strong>not</strong> need to change this.
+            <strong>Local development only.</strong> LAN URL for TVs (not localhost).
           </p>
           <div class="row">
             <input
@@ -49,11 +54,16 @@
           </div>
         </section>
 
-        <section class="card">
-          <h2>When this playlist plays</h2>
-          <p class="hint">
-            Leave blank for always on (device local time). All set fields must match.
-          </p>
+        <section class="card" id="playlistEditorSection">
+          <h2 id="editorTitle">Playlist editor</h2>
+          <p class="hint">Save confirms changes. Names must be unique. Schedule applies to this playlist only.</p>
+          <label class="field-label">
+            Name
+            <input type="text" id="playlistName" placeholder="e.g. Weekday promo" />
+          </label>
+
+          <h3 class="subheading">When this playlist plays</h3>
+          <p class="hint">Leave blank for always on (device local time).</p>
           <div class="schedule-grid">
             <label>
               Start date
@@ -82,6 +92,11 @@
               <label><input type="checkbox" class="day-checkbox" value="6" /> Sat</label>
             </div>
           </div>
+
+          <div class="editor-actions">
+            <button type="button" class="primary" id="savePlaylistBtn">Save playlist</button>
+            <button type="button" class="danger" id="deletePlaylistBtn">Delete playlist</button>
+          </div>
         </section>
 
         <pre id="result" aria-live="polite"></pre>
@@ -89,7 +104,7 @@
 
       <aside class="panel-playlist">
         <div class="playlist-header">
-          <h2>Playlist</h2>
+          <h2>Assets</h2>
           <button type="button" class="primary" id="addAssetBtn" title="Add image or video">+</button>
         </div>
         <input
@@ -99,11 +114,24 @@
           accept="image/*,video/*,.wgt,.zip"
         />
         <ul id="playlistList" class="playlist-list">
-          <li class="playlist-empty" id="playlistEmpty">No assets yet. Tap + to upload.</li>
+          <li class="playlist-empty" id="playlistEmpty">Select or create a playlist, then add assets.</li>
         </ul>
       </aside>
     </div>
 
+    <div id="publishModal" class="modal hidden" role="dialog" aria-modal="true">
+      <div class="modal-backdrop" data-close-modal="1"></div>
+      <div class="modal-card">
+        <h2>Publish to device</h2>
+        <p class="hint" id="publishModalHint">Select playlists to deploy. Updates apply on publish; reboot pulls latest saved versions.</p>
+        <div id="publishChecklist" class="publish-checklist"></div>
+        <div class="modal-actions">
+          <button type="button" id="publishConfirmBtn" class="primary">Publish selected</button>
+          <button type="button" data-close-modal="1">Cancel</button>
+        </div>
+      </div>
+    </div>
+
     <script src="./methods.js" defer></script>
   </body>
 </html>