scrypted-cisco-camera 1.1.0

package/.github/workflows/release.yml

@@ -0,0 +1,76 @@
+name: Build, Release & Publish
+
+on:
+  workflow_dispatch:
+    inputs:
+      bump_type:
+        description: 'Version bump type (patch, minor, major)'
+        required: true
+        default: 'patch'
+        type: choice
+        options:
+          - patch
+          - minor
+          - major
+
+permissions:
+  contents: write
+  pull-requests: write
+  id-token: write
+
+jobs:
+  release:
+    name: Build, Release, & Publish Plugin
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # Required for pushing tags back
+
+      - name: Setup NodeJS
+        uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Setup Git
+        run: |
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+
+      - name: Install Dependencies
+        run: npm ci
+
+      - name: Build Plugin
+        run: npm run build
+
+      - name: Bump Version
+        id: bump
+        run: |
+          # Bumps the version in package.json and creates a git tag automatically
+          NEW_VERSION=$(npm version ${{ github.event.inputs.bump_type }})
+          echo "new_version=$NEW_VERSION" >> $GITHUB_OUTPUT
+
+      - name: Pack Plugin
+        id: pack
+        run: |
+          # Generate the .tgz file
+          TARBALL=$(npm pack)
+          echo "tarball=$TARBALL" >> $GITHUB_OUTPUT
+
+      - name: Push Version Bump & Tag
+        run: git push --follow-tags
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ steps.bump.outputs.new_version }}
+          files: ${{ steps.pack.outputs.tarball }}
+          generate_release_notes: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Publish to NPM
+        run: npm publish --provenance --access public

package/README.md

@@ -0,0 +1,55 @@
+# Scrypted Cisco 4500E Camera Plugin
+
+This is a custom plugin for [Scrypted](https://github.com/koush/scrypted) designed specifically to handle legacy Cisco IP Cameras, such as the Cisco CIVS-IPC-4500E.
+
+These older Cisco cameras rely on outdated browser technologies (like ActiveX and legacy Java applets) for their web interfaces, and have unstable built-in RTSP servers that often drop frames or produce visual artifacts when streamed directly. This plugin solves both of those problems by bundling a customized backend.
+
+## Features
+
+- **Built-in Modern Web Proxy**: The plugin hosts a modernized version of the camera's original Web UI on a custom port, stripping out the broken ActiveX controls and replacing them with a native HTML5 video player. You can configure camera settings (like motion detection and resolution) right from any modern browser.
+- **Embedded `go2rtc` Service**: To solve the visual artifacting and connection instability, the plugin automatically downloads and runs `go2rtc` locally. It securely intercepts the video feed over a stable TCP connection and re-broadcasts it as an ultra-stable, artifact-free RTSP feed into Scrypted.
+- **Auto-Session Management**: The plugin dynamically scrapes and maintains the required authentication `sessionID` from the camera, ensuring the video stream never times out or drops due to expired credentials.
+- **Zero Configuration Files**: Everything is configured natively through the Scrypted UI.
+
+## Installation & Deployment
+
+Since this is a custom plugin, you'll need to deploy it directly to your Scrypted instance using the `@scrypted/cli`.
+
+### Prerequisites
+- Node.js (v18+)
+- A running instance of Scrypted
+
+### Setup Steps
+1. Clone this repository:
+   ```bash
+   git clone https://github.com/mkelley88/scrypted-cisco-4500e.git
+   cd scrypted-cisco-4500e
+   ```
+2. Install the necessary dependencies:
+   ```bash
+   npm install
+   ```
+3. Build the plugin:
+   ```bash
+   npm run build
+   ```
+4. Deploy it directly to your Scrypted server (replace `<IP_ADDRESS>` with the IP of your Scrypted server):
+   ```bash
+   npx scrypted-deploy <IP_ADDRESS>
+   ```
+
+## Configuration
+
+Once deployed, add a new instance of the **Cisco Camera** plugin in your Scrypted dashboard.
+
+In the plugin's "Stream Settings" page, you will find several required fields:
+- **Camera IP**: The IP address of your Cisco camera.
+- **Username**: The administrator username of the Cisco camera.
+- **Password**: The administrator password of the Cisco camera.
+- **Web Proxy Port**: The local port where the modernized Web UI should be served (Default: `3000`).
+- **Web Proxy Username**: Choose a username to secure the new Web UI.
+- **Web Proxy Password**: Choose a password to secure the new Web UI.
+
+After saving your settings, simply navigate to `http://<SCRYPTED_IP>:<PROXY_PORT>` in your browser to access the modernized camera interface!
+
+

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "scrypted-cisco-camera",
+  "version": "1.1.0",
+  "description": "Cisco IP Camera Plugin",
+  "main": "src/main.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "scrypted-webpack"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "@scrypted/sdk": "^0.5.59",
+    "axios": "^1.18.0",
+    "basic-auth": "^2.0.1",
+    "express": "^5.2.1",
+    "http-proxy-middleware": "^4.1.1",
+    "ssh2": "^1.17.0",
+    "tcp-port-used": "^1.0.3"
+  },
+  "scrypted": {
+    "name": "Cisco Camera",
+    "type": "DeviceProvider",
+    "interfaces": [
+      "DeviceProvider",
+      "DeviceCreator",
+      "VideoCamera",
+      "Settings"
+    ]
+  },
+  "devDependencies": {
+    "@types/basic-auth": "^1.1.8",
+    "@types/express": "^5.0.6",
+    "@types/node": "^26.0.0",
+    "@types/ssh2": "^1.15.5",
+    "@types/tcp-port-used": "^1.0.4",
+    "ts-node": "^10.9.2",
+    "typescript": "^6.0.3"
+  }
+}

package/src/CiscoCamera.d.ts

@@ -0,0 +1,13 @@
+import { Camera, VideoCamera, Settings, Setting, ScryptedDeviceBase, MediaObject, MediaStreamOptions } from "@scrypted/sdk";
+export declare class CiscoCamera extends ScryptedDeviceBase implements Camera, VideoCamera, Settings {
+    private sessionID;
+    constructor(nativeId: string);
+    getSettings(): Promise<Setting[]>;
+    putSetting(key: string, value: string | number | boolean): Promise<void>;
+    private getSessionID;
+    getVideoStream(options?: MediaStreamOptions): Promise<MediaObject>;
+    getVideoStreamOptions(): Promise<MediaStreamOptions[]>;
+    getPictureOptions(): Promise<void>;
+    takePicture(): Promise<MediaObject>;
+}
+//# sourceMappingURL=CiscoCamera.d.ts.map

package/src/CiscoCamera.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CiscoCamera.d.ts","sourceRoot":"","sources":["CiscoCamera.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,MAAM,EACN,WAAW,EACX,QAAQ,EACR,OAAO,EAEP,kBAAkB,EAClB,WAAW,EACX,kBAAkB,EAErB,MAAM,eAAe,CAAC;AAMvB,qBAAa,WAAY,SAAQ,kBAAmB,YAAW,MAAM,EAAE,WAAW,EAAE,QAAQ;IACxF,OAAO,CAAC,SAAS,CAAuB;gBAE5B,QAAQ,EAAE,MAAM;IAItB,WAAW,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IAwBjC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;YAQhE,YAAY;IA6CpB,cAAc,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,WAAW,CAAC;IAuBlE,qBAAqB,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAatD,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAKlC,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC;CAK5C"}

package/src/CiscoCamera.ts

@@ -0,0 +1,415 @@
+import {
+    VideoCamera,
+    Settings,
+    Setting,
+    ScryptedDeviceBase,
+    MediaObject,
+    MediaStreamOptions,
+    ResponseMediaStreamOptions,
+    ScryptedInterface,
+} from "@scrypted/sdk";
+import sdk from "@scrypted/sdk";
+import { Client } from "ssh2";
+import axios from "axios";
+import * as express from "express";
+import { createProxyMiddleware } from "http-proxy-middleware";
+import * as basicAuth from "basic-auth";
+import { spawn, ChildProcess } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import * as https from "https";
+import * as crypto from "crypto";
+import * as http from "http";
+
+const { mediaManager, deviceManager } = sdk;
+
+const SAFE_NVRAM_VALUE = /^[a-zA-Z0-9._\-:\/@ ]*$/;
+
+function sanitizeNvramValue(value: string): string {
+    if (!SAFE_NVRAM_VALUE.test(value)) {
+        throw new Error(`Refusing to set nvram value containing unsafe characters: "${value}"`);
+    }
+    return value;
+}
+
+export class CiscoCamera extends ScryptedDeviceBase implements VideoCamera, Settings {
+    private go2rtcProc?: ChildProcess;
+    private expressServer?: http.Server;
+    private cachedSessionId?: string;
+    private cachedSessionTime: number = 0;
+
+    constructor(nativeId: string) {
+        super(nativeId);
+        
+        // Start background services asynchronously
+        this.startServices().catch(e => {
+            this.console.error("Failed to start services:", e);
+        });
+    }
+
+    release() {
+        if (this.go2rtcProc) {
+            this.console.log("Killing go2rtc process...");
+            this.go2rtcProc.kill();
+        }
+        if (this.expressServer) {
+            this.console.log("Closing Express server...");
+            this.expressServer.close();
+        }
+    }
+
+    private async startServices() {
+        await this.startGo2Rtc();
+        await this.startExpressProxy();
+    }
+
+    private async startGo2Rtc() {
+        // Scrypted plugin storage directory is safe to store binaries
+        const binPath = path.join(process.env.SCRYPTED_PLUGIN_VOLUME || __dirname, 'go2rtc');
+        
+        if (!fs.existsSync(binPath)) {
+            this.console.log("Downloading go2rtc...");
+            const res = await axios.get("https://github.com/AlexxIT/go2rtc/releases/latest/download/go2rtc_linux_amd64", {
+                responseType: "arraybuffer"
+            });
+            fs.writeFileSync(binPath, res.data);
+            fs.chmodSync(binPath, 0o755);
+            this.console.log("go2rtc downloaded successfully.");
+        }
+
+        // Create a custom go2rtc.yaml in the same directory to avoid port conflicts with Scrypted
+        const configPath = path.join(process.env.SCRYPTED_PLUGIN_VOLUME || __dirname, 'go2rtc.yaml');
+        const configContent = `
+api:
+  listen: ":1984"
+rtsp:
+  listen: ":8554"
+webrtc:
+  listen: ":8555"
+`;
+        fs.writeFileSync(configPath, configContent);
+
+        this.console.log("Starting go2rtc process...");
+        this.go2rtcProc = spawn(binPath, ["-config", configPath], {
+            cwd: path.dirname(binPath),
+            stdio: 'pipe'
+        });
+
+        this.go2rtcProc.stdout?.on('data', (data) => this.console.log(`[go2rtc] ${data.toString().trim()}`));
+        this.go2rtcProc.stderr?.on('data', (data) => this.console.error(`[go2rtc] ${data.toString().trim()}`));
+        
+        this.go2rtcProc.on('exit', (code) => {
+            this.console.warn(`go2rtc process exited with code ${code}`);
+            this.go2rtcProc = undefined;
+        });
+    }
+
+    private async startExpressProxy() {
+        const app = express.default();
+        const port = parseInt(this.storage.getItem("proxyPort") || "3000");
+        const proxyUsername = this.storage.getItem("proxyUsername") || "admin";
+        const proxyPassword = this.storage.getItem("proxyPassword");
+
+        const ipAddress = this.storage.getItem("ipAddress");
+        if (!ipAddress) {
+            this.console.warn("Camera IP not configured. Express proxy will not start until IP is set.");
+            return;
+        }
+
+        const CAMERA_URL = `https://${ipAddress}`;
+
+        const legacyAgent = new https.Agent({
+            rejectUnauthorized: false,
+            secureOptions: crypto.constants.SSL_OP_LEGACY_SERVER_CONNECT,
+            ciphers: 'DEFAULT@SECLEVEL=0',
+            minVersion: 'TLSv1'
+        });
+
+        // Basic Auth Middleware
+        app.use((req, res, next) => {
+            if (!proxyPassword) return next(); // Skip auth if no password configured
+            const user = basicAuth.default(req);
+            if (!user || user.name !== proxyUsername || user.pass !== proxyPassword) {
+                res.set('WWW-Authenticate', 'Basic realm="Cisco Camera Web Proxy"');
+                return res.status(401).send('Authentication required.');
+            }
+            next();
+        });
+
+        const go2rtcProxy = createProxyMiddleware({
+            target: 'http://127.0.0.1:1984',
+            pathRewrite: { '^/go2rtc': '' },
+            ws: true
+        });
+        app.use('/go2rtc', go2rtcProxy);
+
+        app.get(/\.(cs|html)$/, async (req, res) => {
+            try {
+                const headers = { ...req.headers };
+                delete headers.host;
+                if (headers.referer) {
+                    headers.referer = headers.referer.replace(`http://${req.headers.host}`, CAMERA_URL);
+                }
+
+                const response = await axios.get(CAMERA_URL + req.originalUrl, { 
+                    responseType: 'arraybuffer',
+                    headers: headers,
+                    maxRedirects: 0,
+                    validateStatus: null,
+                    httpsAgent: legacyAgent
+                });
+                
+                const contentType = (response.headers['content-type'] as string) || '';
+                if (!contentType.includes('text/html') || response.status !== 200) {
+                    Object.entries(response.headers).forEach(([key, value]) => {
+                        res.setHeader(key, value as string);
+                    });
+                    return res.status(response.status).send(response.data);
+                }
+                
+                let html = response.data.toString('utf8');
+                const sessionID = req.query.sessionID || '';
+                
+                if (req.path === '/viewvideo.cs') {
+                    const objectTagRegex = /<object id="DxPlay"[\s\S]*?<\/object>/i;
+                    const webrtcHtml = `
+                    <div id="DxPlay" style="margin-top:-1px; margin-left:10px; margin-right:10px; width:640px; height:480px; background:#000;">
+                        <iframe src="/go2rtc/webrtc.html?src=cisco_camera" width="100%" height="100%" frameborder="0" allowfullscreen></iframe>
+                    </div>`;
+                    html = html.replace(objectTagRegex, webrtcHtml);
+
+                    // Ensure stream is registered in go2rtc
+                    if (sessionID) {
+                        const rtspUrl = `rtsp://${ipAddress}:554/StreamingSetting?version=1.0&action=getRTSPStream&ChannelID=1&ChannelName=Main&sessionID=${sessionID}#transport=tcp`;
+                        try {
+                            await axios.put(`http://127.0.0.1:1984/api/streams?name=cisco_camera&src=${encodeURIComponent(rtspUrl)}`);
+                        } catch(e: any) {
+                            this.console.error("[go2rtc] Failed to register stream:", e.message);
+                        }
+                    }
+                }
+                
+                const polyfill = `
+<script>
+    window.addEventListener('mousemove', (e) => { window.event = e; }, true);
+    window.addEventListener('mousedown', (e) => { window.event = e; }, true);
+    window.addEventListener('mouseup', (e) => { window.event = e; }, true);
+    const originalGetElementById = document.getElementById;
+    document.getElementById = function(id) {
+        let el = originalGetElementById.call(document, id);
+        if (!el) {
+            let elements = document.getElementsByName(id);
+            if (elements && elements.length > 0) return elements[0];
+        }
+        return el;
+    };
+    window.addEventListener('error', function(e) { console.warn("Camera JS Error:", e.message); });
+    const originalAlert = window.alert;
+    window.alert = function(msg) {
+        if (typeof msg === 'string' && msg.includes('.NET SDK/Runtime')) return;
+        if (originalAlert) originalAlert(msg);
+    };
+</script>
+`;
+                html = html.replace('</head>', polyfill + '</head>');
+                
+                html = html.replace(/<body([^>]*)onLoad="([^"]+)"/i, (match: string, before: string, onloadStr: string) => {
+                    const safeLoad = onloadStr.split(';')
+                        .filter((s: string) => s.trim().length > 0)
+                        .map((s: string) => `try{${s}}catch(e){console.warn('onLoad error', e)}`)
+                        .join(';');
+                    return `<body${before}onLoad="${safeLoad}"`;
+                });
+                
+                html = html.replace(/<(input|select)([^>]*)name="([^"]+)"([^>]*)>/ig, (match: string, tag: string, p1: string, name: string, p3: string) => {
+                    if (!match.toLowerCase().includes('id=')) {
+                        return `<${tag}${p1}name="${name}" id="${name}"${p3}>`;
+                    }
+                    return match;
+                });
+                
+                res.setHeader('Content-Type', 'text/html');
+                res.send(html);
+            } catch (e: any) {
+                this.console.error("Error proxying HTML/CS:", e.message);
+                res.status(500).send("Error proxying HTML/CS");
+            }
+        });
+
+        const cameraProxy = createProxyMiddleware({
+            target: CAMERA_URL,
+            changeOrigin: true,
+            secure: false,
+            agent: legacyAgent
+        });
+        app.use('/', cameraProxy);
+
+        this.expressServer = app.listen(port, '0.0.0.0', () => {
+            this.console.log(`Web Proxy running on http://localhost:${port}`);
+        });
+        this.expressServer.on('upgrade', go2rtcProxy.upgrade);
+    }
+
+    async getSettings(): Promise<Setting[]> {
+        return [
+            {
+                title: "Camera IP Address",
+                group: "Device Login",
+                key: "ipAddress",
+                description: "The IP address of the Cisco Camera",
+                value: this.storage.getItem("ipAddress"),
+            },
+            {
+                title: "Username",
+                group: "Device Login",
+                key: "username",
+                description: "The login username",
+                value: this.storage.getItem("username") || "admin",
+            },
+            {
+                title: "Password",
+                group: "Device Login",
+                key: "password",
+                description: "The login password",
+                value: this.storage.getItem("password"),
+                type: "password",
+            },
+            {
+                title: "Web Proxy Port",
+                group: "Web Proxy Settings",
+                key: "proxyPort",
+                type: "number",
+                description: "The port to run the modernized Web UI Proxy on (default 3000)",
+                value: this.storage.getItem("proxyPort") || "3000",
+            },
+            {
+                title: "Web Proxy Username",
+                group: "Web Proxy Settings",
+                key: "proxyUsername",
+                description: "Username for accessing the modernized Web UI",
+                value: this.storage.getItem("proxyUsername") || "admin",
+            },
+            {
+                title: "Web Proxy Password",
+                group: "Web Proxy Settings",
+                key: "proxyPassword",
+                type: "password",
+                description: "Password for accessing the modernized Web UI. Leave blank to disable authentication.",
+                value: this.storage.getItem("proxyPassword"),
+            }
+        ];
+    }
+
+    async putSetting(key: string, value: string | number | boolean): Promise<void> {
+        this.storage.setItem(key, value.toString());
+        // Restart proxy if proxy settings changed
+        if (key === "proxyPort" || key === "proxyUsername" || key === "proxyPassword" || key === "ipAddress") {
+            if (this.expressServer) {
+                this.console.log("Proxy settings changed, restarting Express server...");
+                this.expressServer.close(() => {
+                    this.startExpressProxy().catch(e => this.console.error("Failed to restart Express server:", e));
+                });
+            } else {
+                this.startExpressProxy().catch(e => this.console.error("Failed to restart Express server:", e));
+            }
+        }
+    }
+
+    private async getSessionID(): Promise<string> {
+        const now = Date.now();
+        if (this.cachedSessionId && now - this.cachedSessionTime < 4 * 60 * 1000) {
+            return this.cachedSessionId;
+        }
+
+        const ipAddress = this.storage.getItem("ipAddress");
+        const username = this.storage.getItem("username") || "admin";
+        const password = this.storage.getItem("password");
+
+        if (!ipAddress || !password) {
+            throw new Error("Missing camera IP or password. Please update plugin settings.");
+        }
+
+        const loginUrl = `http://${ipAddress}/login.cs`;
+        const data = new URLSearchParams({
+            action: 'login',
+            version: '1.0',
+            userName: username,
+            password: password
+        });
+
+        try {
+            const response = await axios.post(loginUrl, data.toString(), {
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                timeout: 5000
+            });
+
+            if (response.request?.res?.responseUrl) {
+                const urlMatch = response.request.res.responseUrl.match(/sessionID=(\d+)/);
+                if (urlMatch && urlMatch[1]) {
+                    this.cachedSessionId = urlMatch[1];
+                    this.cachedSessionTime = now;
+                    return urlMatch[1];
+                }
+            }
+
+            const bodyMatch = response.data.match(/sessionID=(\d+)/);
+            if (bodyMatch && bodyMatch[1]) {
+                this.cachedSessionId = bodyMatch[1];
+                this.cachedSessionTime = now;
+                return bodyMatch[1];
+            }
+
+            throw new Error("Could not find sessionID in login response.");
+        } catch (e: any) {
+            this.console.error("Login to camera failed:", e);
+            throw e;
+        }
+    }
+
+    async getVideoStream(options?: MediaStreamOptions): Promise<MediaObject> {
+        const ipAddress = this.storage.getItem("ipAddress");
+        if (!ipAddress) {
+            throw new Error("Camera IP is not set.");
+        }
+
+        const sessionID = await this.getSessionID();
+        const rtspUrl = `rtsp://${ipAddress}:554/StreamingSetting?version=1.0&action=getRTSPStream&ChannelID=1&ChannelName=Main&sessionID=${sessionID}#transport=tcp`;
+        
+        // Ensure go2rtc is tracking the stream
+        try {
+            await axios.put(`http://127.0.0.1:1984/api/streams?name=scrypted_stream&src=${encodeURIComponent(rtspUrl)}`);
+        } catch(e: any) {
+            this.console.error("[go2rtc] Failed to register stream in getVideoStream:", e.message);
+        }
+
+        // Return the local go2rtc RTSP stream which is artifact-free!
+        const cleanRtspUrl = `rtsp://127.0.0.1:8554/scrypted_stream`;
+        this.console.log(`Providing clean RTSP URL from go2rtc: ${cleanRtspUrl}`);
+
+        try {
+            return await mediaManager.createFFmpegMediaObject({
+                url: cleanRtspUrl,
+                inputArguments: [
+                    "-rtsp_transport", "tcp",
+                    "-i", cleanRtspUrl
+                ]
+            });
+        } catch (e) {
+            this.console.error("Failed to create ffmpeg media object:", e);
+            throw e;
+        }
+    }
+    
+    async getVideoStreamOptions(): Promise<ResponseMediaStreamOptions[]> {
+        return [
+            {
+                id: 'default',
+                name: 'Default Stream',
+                tool: 'ffmpeg',
+                video: {
+                    codec: 'h264',
+                }
+            } as any
+        ];
+    }
+}

package/src/main.d.ts

@@ -0,0 +1,12 @@
+import { DeviceProvider, DeviceCreator, DeviceCreatorSettings, Setting } from "@scrypted/sdk";
+import sdk from "@scrypted/sdk";
+import { CiscoCamera } from "./CiscoCamera";
+declare class CiscoCameraProvider extends sdk.ScryptedDeviceBase implements DeviceProvider, DeviceCreator {
+    constructor();
+    getDevice(nativeId: string): Promise<CiscoCamera>;
+    getCreateDeviceSettings(): Promise<Setting[]>;
+    createDevice(settings: DeviceCreatorSettings): Promise<string>;
+}
+declare const _default: CiscoCameraProvider;
+export default _default;
+//# sourceMappingURL=main.d.ts.map

package/src/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["main.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAA0D,aAAa,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACtJ,OAAO,GAAG,MAAM,eAAe,CAAC;AAChC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAI5C,cAAM,mBAAoB,SAAQ,GAAG,CAAC,kBAAmB,YAAW,cAAc,EAAE,aAAa;;IAKvF,SAAS,CAAC,QAAQ,EAAE,MAAM;IAI1B,uBAAuB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IA4B7C,YAAY,CAAC,QAAQ,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,CAAC;CAkCvE;;AAED,wBAAyC"}

package/src/main.ts

@@ -0,0 +1,98 @@
+import { DeviceProvider, ScryptedDeviceType, ScryptedInterface, DeviceDiscovery, DeviceCreator, DeviceCreatorSettings, Setting, ScryptedDeviceBase } from "@scrypted/sdk";
+import sdk from "@scrypted/sdk";
+import { CiscoCamera } from "./CiscoCamera";
+
+const { deviceManager } = sdk;
+
+class CiscoCameraProvider extends ScryptedDeviceBase implements DeviceProvider, DeviceCreator {
+    constructor() {
+        super();
+    }
+
+    async getDevice(nativeId: string) {
+        const device = new CiscoCamera(nativeId);
+        // Force update of existing devices to ensure they have the latest interfaces
+        await deviceManager.onDeviceDiscovered({
+            name: device.name || "Cisco Camera",
+            type: ScryptedDeviceType.Camera,
+            nativeId,
+            interfaces: [
+                ScryptedInterface.VideoCamera,
+                ScryptedInterface.Settings
+            ],
+            info: {
+                model: "CIVS-IPC-4500E",
+                manufacturer: "Cisco",
+            }
+        });
+        return device;
+    }
+    
+    async releaseDevice(id: string, nativeId: string): Promise<void> {
+        // Nothing special to do on release.
+    }
+
+    async getCreateDeviceSettings(): Promise<Setting[]> {
+        return [
+            {
+                title: "Camera Name",
+                key: "name",
+                description: "The name of the camera (e.g., Driveway)",
+                value: "Cisco Camera",
+            },
+            {
+                title: "Camera IP Address",
+                key: "ipAddress",
+                description: "The IP address of the Cisco Camera",
+            },
+            {
+                title: "Username",
+                key: "username",
+                description: "The login username",
+                value: "admin",
+            },
+            {
+                title: "Password",
+                key: "password",
+                description: "The login password",
+                type: "password",
+            }
+        ];
+    }
+
+    async createDevice(settings: DeviceCreatorSettings): Promise<string> {
+        const name = settings.name?.toString() || "Cisco Camera";
+        const ipAddress = settings.ipAddress?.toString();
+        const username = settings.username?.toString() || "admin";
+        const password = settings.password?.toString();
+
+        if (!ipAddress || !password) {
+            throw new Error("IP Address and Password are required");
+        }
+
+        const nativeId = `cisco-${ipAddress.replace(/\./g, '-')}`;
+
+        await deviceManager.onDeviceDiscovered({
+            name,
+            type: ScryptedDeviceType.Camera,
+            nativeId,
+            interfaces: [
+                ScryptedInterface.VideoCamera,
+                ScryptedInterface.Settings
+            ],
+            info: {
+                model: "CIVS-IPC-4500E",
+                manufacturer: "Cisco",
+            }
+        });
+
+        const device = new CiscoCamera(nativeId);
+        await device.storage.setItem("ipAddress", ipAddress);
+        await device.storage.setItem("username", username);
+        await device.storage.setItem("password", password);
+
+        return nativeId;
+    }
+}
+
+export default new CiscoCameraProvider();

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}

package/webpack.nodejs.config.js

@@ -0,0 +1,8 @@
+const baseConfig = require('./node_modules/@scrypted/sdk/webpack.nodejs.config.js');
+
+if (!baseConfig.externals) {
+    baseConfig.externals = {};
+}
+baseConfig.externals['cpu-features'] = 'commonjs cpu-features';
+
+module.exports = baseConfig;