scrypted-kasa 1.3.1 → 1.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "scrypted-kasa",
-   "version": "1.3.1",
+   "version": "1.3.3",
    "description": "TP-Link Kasa plugin for Scrypted — cameras (video, two-way audio, spotlight, siren, status LED), plugs/outlets, wall switches, dimmers, and smart bulbs (on/off, brightness, color, color temperature).",
    "author": "Sergey Vilgelm <sergey@vilgelm.com>",
    "license": "MIT",
@@ -12,6 +12,9 @@
       "url": "https://github.com/sv-tools/scrypted-kasa-plugin/issues"
    },
    "homepage": "https://github.com/sv-tools/scrypted-kasa-plugin#readme",
+   "files": [
+      "dist/plugin.zip"
+   ],
    "scripts": {
       "scrypted-setup-project": "scrypted-setup-project",
       "prescrypted-setup-project": "scrypted-package-json",

package/.github/dependabot.yml

@@ -1,14 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: npm
-    directory: "/"
-    schedule:
-      interval: weekly
-  - package-ecosystem: github-actions
-    directory: "/"
-    schedule:
-      interval: weekly
-    groups:
-      ci:
-        patterns:
-          - "*"

package/.github/workflows/ci.yml

@@ -1,40 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-    branches: [main]
-  push:
-    branches: [main]
-
-# Cancel in-progress runs for the same PR/branch when a new commit is pushed.
-concurrency:
-  group: ci-${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-# Read-only is enough — CI just builds and lints, doesn't push commits, comments, or
-# release artifacts.
-permissions:
-  contents: read
-
-jobs:
-  check:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-
-      - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
-        with:
-          node-version-file: '.nvmrc'
-          cache: 'npm'
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Prettier check
-        run: npm run fmt:check
-
-      - name: ESLint
-        run: npm run lint
-
-      - name: Build (scrypted-webpack)
-        run: npm run build

package/.github/workflows/publish.yml

@@ -1,52 +0,0 @@
-name: Publish
-
-on:
-  push:
-    # Trigger on semver tags like v1.0.7. Push the tag with `git tag v1.0.7 && git push --tags`
-    # after bumping the version in package.json.
-    tags: ['v*']
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      # id-token is required for npm publish provenance — provenance signs the package
-      # via the GitHub OIDC token so consumers can verify it was built by this workflow.
-      id-token: write
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-
-      - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
-        with:
-          node-version-file: '.nvmrc'
-          cache: 'npm'
-          # Configures npm with the registry URL so NODE_AUTH_TOKEN is honored at publish.
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: Verify package.json version matches git tag
-        run: |
-          PKG_VERSION=$(node -p "require('./package.json').version")
-          TAG_VERSION="${GITHUB_REF#refs/tags/v}"
-          if [ "$PKG_VERSION" != "$TAG_VERSION" ]; then
-            echo "::error::package.json version ($PKG_VERSION) does not match git tag ($TAG_VERSION)"
-            exit 1
-          fi
-          echo "Publishing scrypted-kasa@$PKG_VERSION"
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Prettier check
-        run: npm run fmt:check
-
-      - name: ESLint
-        run: npm run lint
-
-      - name: Build (scrypted-webpack)
-        run: npm run build
-
-      - name: Publish to npm
-        run: npm publish --access public --provenance
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.nvmrc

@@ -1 +0,0 @@
-v25

package/.prettierignore

@@ -1,6 +0,0 @@
-node_modules/
-out/
-build/
-dist/
-*.log
-package-lock.json

package/.prettierrc.json

@@ -1,11 +0,0 @@
-{
-    "tabWidth": 4,
-    "useTabs": false,
-    "singleQuote": true,
-    "semi": true,
-    "trailingComma": "all",
-    "printWidth": 120,
-    "arrowParens": "avoid",
-    "bracketSpacing": true,
-    "endOfLine": "lf"
-}

package/eslint.config.mjs

@@ -1,33 +0,0 @@
-import js from '@eslint/js';
-import tseslint from 'typescript-eslint';
-
-// We deliberately don't use `eslint-config-prettier`: typescript-eslint's `recommended`
-// preset focuses on code-quality rules, not style. Prettier already owns formatting via
-// `npm run fmt` / `fmt:check`, and there's nothing in the rule set below that fights it.
-// Skipping the dep also sidesteps the known eslint-config-prettier supply-chain compromise.
-export default tseslint.config(
-    {
-        ignores: ['node_modules/', 'out/', 'build/', 'dist/'],
-    },
-    js.configs.recommended,
-    ...tseslint.configs.recommended,
-    {
-        rules: {
-            // Allow `any` — used intentionally for kasa sysinfo (untyped JSON shape varies
-            // per device family) and for narrow casts where TypeScript can't see through
-            // the runtime tag (e.g. `kasaClass`).
-            '@typescript-eslint/no-explicit-any': 'off',
-
-            // Treat `_`-prefixed args/vars as intentionally unused (matches the convention
-            // we already use for ignored handler params like `_options`, `_id`, `_nativeId`).
-            '@typescript-eslint/no-unused-vars': [
-                'warn',
-                { argsIgnorePattern: '^_', varsIgnorePattern: '^_', caughtErrorsIgnorePattern: '^_' },
-            ],
-
-            // Empty catch blocks are a deliberate teardown idiom in this codebase: e.g.
-            // `try { socket.close(); } catch {}` — best-effort, ignore failure. Don't nag.
-            'no-empty': ['warn', { allowEmptyCatch: true }],
-        },
-    },
-);

package/src/camera/api.ts

@@ -1,354 +0,0 @@
-import { once } from 'events';
-import https from 'https';
-import type { IncomingMessage } from 'http';
-import type { Readable } from 'stream';
-
-// Kasa cameras serve a non-standard mixed multipart stream over HTTPS on this port/path.
-// Reverse-engineered: https://medium.com/@hu3vjeen/reverse-engineering-tp-link-kc100-bac4641bf1cd
-export const KASA_DEFAULT_PORT = 19443;
-export const KASA_STREAM_PATH = '/https/stream/mixed';
-
-// Real headers from this camera fit in well under 1 KB. Cap at 32 KB so a malformed framing
-// (or an attacker who substitutes a non-Kasa endpoint) can't grow the queued chunks until
-// the stream eventually ends. Throwing here surfaces the problem instead of silently
-// retaining memory.
-const MAX_HEADER_BYTES = 32 * 1024;
-
-// Connect-phase idle timeout: while establishing the HTTPS request and waiting for response
-// headers, fires only if the socket is idle for this long. Covers TLS handshake hangs and
-// unresponsive-but-routable cameras — but it's not a strict wall-clock deadline if there
-// is intermittent socket activity without headers arriving. Once headers arrive we clear
-// the socket timeout because kasa cameras on marginal Wi-Fi can go briefly silent (channel
-// scan, AP roam, transient congestion) and recover; killing the stream on every such gap
-// causes more harm than good. Half-open TCP detection is delegated to OS keepalive (see
-// setKeepAlive below) so a Wi-Fi drop without a clean FIN still gets cleaned up.
-const KASA_STREAM_CONNECT_TIMEOUT_MS = 10000;
-
-// Initial idle before the OS sends the first TCP keepalive probe on the streaming socket.
-// During normal streaming, frame-level data activity resets this timer so probes never
-// fire. If the connection dies (Wi-Fi drop, NAT timeout, switch reset), keepalive probes
-// eventually cause the OS to close the socket and our `body.on('close')` triggers teardown.
-// Note: `socket.setKeepAlive(true, initialDelay)` controls only this initial idle period
-// (TCP_KEEPIDLE); total detection/teardown time still depends on OS-level keepalive
-// interval (TCP_KEEPINTVL) and probe count (TCP_KEEPCNT). Linux defaults are often too
-// slow for a live video stream (TCP_KEEPIDLE may default to 7200 s), so 30 s here just
-// starts probing sooner after the stream goes idle.
-const KASA_STREAM_KEEPALIVE_INITIAL_DELAY_MS = 30000;
-
-export const KasaMimeVideo = 'video/x-h264';
-export const KasaMimeG711U = 'audio/g711u';
-
-const H264_NAL_TYPE_SPS = 7;
-const H264_NAL_TYPE_PPS = 8;
-
-export interface H264SpsPps {
-    sps?: Buffer;
-    pps?: Buffer;
-}
-
-// Scans an annex-b H.264 buffer (NALs prefixed by 00 00 01 or 00 00 00 01) for SPS (type 7)
-// and PPS (type 8). Mutates `found` so callers can accumulate across multiple parts; once both
-// are set further calls are cheap and idempotent.
-export function findSpsPps(annexb: Buffer, found: H264SpsPps = {}): H264SpsPps {
-    const len = annexb.length;
-    let i = 0;
-    while (i < len) {
-        let nalStart = -1;
-        if (i + 2 < len && annexb[i] === 0 && annexb[i + 1] === 0) {
-            if (annexb[i + 2] === 1) nalStart = i + 3;
-            else if (i + 3 < len && annexb[i + 2] === 0 && annexb[i + 3] === 1) nalStart = i + 4;
-        }
-        if (nalStart < 0) {
-            i++;
-            continue;
-        }
-        // Walk forward to the next start code; if none, the NAL runs to end-of-buffer.
-        let nalEnd = len;
-        for (let j = nalStart + 1; j + 2 < len; j++) {
-            if (
-                annexb[j] === 0 &&
-                annexb[j + 1] === 0 &&
-                (annexb[j + 2] === 1 || (j + 3 < len && annexb[j + 2] === 0 && annexb[j + 3] === 1))
-            ) {
-                nalEnd = j;
-                break;
-            }
-        }
-        const nalType = annexb[nalStart] & 0x1f;
-        if (nalType === H264_NAL_TYPE_SPS && !found.sps) found.sps = annexb.subarray(nalStart, nalEnd);
-        else if (nalType === H264_NAL_TYPE_PPS && !found.pps) found.pps = annexb.subarray(nalStart, nalEnd);
-        i = nalEnd;
-    }
-    return found;
-}
-
-export interface KasaConnectOptions {
-    ip: string;
-    port?: number;
-    username: string;
-    password: string;
-}
-
-export interface KasaPart {
-    contentType: string;
-    body: Buffer;
-}
-
-// Camera quirk: the Basic auth password must itself be base64(plaintext) before the standard
-// Basic auth base64(user:pass) wrapping. Username is the plaintext Kasa account email.
-function encodeKasaPassword(plaintext: string) {
-    return Buffer.from(plaintext, 'utf8').toString('base64');
-}
-
-export class KasaClient {
-    body!: IncomingMessage;
-    boundary!: string;
-
-    static async connect(options: KasaConnectOptions): Promise<KasaClient> {
-        const port = options.port || KASA_DEFAULT_PORT;
-        // Pre-emptive Basic auth — the camera doesn't send a 401 challenge before serving
-        // the multipart stream; the very first request must already include credentials.
-        // (No need for the auth-fetch challenge/retry dance other endpoints use.)
-        const auth =
-            'Basic ' + Buffer.from(`${options.username}:${encodeKasaPassword(options.password)}`).toString('base64');
-
-        // Cameras present a self-signed cert. The body is consumed as a long-lived stream
-        // rather than buffered to completion, so we don't read the response body here.
-        const response = await new Promise<IncomingMessage>((resolve, reject) => {
-            const req = https.request(
-                {
-                    host: options.ip,
-                    port,
-                    method: 'GET',
-                    path: KASA_STREAM_PATH,
-                    rejectUnauthorized: false,
-                    headers: {
-                        Authorization: auth,
-                        Accept: '*/*',
-                        Connection: 'keep-alive',
-                    },
-                },
-                response => {
-                    // Headers in — clear the connect-phase idle timeout so it doesn't
-                    // keep firing during normal streaming gaps. setTimeout(0) on the
-                    // underlying socket disables Node's idle-timeout machinery.
-                    response.socket?.setTimeout(0);
-                    // Enable OS-level TCP keepalive as a safety net for half-open
-                    // detection. During normal streaming the data flow keeps this from
-                    // firing, but if Wi-Fi drops / NAT times out without a clean FIN,
-                    // keepalive probes will eventually fail and the kernel will close
-                    // the socket — without keepalive we'd block forever in readPart()
-                    // waiting for a multipart header that never arrives.
-                    response.socket?.setKeepAlive(true, KASA_STREAM_KEEPALIVE_INITIAL_DELAY_MS);
-                    resolve(response);
-                },
-            );
-            req.setTimeout(KASA_STREAM_CONNECT_TIMEOUT_MS, () => {
-                req.destroy(new Error(`kasa stream connect timeout after ${KASA_STREAM_CONNECT_TIMEOUT_MS}ms`));
-            });
-            req.on('error', reject);
-            req.end();
-        });
-
-        if (response.statusCode && response.statusCode >= 400) {
-            response.destroy();
-            throw new Error(`kasa stream HTTP ${response.statusCode}`);
-        }
-
-        const contentType = (response.headers['content-type'] || '') as string;
-        if (!/multipart\/x-mixed-replace/i.test(contentType)) {
-            response.destroy();
-            throw new Error(`unexpected content-type: ${contentType}`);
-        }
-
-        const m = /boundary=([^;\s]+)/i.exec(contentType);
-        if (!m) {
-            response.destroy();
-            throw new Error(`missing boundary in content-type: ${contentType}`);
-        }
-
-        const client = new KasaClient();
-        client.body = response;
-        client.boundary = m[1];
-        return client;
-    }
-
-    destroy() {
-        this.body?.destroy();
-    }
-
-    async readPart(): Promise<KasaPart> {
-        const expected = '--' + this.boundary;
-
-        // Read the boundary + header block as one buffer (terminated by a blank line) and
-        // walk it byte-wise to extract just content-type and content-length. At ~30 parts/s
-        // this avoids the regex split and ~6 string allocations per part that a per-line
-        // approach would do.
-        const headerBlock = await readUntilDoubleCrlf(this.body);
-        const len = headerBlock.length;
-
-        // Pull out the next \r\n- or \n-terminated line as a string. Returns the slice plus
-        // the index just after the line terminator. Skips leading blank lines so a stray
-        // CRLF before the boundary (some firmwares) doesn't break parsing.
-        const nextLine = (start: number): { line: string; next: number } => {
-            let i = start;
-            // Find next LF.
-            while (i < len && headerBlock[i] !== 0x0a) i++;
-            // Trim a trailing CR if present.
-            const end = i > start && headerBlock[i - 1] === 0x0d ? i - 1 : i;
-            return { line: headerBlock.toString('utf8', start, end), next: i + 1 };
-        };
-
-        let pos = 0;
-        // Tolerate leading empty lines.
-        while (pos < len) {
-            const { line, next } = nextLine(pos);
-            if (line) {
-                if (line !== expected) throw new Error(`unexpected boundary line: ${JSON.stringify(line)}`);
-                pos = next;
-                break;
-            }
-            pos = next;
-        }
-
-        let contentType = '';
-        let length = -1;
-        while (pos < len) {
-            const { line, next } = nextLine(pos);
-            pos = next;
-            if (!line) break;
-            // Header names from this camera are stable (`Content-Type:`, `Content-Length:`),
-            // but match case-insensitively to tolerate firmware revisions.
-            if (line.length > 13 && line.charCodeAt(12) === 0x3a /* : */) {
-                const name = line.slice(0, 12);
-                if (name === 'Content-Type' || name.toLowerCase() === 'content-type') {
-                    contentType = line.slice(13).trim();
-                    continue;
-                }
-            }
-            if (line.length > 15 && line.charCodeAt(14) === 0x3a) {
-                const name = line.slice(0, 14);
-                if (name === 'Content-Length' || name.toLowerCase() === 'content-length') {
-                    const n = parseInt(line.slice(15).trim(), 10);
-                    if (Number.isFinite(n) && n >= 0) length = n;
-                    continue;
-                }
-            }
-        }
-
-        if (length < 0) throw new Error('multipart: no/invalid content length');
-
-        const body = length === 0 ? Buffer.alloc(0) : await readLength(this.body, length);
-        return { contentType, body };
-    }
-}
-
-// Read exactly `length` bytes from a Readable. Returns when the bytes are available;
-// throws if the stream ends before that.
-async function readLength(readable: Readable, length: number): Promise<Buffer> {
-    if (readable.readableEnded || readable.destroyed) throw new Error('kasa stream ended before readLength');
-
-    {
-        const ret = readable.read(length);
-        if (ret) return ret;
-    }
-
-    return new Promise<Buffer>((resolve, reject) => {
-        const onReadable = () => {
-            const ret = readable.read(length);
-            if (ret) {
-                cleanup();
-                resolve(ret);
-            }
-        };
-        const onEnd = () => {
-            cleanup();
-            reject(new Error('kasa stream ended during readLength'));
-        };
-        const cleanup = () => {
-            readable.removeListener('readable', onReadable);
-            readable.removeListener('end', onEnd);
-            readable.removeListener('close', onEnd);
-            readable.removeListener('error', onError);
-        };
-        const onError = (e: Error) => {
-            cleanup();
-            reject(e);
-        };
-        readable.on('readable', onReadable);
-        readable.on('end', onEnd);
-        readable.on('close', onEnd);
-        readable.on('error', onError);
-    });
-}
-
-// Read up to and including the first blank line (CRLF CRLF or LF LF) and return everything
-// up to and including the terminator as a Buffer. Whatever bytes come after are unshifted
-// back so the body that follows can be read intact. Enforces MAX_HEADER_BYTES so a malformed
-// stream that never sends a terminator can't grow queued chunks unbounded.
-async function readUntilDoubleCrlf(readable: Readable): Promise<Buffer> {
-    const queued: Buffer[] = [];
-    let queuedLen = 0;
-    // crlf encodes how many bytes of \r\n\r\n we've matched: 0,1=\r, 2=\r\n, 3=\r\n\r, 4=done.
-    // lfOnly counts consecutive \n bytes (some firmwares emit LF-only framing).
-    let crlf = 0;
-    let lfOnly = 0;
-    while (true) {
-        if (readable.readableEnded || readable.destroyed) throw new Error('kasa stream ended before headers');
-        const chunk: Buffer | null = readable.read();
-        if (!chunk) {
-            // Race 'readable' against 'end'/'close'/'error': if the stream has already ended
-            // (or terminates while we're waiting), 'readable' will never fire and the await
-            // would strand this promise forever. Re-checking readableEnded on the next loop
-            // turn lets us throw a real error instead of hanging.
-            //
-            // AbortController removes the losing once() listeners; without it each iteration
-            // would leave 2 dangling listeners attached for the lifetime of the stream and
-            // eventually trip MaxListenersExceededWarning on a long stream with many parts.
-            const ac = new AbortController();
-            try {
-                await Promise.race([
-                    once(readable, 'readable', { signal: ac.signal }).catch(() => {
-                        /* aborted or end */
-                    }),
-                    once(readable, 'end', { signal: ac.signal }).catch(() => {}),
-                    once(readable, 'close', { signal: ac.signal }).catch(() => {}),
-                ]);
-            } finally {
-                ac.abort();
-            }
-            continue;
-        }
-        let split = -1;
-        for (let i = 0; i < chunk.length; i++) {
-            const b = chunk[i];
-            if (crlf === 0 && b === 0x0d) crlf = 1;
-            else if (crlf === 1 && b === 0x0a) crlf = 2;
-            else if (crlf === 2 && b === 0x0d) crlf = 3;
-            else if (crlf === 3 && b === 0x0a) {
-                split = i + 1;
-                break;
-            } else crlf = b === 0x0d ? 1 : 0;
-            if (b === 0x0a) {
-                if (++lfOnly === 2) {
-                    split = i + 1;
-                    break;
-                }
-            } else lfOnly = 0;
-        }
-        if (split < 0) {
-            queuedLen += chunk.length;
-            if (queuedLen > MAX_HEADER_BYTES)
-                throw new Error(`multipart header exceeded ${MAX_HEADER_BYTES} bytes without terminator`);
-            queued.push(chunk);
-            continue;
-        }
-        const headerPart = chunk.subarray(0, split);
-        const rest = chunk.subarray(split);
-        if (queuedLen + headerPart.length > MAX_HEADER_BYTES)
-            throw new Error(`multipart header exceeded ${MAX_HEADER_BYTES} bytes`);
-        queued.push(headerPart);
-        if (rest.length) readable.unshift(rest);
-        return queued.length === 1 ? queued[0] : Buffer.concat(queued);
-    }
-}