Merge pull request 'Initial app + gitea action' (#1) from dev into main

Reviewed-on: https://git.dwestgate.us/david/ota-tv-web/pulls/1

.gitea/workflows/deploy.yml

@@ -0,0 +1,33 @@
+name: Personal Website - Run Python HTTP Server
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  deploy:
+    runs-on: self-hosted
+
+    steps:
+      - name: Checkout code
+        run: |
+          cd ~/ota-tv-web
+          git fetch
+          git checkout main
+          git pull origin main
+
+      - name: Stop existing screen session, if running
+        run: |
+          if screen -list | grep -q "ota_tv_web_server"; then
+            echo "Stopping existing screen session..."
+            screen -S ota_tv_web -X quit
+          fi
+
+      - name: Start server in screen session
+        run: |
+          cd ~/ota-tv-web
+          chmod +x ./start.sh
+          sassc css/style.scss css/style.css
+          setsid screen -dmS ota_tv_web bash -c 'HTTP_PORT=8081 WS_PORT=3001 npm start > server.log 2>&1'
+          echo "Server started in detached screen session"

.gitignore

@@ -0,0 +1,2 @@
+node_modules/*
+dist/*

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "typescript.tsdk": "node_modules/typescript/lib"
+}

dvb_channel.conf

@@ -0,0 +1,7 @@
+FOX 12:207028615:8VSB:49:52:3
+ION:521028615:8VSB:49:52:3
+KATU:533028615:8VSB:49:52:3
+KOIN-HD:539028615:8VSB:49:52:3
+KGW:545028615:8VSB:49:52:3
+KBLN-DT:575028615:8VSB:49:52:1
+TBN HD:581028615:8VSB:49:52:3

package.json

@@ -0,0 +1,22 @@
+{
+  "dependencies": {
+    "@roamhq/wrtc": "^0.8.0",
+    "node-pre-gyp": "^0.17.0",
+    "ws": "^8.18.0"
+  },
+  "scripts": {
+    "build:scss": "npx sass src/static/css:dist/static/css",
+    "copy:html": "cp src/static/index.html dist/static",
+    "build:js:fe": "npx tsc src/static/js/*.ts --outDir dist/static/js",
+    "build:js:be": "npx tsc --skipLibCheck src/*.ts --outDir dist",
+    "build": "npm run build:js:fe && npm run build:js:be && npm run build:scss && npm run copy:html",
+    "start": "npm run build && node dist/server.js",
+    "dev": "npm run build && npx ts-node src/server.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@types/ws": "^8.5.13",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.2"
+  }
+}

scripts.bash

@@ -0,0 +1,6 @@
+curl https://git.linuxtv.org/dtv-scan-tables.git/plain/atsc/us-ATSC-center-frequencies-8VSB
+
+
+dvbv5-zap -r -c dvb_channel.conf -CUS -IZAP "ION"
+
+dvbv5-scan -Cus -o dvb_channel.conf -O zap -v  us-ATSC-center-frequencies-8VSB

src/http.ts

@@ -0,0 +1,82 @@
+import * as http from "http";
+import * as fs from "fs";
+import * as path from "path";
+
+
+export default class HttpServer {
+
+    private httpServer: http.Server;
+    private port: number;
+    private root: string;
+    public constructor(port: number, root: string, tune: (ch: string, adp?: number) => void, getChannels: ()=>string[], getSignal: (adapter:number)=>object) {
+        this.port = port;
+        this.root = root;
+        this.httpServer = http.createServer((req, res) => {
+            let status: number = 404;
+            let body: any = "";
+            const url = new URL(req.url, `http://${req.headers.host}`);
+            const pathname = path.normalize(url.pathname);
+
+            if (pathname.startsWith('/api/')) {
+                const query = pathname.split('/');
+                const api = query[2];
+                switch (req.method) {
+                    case "GET":
+                        switch (api) {
+                            case "list":
+                                body = JSON.stringify(getChannels());
+                                status = 200;
+                                break;
+                            case "signal":
+                                const adapter = parseInt(url.searchParams.get('adapter'));
+                                body = JSON.stringify(getSignal(adapter));
+                                status = 200;
+                                break;
+
+                        }
+                        break;
+                    case "PUT":
+                        switch (api) {
+                            case "tune":
+                                const channel = decodeURIComponent(query[3]);
+                                const adapter = parseInt(url.searchParams.get('adapter'));
+                                tune(channel, adapter);
+                                status = 202;
+                                break;
+     
+                        }
+
+                }
+            }
+            else if (req.method === 'GET') {
+                const filePath = path.join(root, path.extname(pathname) === '' ? pathname + "/index.html" : pathname);
+                try {
+                    body = fs.readFileSync(filePath);
+                    status = 200;
+                }
+                catch (err) {
+                    body = "Invalid File"
+                }
+            }
+            else {
+                body = "Invalid Request"
+            }
+            res.writeHead(status);
+            res.end(body);
+
+        });
+    }
+    public start() {
+        this.httpServer.listen(this.port, () => {
+            console.log(`Serving ${this.root} at http://localhost:${this.port}`);
+        });
+    }
+
+
+
+
+
+
+
+}
+

src/server.ts

@@ -0,0 +1,56 @@
+import HttpServer from './http';
+import TVWebSocket from './ws';
+import Zap, { IZap } from './zap';
+
+const HTTP_PORT = process.env.HTTP_PORT ? parseInt(process.env.HTTP_PORT, 10) : 8080;
+const WS_PORT = process.env.WS_PORT ? parseInt(process.env.WS_PORT, 10) : 3001;
+const STATIC_ROOT = process.cwd() + "/dist/static";
+const TV_DEV_0 = process.env.TV_DEV_0 ?? '/dev/dvb/adapter0/dvr0'
+const TV_DEV_1 = process.env.TV_DEV_1 ?? '/dev/dvb/adapter1/dvr0';
+
+const zap = new Zap();
+
+
+const tune = (reqChannel: string, reqAdapter?: number) => {
+    const adapter = reqAdapter === 0 || reqAdapter === 1 ? reqAdapter : 0;
+    zap.zapTo(reqChannel, adapter).then((zap: IZap) => {
+        console.log(`Tuned ${zap.adapter} to ${zap.channel}`)
+    }).catch((err: Error) => {
+        console.error(err.message);
+    });
+}
+
+const getChannels = () =>
+    zap.getChannels();
+
+const getSignal = (adapter: number) =>
+    zap.getSignal(adapter)
+
+const httpServer = new HttpServer(HTTP_PORT, STATIC_ROOT, tune, getChannels, getSignal);
+const tvWebSocket0 = new TVWebSocket(WS_PORT, TV_DEV_0);
+const tvWebSocket1 = new TVWebSocket(WS_PORT + 1, TV_DEV_1);
+httpServer.start();
+
+
+process.stdin.setEncoding("utf8");
+process.stdin.resume();
+
+console.log("Enter Channel Name:");
+
+process.stdin.on("data", async (data: string) => {
+    const input = data.trim();
+    console.log(`Received: "${input}"`);
+    await zap.zapTo(input).then((zap: IZap) => {
+        console.log(`Tuned ${zap.adapter} to ${zap.channel}`)
+
+    }).catch((err: Error) => {
+        console.error(err.message);
+    });
+
+});
+
+
+
+
+
+

src/static/css/index.scss

@@ -0,0 +1,60 @@
+$background-color: #c7c7c7;
+$primary-color: #333;
+$secondary-color: #d11414;
+$text-color: #123455;
+
+body {
+    font-family: sans-serif;
+    background-color: $background-color;
+    header {
+        nav {
+            ul {
+                display: flex;
+                list-style: none;
+                gap: 1em;
+                li {
+
+                }
+            }
+            a {
+                &:hover {}
+            }
+        }
+    }
+
+    main {
+        display: flex;
+        flex-direction: column;
+        text-align: center;
+        align-items: center;
+        justify-content: center;
+        h1 {}
+
+        p {}
+        img {
+            width: 20em;
+            border-radius: 50%;
+        }
+        .content{
+            display: flex;
+            flex-direction: row;
+            gap: 1em;
+            .player{
+
+                .channel-group{
+                    display: flex;
+                    align-self: center;
+                    justify-self: center;
+                }
+            }
+        }
+        
+    }
+
+
+    footer {
+        text-align: center;
+        // background: #eee;
+        padding: 1em;
+    }
+}

src/static/index.html

@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <title>WebRTC Stream</title>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <link rel="stylesheet" href="css/index.css" />
+</head>
+
+<body>
+  <header></header>
+  <main>
+    <h1>Video streams</h1>
+    <h2>WebRTC</h2>
+    <div class="content">
+      <div class="player">
+        <video id="video0" autoplay playsinline controls></video>
+        <div id="channel-container-0" class="channel-group"></div>
+        <button onClick="tune(0)">Tune</button>
+        <p id="signal-0">N/A</p>
+        <button onClick="getSignal(0)">Get Signal</button>
+      </div>
+
+      <div class="player">
+        <video id="video1" autoplay playsinline controls></video>
+        <div id="channel-container-1" class="channel-group"></div>
+        <button onClick="tune(1)">Tune</button>
+        <p id="signal-1">N/A</p>
+        <button onClick="getSignal(1)">Get Signal</button>
+
+      </div>
+  </main>
+  </div>
+
+  <script src="js/video.js"></script>
+  <script src="js/doc.js"></script>
+</body>
+
+</html>

src/static/js/doc.ts

@@ -0,0 +1,61 @@
+const PLAYERS = 2;
+
+const populateChannels = (players: number) => {
+    fetch('/api/list').then(async (res) => {
+        const channelNames: string[] = await res.json()
+
+
+        for (let i = 0; i < players; ++i) {
+            const radioGroup = document.getElementById(`channel-container-${i}`);
+            if (!radioGroup) {
+                throw new Error("Radio group not found")
+            }
+            radioGroup.innerHTML = ''
+            channelNames.forEach((channelName, _) => {
+                const id = `radio-${i}-${channelName}`;
+
+                const input = document.createElement('input');
+                input.type = "radio"
+                input.name = `channel-radio-${i}`;
+                input.value = `${channelName}`;
+                input.id = id
+
+                const lbl = document.createElement("label");
+                lbl.htmlFor = id;
+                lbl.textContent = channelName;
+
+                const wrapper = document.createElement("div");
+                wrapper.appendChild(input);
+                wrapper.appendChild(lbl);
+
+                radioGroup.appendChild(wrapper)
+            })
+        }
+
+    }).catch(err => {
+        console.log("nope ", err)
+    })
+}
+
+const tune = (adapter = 0) => {
+    const choice = document.querySelector<HTMLInputElement>(`input[name="channel-radio-${adapter}"]:checked`)
+    const channel = choice?.value;
+    if (channel) {
+        fetch(`/api/tune/${channel}?adapter=${adapter}`, { method: 'PUT' })
+    }
+
+}
+
+const getSignal = (adapter = 0) => {
+    const signalElement = document.getElementById(`signal-${adapter}`);
+    if (!signalElement) {
+        return;
+    }
+    fetch(`/api/signal?adapter=${adapter}`).then(res =>
+        res.json()
+    ).then((strength: any) => {
+        signalElement.innerHTML = `Signal: ${strength.signal} C/N: ${strength.cn}`
+    })
+}
+
+populateChannels(PLAYERS);

src/static/js/video.ts

@@ -0,0 +1,67 @@
+const host = window.location.hostname
+const ws0 = new WebSocket(`ws://${host}:3001`);
+const ws1 = new WebSocket(`ws://${host}:3002`);
+const pc0 = new RTCPeerConnection({ iceServers: [] });
+const pc1 = new RTCPeerConnection({ iceServers: [] });
+const video0 = document.getElementById('video0') as HTMLVideoElement;
+const video1 = document.getElementById('video1') as HTMLVideoElement;
+
+// 0
+pc0.ontrack = (event) => {
+  console.log("Received track event", event.streams);
+  video0.srcObject = event.streams[0];
+};
+
+pc0.onicecandidate = ({ candidate }) => {
+  if (candidate) {
+    ws0.send(JSON.stringify({ type: 'ice-candidate', data: candidate }));
+  }
+};
+
+ws0.onopen = async () => {
+  pc0.addTransceiver('video', { direction: 'recvonly' });
+  pc0.addTransceiver('audio', { direction: 'recvonly' })
+  const offer = await pc0.createOffer();
+  await pc0.setLocalDescription(offer);
+  ws0.send(JSON.stringify({ type: 'offer', data: offer }));
+}
+
+ws0.onmessage = async (message) => {
+  const msg = JSON.parse(message.data);
+  if (msg.type === 'answer') {
+    await pc0.setRemoteDescription(msg.data);
+  }
+  else if (msg.type === 'ice-candidate') {
+    await pc0.addIceCandidate(msg.data);
+  }
+};
+
+// 1
+pc1.ontrack = (event) => {
+  console.log("Received track event", event.streams);
+  video1.srcObject = event.streams[0];
+};
+
+pc1.onicecandidate = ({ candidate }) => {
+  if (candidate) {
+    ws1.send(JSON.stringify({ type: 'ice-candidate', data: candidate }));
+  }
+};
+
+ws1.onopen = async () => {
+  pc1.addTransceiver('video', { direction: 'recvonly' });
+  pc1.addTransceiver('audio', { direction: 'recvonly' })
+  const offer = await pc1.createOffer();
+  await pc1.setLocalDescription(offer);
+  ws1.send(JSON.stringify({ type: 'offer', data: offer }));
+}
+
+ws1.onmessage = async (message) => {
+  const msg = JSON.parse(message.data);
+  if (msg.type === 'answer') {
+    await pc1.setRemoteDescription(msg.data);
+  }
+  else if (msg.type === 'ice-candidate') {
+    await pc1.addIceCandidate(msg.data);
+  }
+};

src/ws.ts

@@ -0,0 +1,200 @@
+import { MediaStream, MediaStreamTrack, nonstandard, RTCPeerConnection } from '@roamhq/wrtc';
+import { ChildProcessWithoutNullStreams, spawn } from 'child_process';
+import * as ws from 'ws';
+
+// Constants
+const WIDTH = 640; // Video width
+const HEIGHT = 480; // Video height
+const FRAME_SIZE = WIDTH * HEIGHT * 1.5; // YUV420p frame size (460800 bytes)
+
+export default class TVWebSocket {
+    videoDevice: string;
+    public constructor(port: number, videoDevice) { 
+        this.videoDevice = videoDevice   
+        const ffmpegProcess = this.startFFmpeg();
+        const videoTrack = this.createVideoTrack(ffmpegProcess);
+        const audioTrack = this.createAudioTrack(ffmpegProcess);
+
+
+        ffmpegProcess.stdio[2].on('data',data=>{
+            // console.log("stdio[2] ",data.toString())
+        })
+
+        // WebSocket signaling server
+        const wss = new ws.WebSocketServer({ port });
+
+        wss.on('connection', async (ws: ws.WebSocket) => {
+            const peerConnection: RTCPeerConnection =  this.createPeerConnection(videoTrack, audioTrack);
+
+            ws.on('message', async (message: Buffer) => {
+                const { type, data } = JSON.parse(message.toString());
+
+                if (type == 'offer') {
+                    await peerConnection.setRemoteDescription(data);
+                    const answer = await peerConnection.createAnswer();
+                    await peerConnection.setLocalDescription(answer);
+                    ws.send(JSON.stringify({ type: 'answer', data: peerConnection.localDescription }));
+                }
+
+                if (type === 'ice-candidate') {
+                    await peerConnection.addIceCandidate(data);
+                }
+
+            });
+
+            peerConnection.oniceconnectionstatechange = () => {
+                if (peerConnection.iceConnectionState === 'failed') {
+                    console.error('ICE connection failed');
+                }
+            };
+
+
+            // Send ICE candidates to the client
+            peerConnection.onicecandidate = ({ candidate }) => {
+                if (candidate) {
+                    ws.send(JSON.stringify({ type: 'ice-candidate', data: candidate }));
+                }
+            };
+
+            ws.on('close', () => {
+                console.log('Client disconnected');
+                peerConnection.close();
+            });
+        });
+    }
+
+    // Function to start FFmpeg and capture raw video
+    startFFmpeg = (): ChildProcessWithoutNullStreams => {
+        const p = spawn('ffmpeg', [
+            '-loglevel', 'debug',
+            '-i', this.videoDevice,
+
+            // Video
+            '-map', '0:v:0',
+            '-vf', `scale=${WIDTH}:${HEIGHT}`,
+            '-vcodec', 'rawvideo',
+            '-pix_fmt', 'yuv420p',
+            '-f', 'rawvideo',
+
+            //quality
+            '-fflags', '+discardcorrupt',
+            '-err_detect', 'ignore_err',
+            '-analyzeduration', '100M',
+            '-probesize', '100M',
+
+            'pipe:3',
+
+            // Audio
+            '-map', '0:a:0',
+            '-acodec', 'pcm_s16le',
+            '-ac', '1',
+            '-ar', '48000',
+            '-f', 's16le',
+            'pipe:4'
+
+        ], {
+            stdio: ['ignore', 'pipe', 'pipe', 'pipe', 'pipe']
+        });
+        process.on('SIGINT', () => {
+            console.log('🔻 Server shutting down...');
+            p.kill('SIGINT');
+            process.exit(0);
+        });
+
+        process.on('SIGTERM', () => {
+            console.log('🔻 SIGTERM received');
+            p.kill('SIGTERM');
+            process.exit(0);
+        });
+        process.on('exit', () => {
+            p.kill('SIGHUP'); //this one
+            p.kill('SIGTERM');
+        });
+        return p;
+    }
+
+    
+    createVideoTrack = (ffmpegProcess: ChildProcessWithoutNullStreams) => {
+        let videoBuffer = Buffer.alloc(0);
+        const videoSource = new nonstandard.RTCVideoSource();
+        const videoStream = ffmpegProcess.stdio[3]; // pipe:3
+        // Start FFmpeg and pipe video frames to the source
+        videoStream.on('data', (chunk: Buffer) => {
+            videoBuffer = Buffer.concat([videoBuffer, chunk]);
+            if (videoBuffer.length > FRAME_SIZE * 2) {
+                console.warn('Video buffer overrun — possible freeze trigger');
+            }
+            while (videoBuffer.length >= FRAME_SIZE) {
+                const frameData = videoBuffer.slice(0, FRAME_SIZE);
+                videoBuffer = videoBuffer.slice(FRAME_SIZE);
+                const frame: nonstandard.RTCVideoFrame = {
+                    width: WIDTH,
+                    height: HEIGHT,
+                    data: new Uint8Array(frameData),
+                }
+                videoSource.onFrame(frame);
+            }
+        });
+
+        videoStream.on('data', (data: Buffer) => {
+            // console.error('FFmpeg Error:', data.toString());
+        });
+
+        videoStream.on('exit', (code) => {
+            console.log(`FFmpeg exited with code ${code}`);
+        });
+        return videoSource.createTrack();
+
+    }
+
+    createAudioTrack = (ffmpegProcess: ChildProcessWithoutNullStreams) => {
+        let audioBuffer = Buffer.alloc(0);
+        const audioSource = new nonstandard.RTCAudioSource();
+        const audioStream = ffmpegProcess.stdio[4]; // pipe:4
+        // --- AUDIO handling ---
+        const AUDIO_FRAME_SIZE = 480 * 2; // 480 samples * 2 bytes (s16le)
+
+
+        audioStream.on('data', (chunk: Buffer) => {
+            audioBuffer = Buffer.concat([audioBuffer, chunk]);
+            while (audioBuffer.length >= AUDIO_FRAME_SIZE) {
+                const frameData = audioBuffer.slice(0, AUDIO_FRAME_SIZE);
+                audioBuffer = audioBuffer.slice(AUDIO_FRAME_SIZE);
+                const samples = new Int16Array(480);
+                for (let i = 0; i < 480; i++) {
+                    samples[i] = frameData.readInt16LE(i * 2);
+                }
+                audioSource.onData({
+                    samples,
+                    sampleRate: 48000,
+                    bitsPerSample: 16,
+                    channelCount: 1,
+                    numberOfFrames: 480
+                });
+            }
+        });
+
+        audioStream.on('data', (data: Buffer) => {
+            // console.error('FFmpeg Error:', data.toString());
+        });
+
+        audioStream.on('exit', (code) => {
+            console.log(`FFmpeg exited with code ${code}`);
+        });
+        return audioSource.createTrack();
+    }
+
+    createPeerConnection = (videoTrack: MediaStreamTrack, audioTrack: MediaStreamTrack): RTCPeerConnection => {
+        const peerConnection = new RTCPeerConnection({ iceServers: [] });
+        const stream = new MediaStream()
+        stream.addTrack(videoTrack)
+        stream.addTrack(audioTrack);
+        peerConnection.addTrack(videoTrack, stream);
+        peerConnection.addTrack(audioTrack, stream);
+        return peerConnection;
+    }
+
+}
+
+
+

src/zap.ts

@@ -0,0 +1,164 @@
+import { spawn, ChildProcessWithoutNullStreams } from "child_process";
+import * as fs from "fs";
+
+export interface IZap {
+    process: ChildProcessWithoutNullStreams | null,
+    channel: string,
+    adapter: 0 | 1
+    strength: {
+        signal: string;
+        cn: string;
+    },
+}
+
+export default class Zap {
+    private zap0: IZap;
+    private zap1: IZap;
+    private channelNameList: string[];
+    private fileName: string;
+
+    private  regex = /Signal=\s*(-?\d+(\.\d+)?dBm)\s+C\/N=\s*(\d+(\.\d+)?dB)/;
+
+
+    public constructor(fileName = "dvb_channel.conf", channel = "ION") {
+        const zap0: IZap = {
+            process: null,
+            channel,
+            adapter: 0,
+            strength: {
+                signal: "None", 
+                cn: "None"
+            }
+        }
+        const zap1: IZap = {
+            process: null,
+            channel,
+            adapter: 1,
+            strength: {
+                signal: "None", 
+                cn: "None"
+            }
+        }
+        this.zap0 = zap0;
+        this.zap1 = zap1;
+
+        const file = fs.readFileSync('./' + fileName, "utf-8");
+        const lines = file.split("\n").map(line => line.trim()).filter(line => line && !line.startsWith("#")).map(line => line.split(":")[0]);
+        this.channelNameList = lines;
+        this.fileName = fileName;
+
+    }
+
+    public getChannels(): string[] {
+        return this.channelNameList;
+    }
+
+    public getSignal(adapter: number) {
+        if(adapter == 0){
+            return this.zap0.strength;
+        }
+        else if (adapter == 1){
+            return this.zap1.strength;
+        }
+        else {
+            return {signal: 'N/A', cn: 'N/A'}
+        }
+    }
+
+    private nextChannel(channel: string) :string {
+        const size = this.channelNameList.length;
+        const currentIndex = this.channelNameList.indexOf(channel);
+        if (currentIndex >= 0) {
+            return this.channelNameList[this.mod(currentIndex + 1, size)];
+        }
+        else {
+            return channel;
+        }
+    }
+
+    private mod(n: number, m: number) :number{
+        return ((n % m) + m) % m;
+    }
+
+    private previousChannel(channel: string):string {
+        const size = this.channelNameList.length;
+        const currentIndex = this.channelNameList.indexOf(channel);
+        if (currentIndex >= 0) {
+            return this.channelNameList[this.mod(currentIndex - 1, size)];
+        }
+        else {
+            return channel;
+        }
+    }
+
+    private cleanup(proc: ChildProcessWithoutNullStreams): Promise<void> {
+        proc.kill('SIGHUP');
+        return new Promise((resolve, reject) => {
+            proc.once('exit', () =>
+                resolve()
+            )
+            proc.on("error", (err: Error) =>
+                reject(err)
+            );
+        })
+    }
+
+    public async zapTo(channel: string, adapter: 0 | 1 = 0): Promise<IZap> {
+        let zap = adapter == 0 ? this.zap0 : this.zap1;
+        let verifiedChannel: string;
+        if (channel == '+') {
+            verifiedChannel = this.nextChannel(zap.channel);
+        }
+        else if (channel == '-') {
+            verifiedChannel = this.previousChannel(zap.channel);
+        }
+        else {
+            if (!this.channelNameList.includes(channel)) {
+                return Promise.reject(new Error("Invalid Channel name"));
+            }
+            else {
+                verifiedChannel = channel;
+            }
+        }
+        const cmd = 'dvbv5-zap'
+        const args: string[] = ["-r", "-C", "US", "-I", "ZAP", "-c", this.fileName, "-a", adapter.toString(), verifiedChannel];
+        if (zap.process != null) {
+            await this.cleanup(zap.process).catch(err => Promise.reject(err));
+
+        }
+        zap.process = spawn(cmd, args);
+        return new Promise((resolve, reject) => {
+            let lockTimer: NodeJS.Timeout;
+
+
+            zap.process.stderr.on("data", (data) => {
+                const output = data.toString();
+
+                if (/Lock/.test(output)) {
+                    clearTimeout(lockTimer);
+                    const match = output.match(this.regex);
+                    zap.channel = verifiedChannel;
+                    zap.strength = {
+                        signal: match[1],
+                        cn: match[3]
+                    }
+                    resolve(zap);
+                }
+
+                if (/Not locked/.test(output)) {
+                    clearTimeout(lockTimer);
+                    zap.process.kill("SIGHUP");
+                }
+            });
+
+            zap.process.on("exit", (code) => {
+                reject(new Error("Unexpected exit of Zap"));
+            });
+
+            lockTimer = setTimeout(() => {
+                reject(new Error("Failed to Zap in time"));
+            }, 5000);
+        })
+
+    }
+} 

tsconfig.json

@@ -0,0 +1,116 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+    /* Language and Environment */
+    "target": "ES2020", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "lib": [
+      "esnext",
+      "ES2020",
+      "DOM"
+    ], /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    "noLib": false, /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+    /* Modules */
+    "module": "commonjs", /* Specify what module code is generated. */
+    "rootDir": "src",                                  /* Specify the root folder within your source files. */
+    "moduleResolution": "node10", /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "types": ["node", "webrtc"],
+    // "typeRoots": ["./node_modules/@types"],
+    // "typeRoots": ["./node_modules/@types/webrtc"],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "rewriteRelativeImportExtensions": true,          /* Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "noUncheckedSideEffectImports": true,             /* Check side effect imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "dist",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    "noEmitOnError": false, /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
+    "allowSyntheticDefaultImports": true, /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true, /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true, /* Ensure that casing is correct in imports. */
+    /* Type Checking */
+    "strict": false, /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "strictBuiltinIteratorReturn": true,              /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+    /* Completeness */
+    "skipDefaultLibCheck": true, /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true /* Skip type checking all .d.ts files. */
+  },
+  "include": ["src"],
+  "exclude": [
+    "node_modules","./node_modules/@roamhq/wrtc"
+  ]
+  //   "include": [
+  //  "./src", "./types"
+  //   ]
+}