@tak-ps/node-tak 8.2.1 → 8.4.0

package/dist/lib/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","sourceRoot":"","sources":["../../lib/stream.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,CAAC,KAAK,UAAU,aAAa,CAAC,MAAc;IACtD,OAAO,IAAI,OAAO,CAAS,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QAC3C,MAAM,IAAI,GAAG,KAAK,EAAU,CAAC;QAC7B,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAC7C,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACrD,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAU,EAAE,EAAE,CAAC,MAAM,CAAC,6BAA6B,GAAG,EAAE,CAAC,CAAC,CAAC;IACnF,CAAC,CAAC,CAAC;AACP,CAAC"}

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../index.ts","../test/default.test.ts","../test/findCoT.test.ts"],"version":"5.8.2"}
+{"root":["../index.ts","../test/default.test.ts","../test/findCoT.test.ts","../lib/api.ts","../lib/auth.ts","../lib/fetch.ts","../lib/stream.ts","../lib/api/contacts.ts","../lib/api/credentials.ts","../lib/api/export.ts","../lib/api/files.ts","../lib/api/groups.ts","../lib/api/mission-layer.ts","../lib/api/mission-log.ts","../lib/api/mission.ts","../lib/api/oauth.ts","../lib/api/package.ts","../lib/api/query.ts","../lib/api/subscriptions.ts","../lib/api/types.ts","../lib/api/video.ts"],"version":"5.8.3"}

package/index.ts

@@ -3,6 +3,9 @@ import tls from 'node:tls';
 import CoT from '@tak-ps/node-cot';
 import type { TLSSocket } from 'node:tls'
 
+export * from './lib/api.js';
+export * from './lib/auth.js';
+
 /* eslint-disable no-control-regex */
 export const REGEX_CONTROL = /[\u000B-\u001F\u007F-\u009F]/g;
 
@@ -127,12 +130,12 @@ export default class TAK extends EventEmitter {
                     result = TAK.findCoT(buff);
                 }
             }).on('timeout', () => {
-                if (!this.destroyed) this.emit('timeout');
+                this.emit('timeout');
             }).on('error', (err: Error) => {
                 this.emit('error', err);
             }).on('end', () => {
                 this.open = false;
-                if (!this.destroyed) this.emit('end');
+                this.emit('end');
             });
 
             this.pingInterval = setInterval(() => {
@@ -234,4 +237,6 @@ export default class TAK extends EventEmitter {
     }
 }
 
-export { CoT }
+export {
+    CoT,
+}

package/lib/api/contacts.ts

@@ -0,0 +1,27 @@
+import TAKAPI from '../api.js';
+import { Type, Static } from '@sinclair/typebox';
+
+export const Contact = Type.Object({
+    filterGroups: Type.Any(), // I'm not familiar with this one
+    notes: Type.String(),
+    callsign: Type.String(),
+    team: Type.String(),
+    role: Type.String(),
+    takv: Type.String(),
+    uid: Type.String()
+});
+
+export default class {
+    api: TAKAPI;
+
+    constructor(api: TAKAPI) {
+        this.api = api;
+    }
+
+    async list(): Promise<Array<Static<typeof Contact>>> {
+        const url = new URL(`/Marti/api/contacts/all`, this.api.url);
+        return await this.api.fetch(url, {
+            method: 'GET'
+        });
+    }
+}

package/lib/api/credentials.ts

@@ -0,0 +1,74 @@
+import TAKAPI from '../api.js';
+import { APIAuthPassword } from '../auth.js';
+import { Static, Type } from '@sinclair/typebox';
+import pem from 'pem';
+import xml2js from 'xml2js';
+
+export const CertificateResponse = Type.Object({
+    cert: Type.String(),
+    key: Type.String()
+});
+
+export default class {
+    api: TAKAPI;
+
+    constructor(api: TAKAPI) {
+        this.api = api;
+    }
+
+    async config() {
+        const url = new URL(`/Marti/api/tls/config`, this.api.url);
+        return await this.api.fetch(url, {
+            method: 'GET'
+        });
+    }
+
+    async generate(): Promise<Static<typeof CertificateResponse>> {
+        if (!(this.api.auth instanceof APIAuthPassword)) throw new Error('Must use Password Auth');
+
+        const config = await xml2js.parseStringPromise(await this.config());
+
+        let organization = null;
+        let organizationUnit = null;
+        for (const nameEntry of config['ns2:certificateConfig'].nameEntries) {
+            for (const ne of nameEntry.nameEntry) {
+                if (ne['$'].name === 'O') organization = ne['$'].value;
+                if (ne['$'].name === 'OU') organizationUnit = ne['$'].value;
+            }
+        }
+
+        const createCSR = pem.promisified.createCSR;
+
+        const keys: {
+            csr: string,
+            clientKey: string
+        } = await createCSR({
+            organization,
+            organizationUnit,
+            commonName: this.api.auth.username
+        });
+
+        const url = new URL(`/Marti/api/tls/signClient/v2`, this.api.url);
+        url.searchParams.append('clientUid', this.api.auth.username + ' (ETL)');
+        url.searchParams.append('version', '3');
+
+        const res = await this.api.fetch(url, {
+            method: 'POST',
+            nocookies: true,
+            headers: {
+                Accept: 'application/json',
+                Authorization: 'Basic ' + btoa(this.api.auth.username + ":" + this.api.auth.password)
+            },
+            body: keys.csr
+        });
+
+        let cert = '-----BEGIN CERTIFICATE-----\n' + res.signedCert;
+        if (!res.signedCert.endsWith('\n')) cert = cert + '\n';
+        cert = cert + '-----END CERTIFICATE-----';
+
+        return {
+            cert,
+            key: keys.clientKey
+        }
+    }
+}

package/lib/api/export.ts

@@ -0,0 +1,44 @@
+import TAKAPI from '../api.js';
+import { Type, Static } from '@sinclair/typebox';
+import { Readable } from 'node:stream';
+
+export const ExportInput = Type.Object({
+    startTime: Type.String(),
+    endTime: Type.String(),
+    groups: Type.Array(Type.String()),
+    format: Type.String({ enum: ['kmz', 'kml'] }),
+    interval: Type.Optional(Type.Number()),
+    multiTrackThreshold: Type.Optional(Type.String()),
+    extendedData: Type.Optional(Type.Boolean()),
+    optimizeExport: Type.Optional(Type.Boolean()),
+});
+
+/**
+ * @class
+ */
+export default class {
+    api: TAKAPI;
+
+    constructor(api: TAKAPI) {
+        this.api = api;
+    }
+
+    async export(query: Static<typeof ExportInput>): Promise<Readable> {
+        const url = new URL(`/Marti/ExportMissionKML`, this.api.url);
+
+        const params = new URLSearchParams();
+        let q: keyof Static<typeof ExportInput>;
+        for (q in query) {
+            if (query[q] !== undefined ) {
+                params.append(q, String(query[q]));
+            }
+        }
+
+        const res = await this.api.fetch(url, {
+            method: 'POST',
+            body: params
+        }, true);
+
+        return res.body;
+    }
+}

package/lib/api/files.ts

@@ -0,0 +1,151 @@
+import TAKAPI from '../api.js';
+import FormData from 'form-data';
+import { Readable } from 'node:stream';
+import mime from 'mime';
+import { Type, Static } from '@sinclair/typebox';
+
+export const Content = Type.Object({
+  UID: Type.String(),
+  SubmissionDateTime: Type.String(),
+  Keywords: Type.Array(Type.String()),
+  MIMEType: Type.String(),
+  SubmissionUser: Type.String(),
+  PrimaryKey: Type.String(),
+  Hash: Type.String(),
+  CreatorUid: Type.String(),
+  Name: Type.String()
+});
+
+export const Config = Type.Object({
+    uploadSizeLimit: Type.Integer()
+})
+
+export default class File {
+    api: TAKAPI;
+
+    constructor(api: TAKAPI) {
+        this.api = api;
+    }
+
+    // TODO Investigate this endpoint
+    list() {
+        new URL(`/Marti/api/sync/search`, this.api.url);
+        // param hash=<hash>
+    } 
+
+    async meta(hash: string): Promise<string> {
+        const url = new URL(`/Marti/sync/${encodeURIComponent(hash)}/metadata`, this.api.url);
+
+        const res = await this.api.fetch(url, {
+            method: 'GET'
+        }, true);
+
+        const body = await res.text();
+
+        return body;
+    }
+
+    async download(hash: string): Promise<Readable> {
+        const url = new URL(`/Marti/sync/content`, this.api.url);
+        url.searchParams.append('hash', hash);
+
+        const res = await this.api.fetch(url, {
+            method: 'GET'
+        }, true);
+
+        return res.body;
+    }
+
+    async adminDelete(hash: string) {
+        const url = new URL(`/Marti/api/files/${hash}`, this.api.url);
+
+        return await this.api.fetch(url, {
+            method: 'DELETE',
+        });
+    }
+
+    async delete(hash: string) {
+        const url = new URL(`/Marti/sync/delete`, this.api.url);
+        url.searchParams.append('hash', hash)
+
+        return await this.api.fetch(url, {
+            method: 'DELETE',
+        });
+    }
+
+    // TODO Return a Content Object
+    async uploadPackage(opts: {
+        name: string;
+        creatorUid: string;
+        hash: string;
+    }, body: Readable | Buffer): Promise<string> {
+        const url = new URL(`/Marti/sync/missionupload`, this.api.url);
+        url.searchParams.append('filename', opts.name)
+        url.searchParams.append('creatorUid', opts.creatorUid)
+        url.searchParams.append('hash', opts.hash)
+
+        if (body instanceof Buffer) {
+            body = Readable.from(body as Buffer);
+        }
+
+        const form = new FormData()
+        form.append('assetfile', body as Readable);
+
+        const res = await this.api.fetch(url, {
+            method: 'POST',
+            body: form
+        }) as string;
+
+        return res;
+    }
+
+    async upload(opts: {
+        name: string;
+        contentLength: number;
+        contentType?: string;
+        keywords: string[];
+        creatorUid: string;
+        latitude?: string;
+        longitude?: string;
+        altitude?: string;
+    }, body: Readable | Buffer): Promise<Static<typeof Content>> {
+        const url = new URL(`/Marti/sync/upload`, this.api.url);
+        url.searchParams.append('name', opts.name)
+        url.searchParams.append('keywords', opts.keywords.join(','))
+        url.searchParams.append('creatorUid', opts.creatorUid)
+        if (opts.altitude) url.searchParams.append('altitude', opts.altitude);
+        if (opts.longitude) url.searchParams.append('longitude', opts.longitude);
+        if (opts.latitude) url.searchParams.append('latitude', opts.latitude);
+
+        if (body instanceof Buffer) {
+            body = Readable.from(body as Buffer);
+        }
+
+        const res = await this.api.fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': opts.contentType ? opts.contentType : mime.getType(opts.name),
+                'Content-Length': opts.contentLength
+            },
+            body: body as Readable
+        });
+
+        return JSON.parse(res);
+    }
+
+    async count() {
+        const url = new URL('/Marti/api/files/metadata/count', this.api.url);
+
+        return await this.api.fetch(url, {
+            method: 'GET'
+        });
+    }
+
+    async config(): Promise<Static<typeof Config>> {
+        const url = new URL('/files/api/config', this.api.url);
+
+        return await this.api.fetch(url, {
+            method: 'GET'
+        });
+    }
+}

package/lib/api/groups.ts

@@ -0,0 +1,63 @@
+import { Static, Type } from '@sinclair/typebox';
+import TAKAPI from '../api.js';
+import { TAKList } from './types.js';
+
+export const Group = Type.Object({
+    name: Type.String(),
+    direction: Type.String(),
+    created: Type.String(),
+    type: Type.String(),
+    bitpos: Type.Number(),
+    active: Type.Boolean(),
+    description: Type.Optional(Type.String())
+})
+
+export const GroupListInput = Type.Object({
+    useCache: Type.Optional(Type.Boolean())
+})
+
+export const TAKList_Group = TAKList(Group);
+
+export default class {
+    api: TAKAPI;
+
+    constructor(api: TAKAPI) {
+        this.api = api;
+    }
+
+    async list(
+        query: Static<typeof GroupListInput> = {}
+    ): Promise<Static<typeof TAKList_Group>> {
+        const url = new URL(`/Marti/api/groups/all`, this.api.url);
+
+        let q: keyof Static<typeof GroupListInput>;
+        for (q in query) {
+            if (query[q] !== undefined) {
+                url.searchParams.append(q, String(query[q]));
+            }
+        }
+
+        return await this.api.fetch(url, {
+            method: 'GET'
+        });
+    }
+
+    async update(
+        body: Static<typeof Group>[],
+        query: Static<typeof GroupListInput> = {}
+    ): Promise<void> {
+        const url = new URL(`/Marti/api/groups/active`, this.api.url);
+
+        let q: keyof Static<typeof GroupListInput>;
+        for (q in query) {
+            if (query[q] !== undefined) {
+                url.searchParams.append(q, String(query[q]));
+            }
+        }
+
+        await this.api.fetch(url, {
+            method: 'PUT',
+            body
+        });
+    }
+}