@tak-ps/node-tak 8.9.0 → 9.0.0

package/lib/api/mission-log.ts

@@ -1,7 +1,7 @@
-import TAKAPI from '../api.js';
 import { Type, Static } from '@sinclair/typebox';
 import { TAKItem } from './types.js';
 import type { MissionOptions } from './mission.js';
+import Commands from '../commands.js';
 import { GUIDMatch } from './mission.js';
 
 export const MissionLog = Type.Object({
@@ -29,11 +29,11 @@ export const UpdateMissionLog = Type.Composite([ CreateMissionLog, Type.Object({
 
 export const TAKItem_MissionLog = TAKItem(MissionLog);
 
-export default class {
-    api: TAKAPI;
+export default class MissionLogCommands extends Commands {
+    schema = {}
 
-    constructor(api: TAKAPI) {
-        this.api = api;
+    async cli(): Promise<object | string> {
+        throw new Error('Unsupported Subcommand');
     }
 
     #headers(opts?: Static<typeof MissionOptions>): object {

package/lib/api/mission.ts

@@ -1,5 +1,5 @@
 import xmljs from 'xml-js';
-import TAKAPI from '../api.js';
+import type { ParsedArgs } from 'minimist'
 import CoT from '@tak-ps/node-cot';
 import { Type, Static } from '@sinclair/typebox';
 import Err from '@openaddresses/batch-error';
@@ -7,6 +7,7 @@ import { Readable } from 'node:stream'
 import { TAKItem, TAKList } from './types.js';
 import { MissionLog } from './mission-log.js';
 import type { Feature } from '@tak-ps/node-cot';
+import Commands from '../commands.js';
 
 export enum MissionSubscriberRole {
     MISSION_OWNER = 'MISSION_OWNER',
@@ -192,11 +193,29 @@ export const TAKItem_MissionSubscriber = TAKItem(MissionSubscriber);
 /**
  * @class
  */
-export default class {
-    api: TAKAPI;
+export default class MissionCommands extends Commands {
+    schema = {
+        list: {
+            description: 'List Missions',
+            params: Type.Object({}),
+            query: Type.Object({})
+        }
+    }
+
+    async cli(args: ParsedArgs): Promise<object | string> {
+        if (args._[3] === 'list') {
+            const list = await this.list({});
 
-    constructor(api: TAKAPI) {
-        this.api = api;
+            if (args.format === 'json') {
+                return list;
+            } else {
+                return list.data.map((mission) => {
+                    return `${mission.name} - ${mission.description}`;
+                }).join('\n');
+            }
+        } else {
+            throw new Error('Unsupported Subcommand');
+        }
     }
 
     #isGUID(id: string): boolean {

package/lib/api/oauth.ts

@@ -1,6 +1,6 @@
 import Err from '@openaddresses/batch-error';
-import TAKAPI from '../api.js';
 import { Type, Static } from '@sinclair/typebox';
+import Commands from '../commands.js';
 
 export const LoginInput = Type.Object({
     username: Type.String(),
@@ -15,11 +15,11 @@ export const TokenContents = Type.Object({
     iat: Type.Number()
 })
 
-export default class {
-    api: TAKAPI;
+export default class OAuthCommands extends Commands {
+    schema = {}
 
-    constructor(api: TAKAPI) {
-        this.api = api;
+    async cli(): Promise<object | string> {
+        throw new Error('Unsupported Subcommand');
     }
 
     parse(jwt: string): Static<typeof TokenContents>{

package/lib/api/package.ts

@@ -1,5 +1,6 @@
-import TAKAPI from '../api.js';
 import { Type, Static } from '@sinclair/typebox';
+import type { ParsedArgs } from 'minimist'
+import Commands from '../commands.js';
 
 export const Package = Type.Object({
     EXPIRATION: Type.String(),
@@ -24,11 +25,29 @@ export const ListInput = Type.Object({
 /**
  * @class
  */
-export default class {
-    api: TAKAPI;
+export default class PackageCommands extends Commands {
+    schema = {
+        list: {
+            description: 'List Data Packages',
+            params: Type.Object({}),
+            query: Type.Object({})
+        }
+    }
+
+    async cli(args: ParsedArgs): Promise<object | string> {
+        if (args._[3] === 'list') {
+            const list = await this.list({});
 
-    constructor(api: TAKAPI) {
-        this.api = api;
+            if (args.format === 'json') {
+                return list;
+            } else {
+                return list.results.map((data) => {
+                    return data.Name;
+                }).join('\n');
+            }
+        } else {
+            throw new Error('Unsupported Subcommand');
+        }
     }
 
     async list(query: Static<typeof ListInput>): Promise<{

package/lib/api/query.ts

@@ -1,9 +1,9 @@
-import TAKAPI from '../api.js';
 import Err from '@openaddresses/batch-error';
 import xmljs from 'xml-js';
 import { Type, Static } from '@sinclair/typebox';
 import CoT from '@tak-ps/node-cot';
 import type { Feature } from '@tak-ps/node-cot';
+import Commands from '../commands.js';
 
 export const HistoryOptions = Type.Object({
     start: Type.Optional(Type.String()),
@@ -11,11 +11,11 @@ export const HistoryOptions = Type.Object({
     secago: Type.Optional(Type.String()),
 })
 
-export default class COTQuery {
-    api: TAKAPI;
+export default class QueryCommands extends Commands {
+    schema = {}
 
-    constructor(api: TAKAPI) {
-        this.api = api;
+    async cli(): Promise<object | string> {
+        throw new Error('Unsupported Subcommand');
     }
 
     async singleFeat(uid: string): Promise<Static<typeof Feature.Feature>> {

package/lib/api/repeater.ts

@@ -1,6 +1,6 @@
-import TAKAPI from '../api.js';
 import { TAKList } from './types.js';
 import { Type, Static } from '@sinclair/typebox';
+import Commands from '../commands.js';
 
 export const Repeater = Type.Object({
     uid: Type.String(),
@@ -13,11 +13,11 @@ export const Repeater = Type.Object({
 
 export const TAKList_Repeater = TAKList(Repeater);
 
-export default class {
-    api: TAKAPI;
+export default class RepeaterCommands extends Commands {
+    schema = {}
 
-    constructor(api: TAKAPI) {
-        this.api = api;
+    async cli(): Promise<object | string> {
+        throw new Error('Unsupported Subcommand');
     }
 
     /**

package/lib/api/subscriptions.ts

@@ -1,7 +1,7 @@
-import TAKAPI from '../api.js';
 import { Type, Static } from '@sinclair/typebox';
 import { Group } from './groups.js';
 import { TAKList } from './types.js';
+import Commands from '../commands.js';
 
 export const Subscription = Type.Object({
     dn: Type.Union([Type.String(), Type.Null()]),
@@ -58,11 +58,11 @@ export const ListSubscriptionInput = Type.Object({
 export const TAKList_Subscription = TAKList(Subscription);
 
 
-export default class {
-    api: TAKAPI;
+export default class SubscriptionCommands extends Commands {
+    schema = {}
 
-    constructor(api: TAKAPI) {
-        this.api = api;
+    async cli(): Promise<object | string> {
+        throw new Error('Unsupported Subcommand');
     }
 
     async list(

package/lib/api/video.ts

@@ -1,7 +1,8 @@
 import Err from '@openaddresses/batch-error';
+import type { ParsedArgs } from 'minimist'
 import { Static, Type } from '@sinclair/typebox';
 import { randomUUID } from 'node:crypto';
-import TAKAPI from '../api.js';
+import Commands from '../commands.js';
 
 export const FeedInput = Type.Object({
     uuid: Type.Optional(Type.String()),
@@ -62,11 +63,21 @@ export const VideoConnectionListInput = Type.Object({
     protocol: Type.Optional(Type.String())
 })
 
-export default class {
-    api: TAKAPI;
+export default class VideoCommands extends Commands {
+    schema = {
+        list: {
+            description: 'List V2 Video Configs',
+            params: Type.Object({}),
+            query: Type.Object({})
+        }
+    }
 
-    constructor(api: TAKAPI) {
-        this.api = api;
+    async cli(args: ParsedArgs): Promise<object | string> {
+        if (args._[3] === 'list') {
+            return await this.list()
+        } else {
+            throw new Error('Unsupported Subcommand');
+        }
     }
 
     async list(

package/lib/api.ts

@@ -17,6 +17,24 @@ import Export from './api/export.js';
 import Err from '@openaddresses/batch-error';
 import * as auth from './auth.js';
 
+export const CommandList: Record<string, keyof TAKAPI> = {
+    package: 'Package',
+    oauth: 'OAuth',
+    mission: 'Mission',
+    'mission-log': 'MissionLog',
+    'mission-layer': 'MissionLayer',
+    credential: 'Credentials',
+    contact: 'Contacts',
+    subscription: 'Subscription',
+    injector: 'Injectors',
+    repeater: 'Repeater',
+    group: 'Group',
+    video: 'Video',
+    export: 'Export',
+    query: 'Query',
+    file: 'Files'
+}
+
 /**
  * Handle TAK HTTP API Operations
  * @class

package/lib/auth.ts

@@ -1,10 +1,22 @@
 import fetch from './fetch.js';
+import { Type } from '@sinclair/typebox';
 import { CookieJar, Cookie } from 'tough-cookie';
 import { CookieAgent } from 'http-cookie-agent/undici';
 import { Client } from 'undici';
 import TAKAPI from './api.js';
 import stream2buffer  from './stream.js';
 
+/**
+ * Store the TAK Client Certificate for a connection
+ */
+export const TAKAuth = Type.Object({
+    cert: Type.String(),
+    key: Type.String(),
+    passphrase: Type.Optional(Type.String()),
+    ca: Type.Optional(Type.String()),
+    rejectUnauthorized: Type.Optional(Type.Boolean())
+})
+
 export class APIAuth {
     async init(api: TAKAPI) { // eslint-disable-line @typescript-eslint/no-unused-vars
 

package/lib/commands.ts

@@ -0,0 +1,41 @@
+import { TAKAuth } from './auth.js';
+import type { ParsedArgs } from 'minimist';
+import TAKAPI from './api.js';
+import type { TObject } from '@sinclair/typebox';
+import { Type } from '@sinclair/typebox';
+
+export const CommandConfig = Type.Object({
+    version: Type.Integer(),
+    profiles: Type.Record(
+        Type.String(),
+        Type.Object({
+            host: Type.String(),
+            ports: Type.Object({
+                marti: Type.Integer(),
+                webtak: Type.Integer(),
+                stream: Type.Integer()
+            }),
+            auth: Type.Optional(TAKAuth)
+        })
+    )
+})
+
+
+export default class Commands {
+    api: TAKAPI;
+
+    schema: Record<string, {
+        description: string,
+        params: TObject<any>,
+        query: TObject<any>,
+    }> = {};
+
+    constructor(api: TAKAPI) {
+        this.api = api;
+    }
+
+    async cli(args: ParsedArgs): Promise<object | string> {
+        if (!args) throw new Error('Args object must be provided');
+        throw new Error('Command not yet supported');
+    }
+}

package/package.json

@@ -1,11 +1,14 @@
 {
     "name": "@tak-ps/node-tak",
     "type": "module",
-    "version": "8.9.0",
+    "version": "9.0.0",
     "description": "Lightweight JavaScript library for communicating with TAK Server",
     "author": "Nick Ingalls <nick@ingalls.ca>",
     "main": "dist/index.js",
     "types": "index.ts",
+    "bin": {
+        "tak": "tsx ./cli.ts"
+    },
     "exports": {
         ".": "./dist/index.js",
         "./lib/*": "./dist/lib/*.js",
@@ -35,12 +38,15 @@
         "@tak-ps/node-cot": "^12.0.0"
     },
     "devDependencies": {
+        "@inquirer/prompts": "^7.5.1",
+        "@types/minimist": "^1.2.5",
         "@types/node": "^22.0.0",
         "@types/pem": "^1.14.4",
         "@types/tape": "^5.6.0",
         "@types/xml2js": "^0.4.14",
         "c8": "^10.1.3",
         "eslint": "^9.0.0",
+        "minimist": "^1.2.8",
         "tape": "^5.6.1",
         "ts-node": "^10.9.1",
         "ts-node-test": "^0.4.0",

package/tsconfig.json

@@ -22,6 +22,7 @@
         }
     },
     "include": [
+        "cli.ts",
         "index.ts", 
         "test/**/*",
         "lib/**/*",