@nebulahome/integration-sdk 1.1.0 → 1.4.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +54 -0
- package/FILES.md +164 -21
- package/README.md +5 -3
- package/dist/chunks/node-dist.js +3066 -222
- package/dist/chunks/node-index.d.ts +247 -17
- package/dist/chunks/node-project.js +2 -1
- package/dist/index.d.ts +79 -9
- package/dist/schemas.d.ts +168 -16
- package/dist/schemas.js +3 -2
- package/dist/testing.d.ts +39 -1
- package/dist/testing.js +44 -4
- package/package.json +5 -5
- package/schemas/discovery.schema.json +554 -0
- package/schemas/driver.schema.json +8 -1
- package/schemas/manifest.schema.json +12 -0
- package/schemas/modbus-template.schema.json +285 -0
- package/schemas/profile.schema.json +49 -0
package/CHANGELOG.md
CHANGED
|
@@ -3,6 +3,60 @@
|
|
|
3
3
|
The SDK's version is the version of the integration contract the platform implements: a minor
|
|
4
4
|
version adds to the contract, a major one breaks it, and a patch leaves it as it is.
|
|
5
5
|
|
|
6
|
+
## 1.4.0
|
|
7
|
+
|
|
8
|
+
The house's Modbus client is the platform's.
|
|
9
|
+
|
|
10
|
+
- The platform runs the house's Modbus TCP client in the hub, the way it runs the MQTT broker:
|
|
11
|
+
one connection per server, one request at a time, shared by everything in the hub that speaks
|
|
12
|
+
Modbus - over MBAP, or RTU frames a transparent RS485 adapter carries over TCP.
|
|
13
|
+
- A driver may run on the platform's `modbus` transport with `"kind": "modbus"` and a `template`:
|
|
14
|
+
the platform reads the device through the template - each entity's capabilities mapped to the
|
|
15
|
+
register it is read from (functions 01-04) and the command it is written with (05, 06, 15, 16) -
|
|
16
|
+
with neither a profile nor code. The template is the one the owner writes on the Brokers page,
|
|
17
|
+
and the integration's show there, read-only, for the owner to duplicate.
|
|
18
|
+
- `discovery.json` may say which of the Modbus servers the network search finds are the vendor's,
|
|
19
|
+
in a `modbus` block: the values to read - registers, as a template reads them - and conditions on
|
|
20
|
+
`values.<name>`; `listen` may then be left out. The platform recognises no server on its own.
|
|
21
|
+
- `sdk.openModbus({ host, port, framing })` opens a session through the hub's one connection to a
|
|
22
|
+
server, for a transport of the vendor's own: its requests wait their turn with the platform's,
|
|
23
|
+
so a gateway that takes one client at a time is never asked twice at once.
|
|
24
|
+
- `identifyModbus(vendor, identity)` in `@nebulahome/integration-sdk/testing` says whether the
|
|
25
|
+
vendor's `modbus` rules take a server, and `schemas/modbus-template.schema.json` checks a
|
|
26
|
+
template in the editor.
|
|
27
|
+
|
|
28
|
+
## 1.3.0
|
|
29
|
+
|
|
30
|
+
The house's MQTT broker is the platform's.
|
|
31
|
+
|
|
32
|
+
- The platform runs the house's MQTT broker in the hub, the way it runs the Matter fabric:
|
|
33
|
+
`requires: { "services": ["mqtt-broker"] }` is always met, and `sdk.platform.mqtt` is the hub's
|
|
34
|
+
own username on it.
|
|
35
|
+
- A driver may run on the platform's `mqtt-house` transport with `"kind": "mqtt"`: the platform's
|
|
36
|
+
MQTT mapping is its driver, with neither a profile nor code, for the devices that announce
|
|
37
|
+
themselves on the broker the way the MQTT discovery convention says, and those the owner maps
|
|
38
|
+
by hand.
|
|
39
|
+
- `discovery.json` may say which of those devices are the vendor's, in an `mqtt` block of
|
|
40
|
+
conditions on who each says it is - `manufacturer`, `model`, `originName` and the rest; `listen`
|
|
41
|
+
may then be left out.
|
|
42
|
+
- `identifyMqtt(vendor, identity)` in `@nebulahome/integration-sdk/testing` says whether the
|
|
43
|
+
vendor's `mqtt` rules take such a device, and as which driver and model.
|
|
44
|
+
|
|
45
|
+
## 1.2.0
|
|
46
|
+
|
|
47
|
+
One device reached two ways.
|
|
48
|
+
|
|
49
|
+
- The manifest may say what makes two of the vendor's devices one, `"twins": ["mac"]` (or
|
|
50
|
+
`["mac", "serial"]`): a device added over the vendor's own transport and again through the
|
|
51
|
+
Matter broker is then offered to the owner to link, and becomes one device with two ways in.
|
|
52
|
+
- A profile's `identity` and `discovery.json`'s `identity` take `mac` and `serialNumber`, written
|
|
53
|
+
any way the device writes them; `discovery.json`'s `identity` also takes `auth`, where the device
|
|
54
|
+
says it is behind a password, which its row on the Found tab shows.
|
|
55
|
+
- An entity of a profile may carry `link`: its key in the transport's terms (`"switch:0"`), shown
|
|
56
|
+
beside the transport's name, and where the same reading sits in Matter
|
|
57
|
+
(`{ "endpoint": 1, "cluster": 6, "attribute": 0 }`), which links the two at once when the device
|
|
58
|
+
is linked.
|
|
59
|
+
|
|
6
60
|
## 1.1.0
|
|
7
61
|
|
|
8
62
|
Matter, and a wider grammar for conditions.
|
package/FILES.md
CHANGED
|
@@ -63,10 +63,20 @@ with `padding` (0 to 16, default 0): extra room, in pixels, the interface leaves
|
|
|
63
63
|
inside its tile. Every logo already gets a small margin; this is on top of it, for a mark drawn
|
|
64
64
|
to the very edge of its file. It cannot ask for less than the margin, only for more.
|
|
65
65
|
|
|
66
|
+
`twins` says what makes two of the vendor's devices **one device reached two ways**: `["mac"]`,
|
|
67
|
+
or `["mac", "serial"]` for both to agree. A Shelly added over its RPC and again through the Matter
|
|
68
|
+
broker is the same plug; with `twins`, the house compares what each said - the MAC and the serial
|
|
69
|
+
its `identity` reads, and its Matter identity's - and offers the owner to link them, when the
|
|
70
|
+
Matter node is added and as a suggestion on the vendor's page. Linked, it is one device with two
|
|
71
|
+
ways in: its readings come the way the owner prefers, and the other way carries them while that
|
|
72
|
+
one is silent. A vendor without `twins` is never offered a link. Each entity's `link` (below) says
|
|
73
|
+
which of its readings is which in Matter.
|
|
74
|
+
|
|
66
75
|
`requires` says what the vendor's devices need besides the hub, in the grammar a
|
|
67
76
|
package's manifest uses (PACKAGES.md §8, Dependencies):
|
|
68
|
-
`{ "services": ["mqtt-broker"] }` for Zigbee2MQTT, which talks through the house's broker
|
|
69
|
-
package by id and range. Until what it needs
|
|
77
|
+
`{ "services": ["mqtt-broker"] }` for Zigbee2MQTT, which talks through the house's broker - one
|
|
78
|
+
the platform runs itself, so it is always met - or a package by id and range. Until what it needs
|
|
79
|
+
runs, the vendor waits: its instances fail with the
|
|
70
80
|
sentence that names the package, `api` refuses its devices with `409 needs-package`, and its page
|
|
71
81
|
says so first. The hub follows the packages at every `pkg.*` event and starts only that vendor's
|
|
72
82
|
instances again when its standing changes. A container that speaks to the broker names its topics
|
|
@@ -118,7 +128,7 @@ the vendor's models by series, across its drivers - the series by name, the mode
|
|
|
118
128
|
counting order - and a device's page says its series where it would say the driver's name. A
|
|
119
129
|
model given no series is grouped under its driver. Every model named must be in `models`.
|
|
120
130
|
|
|
121
|
-
`transport` is a platform transport - `http`, `mqtt`, `matter` - or one the driver's own vendor
|
|
131
|
+
`transport` is a platform transport - `http`, `mqtt`, `matter`, `mqtt-house`, `modbus` - or one the driver's own vendor
|
|
122
132
|
ships, named after the vendor: `shelly/rpc`. Never another vendor's: vendors load in no particular
|
|
123
133
|
order, and a driver leaning on another's transport would load or not by luck.
|
|
124
134
|
|
|
@@ -129,6 +139,70 @@ Matter devices are its own, on its page, without code. Which devices those are i
|
|
|
129
139
|
`discovery.json` says (below), and `modelCodes` maps what they call their model - their product id,
|
|
130
140
|
unless the vendor says another field - onto the models it lists.
|
|
131
141
|
|
|
142
|
+
A driver of the vendor's devices that **announce themselves on the house's MQTT broker** is
|
|
143
|
+
`"transport": "mqtt-house"` with `"kind": "mqtt"`, likewise with neither a profile nor an entry:
|
|
144
|
+
the platform's own MQTT mapping runs it - sensors, binary sensors, switches, lights, covers,
|
|
145
|
+
buttons, numbers, selects and locks, as each announces itself - and `modelCodes` maps the model
|
|
146
|
+
the device announces onto the models it lists.
|
|
147
|
+
|
|
148
|
+
A driver of the vendor's **Modbus devices** is `"transport": "modbus"` with `"kind": "modbus"` and a
|
|
149
|
+
`template` - `"template": "./template.json"` - instead of a profile or an entry: the platform reads
|
|
150
|
+
the device through the template, over the house's one connection to its server. The template is
|
|
151
|
+
the format the owner writes on the Brokers page, and the vendor's show there for the owner to
|
|
152
|
+
duplicate:
|
|
153
|
+
|
|
154
|
+
```json
|
|
155
|
+
{
|
|
156
|
+
"$schema": "../../node_modules/@nebulahome/integration-sdk/schemas/modbus-template.schema.json",
|
|
157
|
+
"name": "SDM630",
|
|
158
|
+
"device": "Eastron SDM630",
|
|
159
|
+
"wordOrder": "high",
|
|
160
|
+
"pollSeconds": 10,
|
|
161
|
+
"entities": [
|
|
162
|
+
{
|
|
163
|
+
"id": "power",
|
|
164
|
+
"name": "Power",
|
|
165
|
+
"domain": "sensor",
|
|
166
|
+
"capabilities": {
|
|
167
|
+
"sensor_numeric": {
|
|
168
|
+
"read": { "function": 4, "address": "0x0034", "type": "f32", "unit": "W" }
|
|
169
|
+
}
|
|
170
|
+
}
|
|
171
|
+
},
|
|
172
|
+
{
|
|
173
|
+
"id": "relay_1",
|
|
174
|
+
"name": "Relay 1",
|
|
175
|
+
"domain": "switch",
|
|
176
|
+
"capabilities": {
|
|
177
|
+
"on_off": {
|
|
178
|
+
"read": { "function": 1, "address": "0x0000" },
|
|
179
|
+
"write": { "function": 5, "on": "0xFF00", "off": "0x0000" }
|
|
180
|
+
}
|
|
181
|
+
}
|
|
182
|
+
}
|
|
183
|
+
]
|
|
184
|
+
}
|
|
185
|
+
```
|
|
186
|
+
|
|
187
|
+
- `port` (502) and `unitId` (1) are what adding a device offers; `wordOrder` says which register
|
|
188
|
+
of a 32-bit value holds its high word; `pollSeconds` how often the device is read.
|
|
189
|
+
- Each entity is a `domain` - `sensor`, `binary_sensor`, `switch`, `light`, `number`, `select`,
|
|
190
|
+
`button` - and its capabilities: a sensor `sensor_numeric` or `sensor_text`, a binary sensor
|
|
191
|
+
`sensor_binary`, a switch `on_off`, a light `on_off` and maybe `level`, the others their own.
|
|
192
|
+
`id` is what the entity stays when it is renamed; give every one.
|
|
193
|
+
- `read`: `function` 1 (coils), 2 (discrete inputs), 3 (holding registers) or 4 (input registers);
|
|
194
|
+
`address`, a number or `"0x…"`; for registers a `type` - `u16` (the default), `s16`, `u32`, `s32`,
|
|
195
|
+
`f32`, or `string` with a `count` of registers - a `bit` for an on/off value, a `scale` (`0.1`
|
|
196
|
+
for tenths), a `unit`, and `options` naming what each raw number means (`{ "0": "Off" }`, which
|
|
197
|
+
a select needs).
|
|
198
|
+
- `write`: `function` 5 (one coil), 6 (one register), 15 (coils) or 16 (registers - a 32-bit value
|
|
199
|
+
needs it); `address`, the read's when left out; `on` and `off` for a switch; `min`, `max` and
|
|
200
|
+
`step` for a number, refused outside before anything is sent; `value` for a button.
|
|
201
|
+
|
|
202
|
+
The rules that tie these together - a number is not read from coils, a coil is not written with
|
|
203
|
+
06, a table read with 02 or 04 cannot be written back without an address - are checked when the
|
|
204
|
+
bundle loads, with the words the editor uses.
|
|
205
|
+
|
|
132
206
|
`defaultIcon` names the icon a device of this driver starts with, by its id in the platform's
|
|
133
207
|
icon catalogue (`packages/icons/catalogue.json` lists the platform's own ids - `light`,
|
|
134
208
|
`relay`, `printer`, `sensor`… - and every lucide icon is there under its own name). The owner
|
|
@@ -183,6 +257,18 @@ on anything its device says, so it is available exactly when the device is, and
|
|
|
183
257
|
`"deviceClass": "restart"` the interface asks before pressing, since the device goes away for a
|
|
184
258
|
while.
|
|
185
259
|
|
|
260
|
+
An entity may carry **`link`**, for a vendor whose devices the house may also reach through the
|
|
261
|
+
Matter broker (`twins`, above): `"link": { "key": "switch:0", "matter": { "endpoint": 1,
|
|
262
|
+
"cluster": 6, "attribute": 0 } }`. `key` is the entity's name in the transport's terms, shown on
|
|
263
|
+
its page beside the transport's name; `matter` is where the same reading sits in Matter - the
|
|
264
|
+
endpoint, the cluster and the attribute the platform's Matter mapping reads it from (the first
|
|
265
|
+
cluster and attribute of an entity it reads from several: 0 for a light). When the device is
|
|
266
|
+
linked, an entity whose `matter` names a Matter entity of the twin is linked to it at once,
|
|
267
|
+
whatever it is; a sensor without one is linked when exactly one Matter sensor reads the same
|
|
268
|
+
thing, and a control never without one. The identity's `mac` and `serialNumber` are what the twin
|
|
269
|
+
is found by: `"identity": { "externalId": "id", "mac": "mac" }`, written any way the device writes
|
|
270
|
+
it.
|
|
271
|
+
|
|
186
272
|
An entity may report **attributes** beside its state: `"attributes": { "endsAt":
|
|
187
273
|
"pairing.endsAt" }`, each a camelCase key read the way a state field is, into a scalar. They are
|
|
188
274
|
for what a page needs of the entity and the entity itself is not - the Zigbee2MQTT bridge's
|
|
@@ -275,7 +361,9 @@ because a device announced it there.
|
|
|
275
361
|
- `identity` - paths to the model code, the id, the name and the firmware version. Only the model
|
|
276
362
|
is ever required. A field may be a list of paths, tried in order, for generations that answer
|
|
277
363
|
in different words: a Shelly Gen1 says `type`, `mac` and `fw` where later ones say `model`,
|
|
278
|
-
`id` and `ver`.
|
|
364
|
+
`id` and `ver`. `mac` and `serialNumber` are what the Found tab shows and a twin is told by
|
|
365
|
+
(`twins`), and `auth` is where the device says it is behind a password - `["auth_en", "auth"]`
|
|
366
|
+
on a Shelly - which its row shows before anyone tries to add it.
|
|
279
367
|
- `adopt` - who adds a device found: `owner` (the default) proposes it on the vendor's
|
|
280
368
|
page to adopt; `automatic` has `api` add it as soon as the hub proposes it, named as it named
|
|
281
369
|
itself, with the id the add form would have offered - for devices the owner already chose
|
|
@@ -335,11 +423,65 @@ at once to the vendor whose `matter` rules take it:
|
|
|
335
423
|
model: a Matter driver that lists models must map every product in `modelCodes`, or a product
|
|
336
424
|
it misses is never added. A driver that lists none takes them all, under its own name.
|
|
337
425
|
|
|
426
|
+
**MQTT devices.** The house's MQTT broker, which the platform runs on port 1883, hears every device
|
|
427
|
+
that announces itself the way the MQTT discovery convention says - a retained JSON document on
|
|
428
|
+
`<prefix>/<component>/[<node>/]<object>/config`, which Tasmota, ESPHome, OpenMQTTGateway and most
|
|
429
|
+
others publish under `homeassistant` - and each device the owner maps by hand on the Brokers page.
|
|
430
|
+
Each is added at once to the vendor whose `mqtt` rules take it:
|
|
431
|
+
|
|
432
|
+
```json
|
|
433
|
+
{
|
|
434
|
+
"mqtt": {
|
|
435
|
+
"match": [{ "path": "originName", "equals": "Tasmota" }],
|
|
436
|
+
"model": "model"
|
|
437
|
+
}
|
|
438
|
+
}
|
|
439
|
+
```
|
|
440
|
+
|
|
441
|
+
- `match` - at least one condition, all of which must hold of who the device says it is: its
|
|
442
|
+
`deviceKey` (its first identifier), `source` (`announced`, `mapped` or `broker`), `name`,
|
|
443
|
+
`manufacturer`, `model`, `modelId`, `swVersion`, `hwVersion`, `serialNumber`, `identifiers` and
|
|
444
|
+
`macAddresses` (lists), `viaDevice`, `originName` and `originSwVersion` (the firmware or program
|
|
445
|
+
that announced it) and `components` (a list: `switch`, `sensor`, `light`…). A field the device
|
|
446
|
+
does not say is `null`.
|
|
447
|
+
- `model` - where the device says its model, looked up in the `modelCodes` of the vendor's drivers
|
|
448
|
+
that say `"kind": "mqtt"`; `model` when absent. A model no driver maps goes to the vendor's MQTT
|
|
449
|
+
driver when it has only one, as with Matter.
|
|
450
|
+
|
|
451
|
+
**Modbus servers.** The house's Modbus client searches the network, when the owner turns the search
|
|
452
|
+
on: every address of the ranges the owner gives - or of the networks the hub is on - on port 502.
|
|
453
|
+
It recognises nothing on its own: a server is the vendor's when its `modbus` rules take it, and the
|
|
454
|
+
owner adds it from the Brokers page with the vendor's template. Whenever a vendor is installed or
|
|
455
|
+
removed, the servers found are asked again.
|
|
456
|
+
|
|
457
|
+
```json
|
|
458
|
+
{
|
|
459
|
+
"modbus": {
|
|
460
|
+
"unitId": 1,
|
|
461
|
+
"read": { "serial": { "function": 3, "address": "0x0000", "type": "string", "count": 7 } },
|
|
462
|
+
"match": [{ "path": "values.serial", "startsWith": "H3" }],
|
|
463
|
+
"model": "values.model"
|
|
464
|
+
}
|
|
465
|
+
}
|
|
466
|
+
```
|
|
467
|
+
|
|
468
|
+
- `read` - at most eight values, by the name the rules use, each read as a template's `read` is,
|
|
469
|
+
from `unitId` (1 unless said); one the server refuses is `null`.
|
|
470
|
+
- `match` - at least one condition, all of which must hold of `values.<name>`, `host`, `port` and
|
|
471
|
+
`unitId`.
|
|
472
|
+
- `model` - where the server says its model, looked up in the `modelCodes` of the vendor's drivers
|
|
473
|
+
that say `"kind": "modbus"`; `values.model` when absent.
|
|
474
|
+
|
|
475
|
+
A vendor may have `mqtt` alone, with no `listen`. A device that more than one vendor's rules take,
|
|
476
|
+
and one that none takes, is added as the platform's own MQTT device, and one added so before the
|
|
477
|
+
vendor was installed becomes the vendor's once it is.
|
|
478
|
+
|
|
338
479
|
A vendor may have `matter` alone, with no `listen`. A device behind a Matter bridge is a device of
|
|
339
480
|
its own, ruled on by what the bridge says of it. A device that more than one vendor's rules take,
|
|
340
481
|
and one that none takes, is added as the platform's own Matter device, and the Brokers page says
|
|
341
|
-
which vendors want it.
|
|
342
|
-
|
|
482
|
+
which vendors want it. One added as the platform's before the vendor was installed becomes the
|
|
483
|
+
vendor's once it is, with its entities. Removing a Matter device from the house takes it off the
|
|
484
|
+
house's fabric; it stays in the other apps it was shared from.
|
|
343
485
|
|
|
344
486
|
**A listener of the vendor's own** is a module - plain JavaScript, like a transport, handed the
|
|
345
487
|
same SDK - whose default export returns `{ listen(signal, context), scan?() }`: an async iterable
|
|
@@ -601,21 +743,22 @@ the manifest names, and its default export - typed with `defineTransportModule`
|
|
|
601
743
|
the hub calls with the **SDK**, the runtime's pieces a transport needs, since the bundle cannot
|
|
602
744
|
import them:
|
|
603
745
|
|
|
604
|
-
| `sdk.` | What
|
|
605
|
-
| -------------------- |
|
|
606
|
-
| `version` | the runtime version, the one `manifest.sdk` was matched against
|
|
607
|
-
| `z` | the runtime's zod, so the transport's settings validate as the hub's do
|
|
608
|
-
| `defineTransport` | the contract the platform's own transports are written against
|
|
609
|
-
| `openWebSocket` | a WebSocket the hub keeps open: reconnection with a doubling pause, resets
|
|
610
|
-
| `openUdpSocket` | a UDP socket the hub binds, joins to a multicast group, and closes with the vendor
|
|
611
|
-
| `openMqtt` | an MQTT session with a client certificate, for a vendor's own broker
|
|
612
|
-
| `
|
|
613
|
-
| `
|
|
614
|
-
| `
|
|
615
|
-
| `
|
|
616
|
-
| `
|
|
617
|
-
| `
|
|
618
|
-
| `
|
|
746
|
+
| `sdk.` | What |
|
|
747
|
+
| -------------------- | ------------------------------------------------------------------------------------- |
|
|
748
|
+
| `version` | the runtime version, the one `manifest.sdk` was matched against |
|
|
749
|
+
| `z` | the runtime's zod, so the transport's settings validate as the hub's do |
|
|
750
|
+
| `defineTransport` | the contract the platform's own transports are written against |
|
|
751
|
+
| `openWebSocket` | a WebSocket the hub keeps open: reconnection with a doubling pause, resets |
|
|
752
|
+
| `openUdpSocket` | a UDP socket the hub binds, joins to a multicast group, and closes with the vendor |
|
|
753
|
+
| `openMqtt` | an MQTT session with a client certificate, for a vendor's own broker |
|
|
754
|
+
| `openModbus` | a Modbus session through the hub's one connection to a server, closed with the vendor |
|
|
755
|
+
| `defineStreamSource` | the contract a camera's stream source is written against |
|
|
756
|
+
| `openRtsp` | an RTSP(S) session over TCP, yielding a camera's H.264 as it comes |
|
|
757
|
+
| `platform.mqtt` | the house's MQTT broker the hub runs, with the hub's username; null if it cannot |
|
|
758
|
+
| `defineAccount` | the contract an account's sign-in module is written against |
|
|
759
|
+
| `codecs.lzma` | unpacks an LZMA stream in the alone format, as some clouds pack maps |
|
|
760
|
+
| `images.png` | encodes a picture of a palette as a PNG, for an image entity |
|
|
761
|
+
| `logger` | the hub's logger, for what happens outside a connection |
|
|
619
762
|
|
|
620
763
|
`openWebSocket` also takes `headers` - sent on every handshake and never logged, or a
|
|
621
764
|
function called before each attempt, for a token that expires - `ping: { everyMs, timeoutMs }`,
|
package/README.md
CHANGED
|
@@ -86,7 +86,8 @@ light.command('light.device', 'on_off', { command: 'turn_on' }); // → the HTTP
|
|
|
86
86
|
```
|
|
87
87
|
|
|
88
88
|
`identify` says what discovery makes of a device heard, `identifyMatter` what the vendor's `matter`
|
|
89
|
-
rules make of one of the house's Matter devices,
|
|
89
|
+
rules make of one of the house's Matter devices, `identifyMqtt` what its `mqtt` rules make of a
|
|
90
|
+
device the house's MQTT broker hears, and `createFakeSdk` is the SDK handed to
|
|
90
91
|
the code, recording what it logged and sent: its UDP sockets and WebSockets connect to nothing, and
|
|
91
92
|
a test opens, delivers to and drops them.
|
|
92
93
|
|
|
@@ -121,8 +122,9 @@ git tag integration-sdk@<version> && git push origin integration-sdk@<version>
|
|
|
121
122
|
```
|
|
122
123
|
|
|
123
124
|
`.github/workflows/release-integration-sdk.yml` checks the tag says the package's version, runs the
|
|
124
|
-
SDK's gates and
|
|
125
|
-
|
|
125
|
+
SDK's gates and keeps the archive npm will receive as the run's artifact; it makes no GitHub
|
|
126
|
+
release, npm is where the SDK is published. The maintainer downloads that artifact from the run
|
|
127
|
+
and publishes it, signed in to npm:
|
|
126
128
|
|
|
127
129
|
```sh
|
|
128
130
|
npm publish nebulahome-integration-sdk-<version>.tgz
|