@tetherto/mdk-skill 0.0.0 → 0.12.1

package/dist/skills/mdk-worker-plugin/SKILL.md

@@ -0,0 +1,198 @@
+---
+name: mdk-worker-plugin
+description: >
+  Integrate a new device into MDK as a device Worker. Use for any task like
+  "new device / miner / power meter / sensor / container Worker", "build a
+  Worker", "integrate hardware", "wrap a device protocol (Modbus / CGMiner /
+  HTTP / MQTT)", or anything creating or editing an mdk-contract.json, a
+  Worker Plugin, or telemetry/command handlers under backend/workers/.
+metadata:
+  suite: mdk-developer-skill
+  mdk_version: "0.7.0"
+license: Apache-2.0
+---
+
+# Integrate a new MDK device Worker
+
+A device Worker is a **Worker Plugin**: a package directory holding an
+`mdk-contract.json` plus one small handler module per telemetry channel and
+per command. It exports no module of its own. `WorkerRuntimeV2`
+(`@tetherto/mdk-worker`) loads the directory and instantiates the plugin once
+per device — handlers are plain `(params)` functions that read device context
+from `require('@tetherto/mdk-worker/device')`. Workers are **site-agnostic**:
+they know nothing about the site they run in, so everything here is testable
+locally against a device mock before a Kernel ever exists.
+
+The final package shape (this is `assets/worker-template/`, a verbatim copy of
+`packages/cli/templates/worker/` — the same tree `mdk create worker` scaffolds):
+
+```
+<your-worker>/
+├── mdk-contract.json            # single source of truth (package root)
+├── package.json                 # no main/exports — the runtime loads the dir
+├── smoke.config.js              # glue for scripts/worker-smoke.mjs
+├── src/
+│   ├── client.js                # vendor-protocol I/O via ambient device context
+│   ├── telemetry/<name>.js      # one file per telemetry channel
+│   └── commands/<name>.js       # one file per command
+└── mock/server.js               # vendor firmware simulator
+```
+
+## Workflow
+
+### 1. Start from the Worker template
+
+The default starting point for every new Worker is `assets/worker-template/`
+— a complete minimal Worker Plugin (contract + client + handlers + mock) with
+no assumptions about your device category.
+
+Do **not** model a new Worker on the MDK monorepo's shipped device families
+(Whatsminer, Antminer, ABB, Seneca, …) by default — those still use the older
+`plugin/` layout and are tightly coupled to the mining use cases they were
+built for. Only when the user **explicitly asks** to follow the existing MDK
+Worker families and their structure (e.g. contributing a Worker into this
+monorepo, or deliberately mirroring a shipped family's protocol handling)
+should you read [`references/device-families.md`](./references/device-families.md)
+and copy from the named family instead.
+
+### 2. Scaffold
+
+In a CLI-managed project, scaffold and register in one step:
+
+```bash
+mdk create worker <name>
+```
+
+This copies the CLI Worker template into `workers/<name>`, links it as an npm
+workspace member (root `npm install`, skip with `--no-install`), and appends
+it under `mdk.yaml` → `spec.workers` with a `mock: true` seed device (skip
+with `--no-stack-entry`) — so it is runnable immediately with
+`mdk run worker <name>` before you change a line.
+
+Outside the CLI (e.g. contributing inside the monorepo, or no `mdk.yaml`
+project), copy `assets/worker-template/` to your Worker's location instead.
+Either way, rename the template-specific parts (contract metadata, client
+methods, mock behavior). Remember to adapt `smoke.config.js` (mock boot,
+device opts, sample command params) and `package.json` (name, description).
+The plugin is location-independent — put the package wherever your project
+keeps packages. (Only Workers contributed to the MDK monorepo itself follow
+its `backend/workers/<category>/<family>/` layout.)
+
+### 3. Author `mdk-contract.json`
+
+Start from [`assets/mdk-contract.template.json`](./assets/mdk-contract.template.json); the field-by-field guide is
+[`references/contract-authoring.md`](./references/contract-authoring.md) — load it now. Non-negotiables:
+
+- Every telemetry/command entry needs a `handler` path (e.g. `src/telemetry/<name>.js`)
+  — the loader hard-fails without it.
+- **Every `number` command param must declare `min` and `max`.** The Kernel
+  enforces bounds only when declared (`ERR_PARAM_RANGE`); an undeclared bound
+  is an unprotected physical setpoint.
+- Read-only devices (meters, sensors) declare `"commands": []`.
+- `description` / `overview` / `constraints` are simultaneously machine docs
+  and AI operator context — write real semantics ("If 0, device is booting"),
+  and put safety thresholds in the contract, not in code comments.
+
+### 4. Validate the contract — loop until clean
+
+```
+node <this-skill>/scripts/validate-contract.mjs <worker>/mdk-contract.json
+```
+
+Validates against `references/mdk-contract.schema.json` plus semantic
+checks (handler files exist, no duplicate names, numeric params bounded).
+Fix and re-run until it exits 0. Handler files must exist first — stubs from
+the template are enough at this stage.
+
+### 5. Build the mock, then the device client
+
+Write `mock/server.js` first — a standalone simulator of the vendor firmware
+API that knows nothing about MDK. The template's self-contained HTTP JSON
+mock is the pattern to follow; adapt it to your device's protocol. (Workers
+living inside the MDK monorepo may instead reuse its shared mock framework in
+[`backend/workers/mock/`](../../../../../backend/workers/mock/README.md).) Then write `src/client.js`: plain vendor-protocol
+I/O. Bind to ambient device context
+(`require('@tetherto/mdk-worker/device')` → `{ opts, env, config, logger }`)
+rather than exporting a `createClient(opts)` factory — the runtime loads the
+module fresh per device. Throw `ERR_*` errors. No envelopes, no base classes.
+
+### 6. Wire the handlers
+
+There is no `connect()` and no `plugin/index.js`. Each handler is
+`async (params) => result` and talks to the device through `src/client.js`
+(or by reading ambient context itself). Telemetry returns the channel value
+(matching the contract's declared `type`); commands return a result object or
+throw an `ERR_*` error. Full runtime semantics: [`references/worker-base-api.md`](references/worker-base-api.md).
+
+Template pattern:
+
+```js
+'use strict'
+const client = require('../client')
+module.exports = async () => (await client.getSummary()).hashrate_ths
+```
+
+### 7. Test locally — the four-step loop
+
+Load [`references/local-testing.md`](./references/local-testing.md) for the full procedure. In order:
+
+1. **Contract validation** — step 4 above (no runtime).
+2. **In-process smoke** — `node <this-skill>/scripts/worker-smoke.mjs <worker-dir>`
+   boots your plugin against your mock (via `smoke.config.js`), asserts every
+   declared telemetry channel returns a value of the declared type, and that
+   out-of-bounds command params are rejected. No Kernel, no DHT.
+3. **Standalone protocol check** — host the package on `WorkerRuntimeV2` with a
+   tiny caller and drive real envelopes through `handleRequest`.
+4. **Site integration** — add the Worker to a site stack (e.g.
+   [`examples/mvp-site/deploy/run-process.js`](../../../../../examples/mvp-site/deploy/run-process.js))
+   and confirm a real Kernel registers it end-to-end.
+
+### 8. Boot into a site
+
+In a CLI-managed project this is just `mdk run worker <name>` (or `mdk run`
+to boot the whole stack together) — see `mdk-deployment`. The rest of this
+section is the manual path, for when nothing owns the runtime yet.
+
+A caller process owns the runtime (the plugin package itself never does):
+
+```js
+const { WorkerRuntimeV2 } = require('@tetherto/mdk-worker')
+const runtime = new WorkerRuntimeV2(pkgDir, {
+  workerId: 'my-worker-1',
+  devices: [{ deviceId: 'dev-0', opts: { host: '127.0.0.1', port: 18080 } }],
+  kernelTopic // hex topic → DHT announce; omit for local-only
+})
+await runtime.start()
+```
+
+The Worker joins the DHT topic; the Kernel pulls identity + capabilities and
+starts scheduling telemetry/health. **No Kernel changes are ever needed to add
+a Worker.**
+
+## Gotchas
+
+- **Unidirectional protocol**: a Worker never calls the Kernel — it only
+  answers. If you think you need to push, you need a telemetry channel that
+  the Kernel pulls.
+- **`deviceId` ownership is exclusive** per Worker; duplicate ids in
+  `opts.devices` throw `ERR_DEVICE_ID_DUPLICATE` at construction.
+- One device offline must never affect siblings — failures stay inside that
+  device's instance (V2 has no boot-time probe; unreachable devices surface
+  as errors in telemetry payloads rather than `ERR_DEVICE_UNAVAILABLE`).
+- Use `debug` / the ambient `logger`, never `console.log`, in Worker code.
+  Errors are `ERR_SCREAMING_SNAKE` strings.
+- The published contract strips `handler` paths; everything else in the
+  contract is visible to sites and AI operators — write it accordingly.
+
+## Hand-off
+
+This skill stops at a working Worker Plugin + contract. For prompts that also
+ask to **show** the data in a UI:
+
+| Next need                                    | Skill                |
+| -------------------------------------------- | -------------------- |
+| Aggregate / expose HTTP API over this Worker | `mdk-gateway-plugin` |
+| Register Worker in `mdk.yaml` and run it     | `mdk-deployment`     |
+| Dashboard page / tiles / charts              | `mdk-ui-component`   |
+
+See the composite routing table in [`../mdk/SKILL.md`](../mdk/SKILL.md).

package/dist/skills/mdk-worker-plugin/assets/mdk-contract.template.json

@@ -0,0 +1,45 @@
+{
+  "metadata": {
+    "provider": "TODO-vendor-slug",
+    "deviceFamily": "TODO: miner | power-meter | sensor | container | minerpool",
+    "brand": "TODO-Brand",
+    "modelsSupported": ["TODO_MODEL"],
+    "overview": "TODO: what the worker controls, which vendor protocol it wraps, and any critical environmental constraint an AI operator must know."
+  },
+  "capabilities": {
+    "telemetry": [
+      {
+        "name": "temperature",
+        "unit": "C",
+        "type": "number",
+        "handler": "src/telemetry/temperature.js",
+        "description": "TODO: what this reads, plus semantic boundaries (e.g. 'If 0, device is booting')."
+      },
+      {
+        "name": "status_text",
+        "type": "string",
+        "handler": "src/telemetry/status-text.js",
+        "description": "TODO: enumerate the possible values and what each means."
+      }
+    ],
+    "commands": [
+      {
+        "name": "setSetpoint",
+        "description": "TODO: what this does physically.",
+        "constraints": "TODO: rate limits / approval requirements, or delete this field.",
+        "handler": "src/commands/set-setpoint.js",
+        "params": [
+          { "name": "value", "type": "number", "min": 0, "max": 100 }
+        ]
+      }
+    ],
+    "health": {
+      "supportedStates": ["OK", "OFFLINE"],
+      "alerts": [],
+      "troubleshooting": []
+    },
+    "errors": {
+      "ERR_DEVICE_CALL_FAILED": "The device API call failed or returned an error."
+    }
+  }
+}

package/dist/skills/mdk-worker-plugin/assets/worker-template/README.md

@@ -0,0 +1,93 @@
+# __WORKER_NAME__
+
+An MDK **Worker Plugin** — the code that translates between MDK and a family of
+physical devices. It ships only an [`mdk-contract.json`](./mdk-contract.json) (its capability manifest)
+plus [`src/`](./src/) handler files, a device "vendor SDK" client, and a mock device
+server. It exports no module of its own; it is **directory-loaded** by
+`WorkerRuntimeV2`, which the MDK CLI constructs (`mdk run worker <name>`) — the
+package never constructs or depends on the runtime itself.
+
+This scaffold is a working example that talks to a hypothetical device over a
+tiny HTTP JSON API. Replace the device client, mock, contract, and handlers with
+your own device's protocol.
+
+## Layout
+
+```
+mdk-contract.json     # capability manifest (telemetry channels + commands)
+src/client.js         # your device "vendor SDK" — binds to this device once, per instance
+src/telemetry/*.js    # telemetry handlers (metrics read live from the device)
+src/commands/*.js     # command handlers (reboot, set-power-mode, ...)
+mock/server.js        # a standalone device simulator (createServer)
+smoke.config.js       # the device spec `mdk validate worker --smoke` checks against
+```
+
+Handlers are plain `(params)` functions — they call `require('../client')` for
+their device's client, which itself binds once (at `require` time) to the
+ambient `@tetherto/mdk-worker/device` for this instance's connection opts.
+There is one such module registry per configured device, so each handler
+always talks to its own device.
+
+## Run it
+
+Add the worker to your stack's `mdk.yaml` by **local path** and describe its
+seed devices under `config`:
+
+```yaml
+spec:
+  workers:
+    - name: __WORKER_NAME__
+      package: ./workers/__WORKER_NAME__
+      config:
+        mock: true          # start mock/server.js per device (dev only)
+        devices:
+          - id: dev-0
+            opts: { host: 127.0.0.1, port: 18080, serial: DEV-0 }
+```
+
+Then:
+
+```bash
+mdk run worker __WORKER_NAME__     # boots the worker (+ its mocks with mock: true)
+```
+
+With `mock: true` the CLI starts one simulator from [`mock/server.js`](./mock/server.js) per device
+so the worker talks to a simulator instead of hardware. Drop `mock` (or set it
+`false`) and point `opts.host`/`opts.port` at real devices for production.
+
+## Check it
+
+```bash
+mdk validate worker __WORKER_NAME__                  # the contract and handler files, without running them
+mdk validate worker --path . --smoke                 # also runs every handler against the simulator
+```
+
+`--smoke` starts the simulator through [`smoke.config.js`](./smoke.config.js), calls every telemetry
+handler and each sample command it lists, then stops the simulator and expects every handler to fail
+with an `ERR_*` error code. Add a sample to `commands` for each command you add, unless it interrupts
+the device.
+
+## Builtin per-device health check
+
+`WorkerRuntimeV2` answers a `telemetry.pull` query of `type: 'health'` for any
+device automatically — no contract or handler changes needed. It works by
+registering `health` as a plain handler in the same table any contract-declared
+telemetry channel lives in, so it is dispatched with zero special-casing, the
+same way `status`/`hashrate_rt`/etc. would be. That means it behaves exactly
+like any other named channel:
+
+- Requires a `deviceId` — a query with no `deviceId` returns
+  `{ error: 'ERR_DEVICE_ID_REQUIRED: health' }`, same as any other named channel.
+- The response comes back in the standard named-channel shape,
+  `{ name: 'health', value: { status, id, opts, env, config, workerId } }` —
+  that device's own ambient config, useful for verifying that Gateway → Kernel
+  → Worker routing reaches the right device instance (e.g. a query addressed
+  to `dev-3` always comes back with `dev-3`'s own `opts`, never a sibling
+  device's).
+- It also shows up as a `health` key inside the default `type: 'metrics'`
+  aggregate for every device, since that aggregate iterates the very same
+  handler table.
+
+If your own contract declares a `health` telemetry channel, that one is used
+instead — the builtin never overrides a plugin-declared handler of the same
+name.

package/dist/skills/mdk-worker-plugin/assets/worker-template/mdk-contract.json

@@ -0,0 +1,26 @@
+{
+  "metadata": {
+    "provider": "demo",
+    "deviceFamily": "device",
+    "brand": "DEMO",
+    "modelsSupported": ["DEMO_V1"],
+    "overview": "Template Worker Plugin — talks to a device's HTTP JSON API over src/client.js. Replace the client, mock, contract and handlers with your own device's protocol."
+  },
+  "capabilities": {
+    "telemetry": [
+      { "name": "hashrate_rt", "unit": "TH/s", "type": "number", "handler": "src/telemetry/hashrate-rt.js", "description": "Real-time throughput from the device's summary endpoint." },
+      { "name": "power", "unit": "W", "type": "number", "handler": "src/telemetry/power.js", "description": "Current power draw." },
+      { "name": "temperature", "unit": "C", "type": "number", "handler": "src/telemetry/temperature.js", "description": "Device temperature." },
+      { "name": "power_mode", "type": "string", "handler": "src/telemetry/power-mode.js", "description": "Active power mode: eco, normal or high." }
+    ],
+    "commands": [
+      { "name": "reboot", "handler": "src/commands/reboot.js", "description": "Restarts the device controller.", "constraints": "Do not call more than once per 5 minutes.", "params": [] },
+      { "name": "setPowerMode", "handler": "src/commands/set-power-mode.js", "description": "Changes the power mode: eco, normal or high (low is accepted as an alias for eco).", "params": [{ "name": "mode", "type": "string" }] }
+    ],
+    "health": { "supportedStates": ["OK", "OFFLINE"] },
+    "errors": {
+      "ERR_BAD_POWER_MODE": "The device rejected the requested power mode.",
+      "ERR_DEVICE_CALL_FAILED": "The device's HTTP API call failed or returned an error."
+    }
+  }
+}

package/dist/skills/mdk-worker-plugin/assets/worker-template/mock/server.js

@@ -0,0 +1,93 @@
+'use strict'
+
+const http = require('http')
+const debug = require('debug')('mdk:worker:__WORKER_NAME__:mock')
+
+// A standalone device simulator: a small HTTP JSON API (GET /api/v3/summary,
+// POST /api/v3/command) matching src/client.js. It knows nothing about MDK —
+// it is the device-side surface the Worker Plugin translates against, the way
+// a real device on the LAN would be. Replace with your own device's protocol.
+
+const POWER_MODES = {
+  eco: { power: 0.8, hashrate: 0.85 },
+  normal: { power: 1, hashrate: 1 },
+  high: { power: 1.15, hashrate: 1.1 }
+}
+
+function jitter (value) {
+  return Math.round(value * (0.99 + Math.random() * 0.02) * 100) / 100
+}
+
+function createServer ({ host, port, serial, hashrateThs, powerW }) {
+  const state = {
+    serial: serial || 'DEV-0000',
+    baseHashrateThs: hashrateThs || 180,
+    basePowerW: powerW || 3400,
+    powerMode: 'normal',
+    bootTime: Date.now()
+  }
+
+  const summary = () => {
+    const scale = POWER_MODES[state.powerMode]
+    return {
+      serial: state.serial,
+      model: 'DEMO_V1',
+      firmware: 'v1.0.0',
+      uptime_s: Math.floor((Date.now() - state.bootTime) / 1000),
+      power_mode: state.powerMode,
+      hashrate_ths: jitter(state.baseHashrateThs * scale.hashrate),
+      power_w: jitter(state.basePowerW * scale.power),
+      board_temp_c: jitter(62 + (scale.power - 1) * 20)
+    }
+  }
+
+  const command = (body) => {
+    switch (body.cmd) {
+      case 'reboot':
+        state.bootTime = Date.now()
+        return { ok: true, rebooting: true }
+      case 'set-power-mode':
+        if (!POWER_MODES[body.mode]) throw new Error(`ERR_BAD_POWER_MODE: ${body.mode}`)
+        state.powerMode = body.mode
+        return { ok: true, power_mode: state.powerMode }
+      default:
+        throw new Error(`ERR_UNKNOWN_CMD: ${body.cmd}`)
+    }
+  }
+
+  const server = http.createServer((req, res) => {
+    const reply = (code, body) => {
+      res.writeHead(code, { 'content-type': 'application/json' })
+      res.end(JSON.stringify(body))
+    }
+
+    if (req.method === 'GET' && req.url === '/api/v3/summary') return reply(200, summary())
+
+    if (req.method === 'POST' && req.url === '/api/v3/command') {
+      let buf = ''
+      req.on('data', (chunk) => { buf += chunk })
+      req.on('end', () => {
+        try {
+          reply(200, command(JSON.parse(buf || '{}')))
+        } catch (err) {
+          reply(400, { ok: false, error: err.message })
+        }
+      })
+      return
+    }
+
+    reply(404, { ok: false, error: 'ERR_NOT_FOUND' })
+  })
+
+  server.listen(port, host || '127.0.0.1', () => {
+    debug('device mock %s listening on %s:%d', state.serial, host, port)
+  })
+
+  return {
+    server,
+    state,
+    exit () { server.close() }
+  }
+}
+
+module.exports = { createServer }

package/dist/skills/mdk-worker-plugin/assets/worker-template/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "__WORKER_NAME__",
+  "version": "0.12.1",
+  "description": "MDK Worker Plugin — an mdk-contract.json plus src/ handler files, loaded from this directory and instantiated per device by WorkerRuntimeV2 (see `mdk run worker`). It exports no module of its own.",
+  "keywords": [
+    "mdk",
+    "mdk-worker"
+  ],
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "mock": "node -e \"require('./mock/server').createServer({ host: '127.0.0.1', port: 18080, serial: 'DEV-0' })\""
+  },
+  "dependencies": {
+    "@tetherto/mdk-worker": "^0.12.1",
+    "debug": "4.4.1"
+  },
+  "devDependencies": {
+    "brittle": "3.18.0"
+  }
+}

package/dist/skills/mdk-worker-plugin/assets/worker-template/smoke.config.js

@@ -0,0 +1,41 @@
+'use strict'
+
+// Smoke-harness glue for scripts/worker-smoke.mjs and `mdk validate worker
+// --smoke`: setup() boots this worker's device mock and returns { config,
+// commands, teardown }. Adapt all three when copying the template. `config`
+// becomes device opts for WorkerRuntimeV2 (host/port for src/client.js).
+//
+// After teardown() every telemetry channel must fail with an ERR_*. A channel
+// the worker serves from its own store (a `history` log, say) keeps answering
+// instead: list it as `offlineTelemetry: ['history']` next to `teardown`.
+
+const net = require('net')
+
+const mock = require('./mock/server')
+
+function freePort () {
+  return new Promise((resolve, reject) => {
+    const s = net.createServer()
+    s.once('error', reject)
+    s.listen(0, '127.0.0.1', () => {
+      const { port } = s.address()
+      s.close(() => resolve(port))
+    })
+  })
+}
+
+module.exports = {
+  setup: async () => {
+    const port = await freePort()
+    const handle = mock.createServer({ host: '127.0.0.1', port, serial: 'DEV-SMOKE' })
+
+    return {
+      config: { host: '127.0.0.1', port },
+      commands: {
+        reboot: {},
+        setPowerMode: { mode: 'eco' }
+      },
+      teardown: async () => { handle.exit() }
+    }
+  }
+}

package/dist/skills/mdk-worker-plugin/assets/worker-template/src/client.js

@@ -0,0 +1,47 @@
+'use strict'
+
+const { opts, env, config, logger } = require('@tetherto/mdk-worker/device')
+
+// The "vendor SDK" for your device's own HTTP JSON API. Plain device I/O — no
+// MDK concepts, no base classes. This is all a plugin author writes to talk
+// to their own device; replace it with your real protocol.
+//
+// The runtime loads this module fresh into a private registry per device, so
+// binding directly to the ambient device module here — rather than exporting
+// a `createClient(opts)` factory for a caller to invoke — already yields one
+// client per device with no extra plumbing.
+// Log only non-secret fields and key names: `env` carries credentials such as
+// DEVICE_TOKEN, and `opts`/`config` may too — never log their values.
+logger('config received: host=%s port=%s env keys=%o config keys=%o',
+  opts.host, opts.port, Object.keys(env || {}), Object.keys(config || {}))
+
+const base = `http://${opts.host || '127.0.0.1'}:${opts.port}`
+const auth = env.DEVICE_TOKEN ? { authorization: `Bearer ${env.DEVICE_TOKEN}` } : {}
+
+const call = async (path, callOpts) => {
+  let res, body
+  try {
+    res = await fetch(base + path, { ...callOpts, headers: { ...auth, ...(callOpts && callOpts.headers) } })
+    body = await res.json()
+  } catch (err) {
+    // An unreachable device or a non-JSON reply: surface it as this plugin's
+    // own error code, not fetch's bare "fetch failed".
+    throw new Error(`ERR_DEVICE_CALL_FAILED: ${(err.cause && err.cause.code) || err.message}`)
+  }
+  if (!res.ok || body.ok === false) {
+    throw new Error(body.error || `ERR_DEVICE_CALL_FAILED: ${res.status}`)
+  }
+  return body
+}
+
+const command = (cmd, args) => call('/api/v3/command', {
+  method: 'POST',
+  headers: { 'content-type': 'application/json' },
+  body: JSON.stringify({ cmd, ...args })
+})
+
+module.exports = {
+  getSummary: () => call('/api/v3/summary'),
+  reboot: () => command('reboot'),
+  setPowerMode: (mode) => command('set-power-mode', { mode })
+}

package/dist/skills/mdk-worker-plugin/assets/worker-template/src/commands/reboot.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const client = require('../client')
+
+module.exports = async () => client.reboot()

package/dist/skills/mdk-worker-plugin/assets/worker-template/src/commands/set-power-mode.js

@@ -0,0 +1,10 @@
+'use strict'
+
+const client = require('../client')
+
+module.exports = async (params) => {
+  // Example vendor-agnostic-to-firmware translation: this device's API calls
+  // low "eco". Adjust to your own device's vocabulary.
+  const mode = params.mode === 'low' ? 'eco' : params.mode
+  return client.setPowerMode(mode)
+}

package/dist/skills/mdk-worker-plugin/assets/worker-template/src/telemetry/hashrate-rt.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const client = require('../client')
+
+module.exports = async () => (await client.getSummary()).hashrate_ths

package/dist/skills/mdk-worker-plugin/assets/worker-template/src/telemetry/power-mode.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const client = require('../client')
+
+module.exports = async () => (await client.getSummary()).power_mode

package/dist/skills/mdk-worker-plugin/assets/worker-template/src/telemetry/power.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const client = require('../client')
+
+module.exports = async () => (await client.getSummary()).power_w

package/dist/skills/mdk-worker-plugin/assets/worker-template/src/telemetry/temperature.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const client = require('../client')
+
+module.exports = async () => (await client.getSummary()).board_temp_c