addigy 2.8.2 → 2.10.0

package/lib/addigy.constants.d.ts

@@ -0,0 +1,6 @@
+export declare enum Urls {
+    app = "https://app.addigy.com",
+    appProd = "https://app-prod.addigy.com",
+    api = "https://prod.addigy.com",
+    fileManager = "https://file-manager-prod.addigy.com"
+}

package/lib/addigy.constants.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Urls = void 0;
+var Urls;
+(function (Urls) {
+    Urls["app"] = "https://app.addigy.com";
+    Urls["appProd"] = "https://app-prod.addigy.com";
+    Urls["api"] = "https://prod.addigy.com";
+    Urls["fileManager"] = "https://file-manager-prod.addigy.com";
+})(Urls || (exports.Urls = Urls = {}));

package/lib/addigy.d.ts

@@ -0,0 +1,44 @@
+import { IAddigyConfig } from './types';
+import { Alerts } from './alerts/alerts';
+import { Applications } from './applications/applications';
+import { Billing } from './billing/billing';
+import { Certs } from './certs/certs';
+import { Commands } from './commands/commands';
+import { MdmConfigurations } from './mdm/mdm-configurations';
+import { Devices } from './devices/devices';
+import { Facts } from './facts/facts';
+import { Files } from './files/files';
+import { Integrations } from './integrations/integrations';
+import { Maintenance } from './maintenance/maintenance';
+import { Policies } from './policies/policies';
+import { Profiles } from './profiles/profiles';
+import { ScreenConnect } from './screenconnect/screenconnect';
+import { Software } from './software/software';
+import { Users } from './users/users';
+import { Auth } from './auth/auth';
+import { MdmPolicies } from './mdm/mdm-policies';
+import { MdmProfiles } from './mdm/mdm-profiles';
+export declare class Addigy {
+    private readonly config;
+    auth: Auth;
+    alerts: Alerts;
+    apps: Applications;
+    billing: Billing;
+    certs: Certs;
+    commands: Commands;
+    devices: Devices;
+    facts: Facts;
+    files: Files;
+    integrations: Integrations;
+    maintenance: Maintenance;
+    mdmConfigurations: MdmConfigurations;
+    mdmPolicies: MdmPolicies;
+    mdmProfiles: MdmProfiles;
+    policies: Policies;
+    profiles: Profiles;
+    screenconnect: ScreenConnect;
+    software: Software;
+    users: Users;
+    private readonly http;
+    constructor(config: IAddigyConfig);
+}

package/lib/addigy.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Addigy = void 0;
+const alerts_1 = require("./alerts/alerts");
+const applications_1 = require("./applications/applications");
+const billing_1 = require("./billing/billing");
+const certs_1 = require("./certs/certs");
+const commands_1 = require("./commands/commands");
+const mdm_configurations_1 = require("./mdm/mdm-configurations");
+const devices_1 = require("./devices/devices");
+const facts_1 = require("./facts/facts");
+const files_1 = require("./files/files");
+const integrations_1 = require("./integrations/integrations");
+const maintenance_1 = require("./maintenance/maintenance");
+const policies_1 = require("./policies/policies");
+const profiles_1 = require("./profiles/profiles");
+const screenconnect_1 = require("./screenconnect/screenconnect");
+const software_1 = require("./software/software");
+const users_1 = require("./users/users");
+const axios_1 = __importDefault(require("axios"));
+const auth_1 = require("./auth/auth");
+const addigy_constants_1 = require("./addigy.constants");
+const mdm_policies_1 = require("./mdm/mdm-policies");
+const addigy_utils_1 = require("./addigy.utils");
+const mdm_profiles_1 = require("./mdm/mdm-profiles");
+class Addigy {
+    constructor(config) {
+        this.config = config;
+        this.http = axios_1.default.create({
+            baseURL: `${addigy_constants_1.Urls.api}/api`,
+            ...(0, addigy_utils_1.getAxiosHttpAgents)(),
+            headers: {
+                'content-type': 'application/json',
+                accept: 'application/json',
+                'client-id': this.config.clientId,
+                'client-secret': this.config.clientSecret,
+            },
+        });
+        this.auth = new auth_1.Auth(config);
+        this.alerts = new alerts_1.Alerts(this.http);
+        this.apps = new applications_1.Applications(this.http);
+        this.billing = new billing_1.Billing();
+        this.certs = new certs_1.Certs();
+        this.commands = new commands_1.Commands(this.http);
+        this.devices = new devices_1.Devices(this.http, this.config);
+        this.facts = new facts_1.Facts();
+        this.files = new files_1.Files(this.config);
+        this.integrations = new integrations_1.Integrations();
+        this.maintenance = new maintenance_1.Maintenance(this.http);
+        this.mdmConfigurations = new mdm_configurations_1.MdmConfigurations();
+        this.mdmPolicies = new mdm_policies_1.MdmPolicies();
+        this.mdmProfiles = new mdm_profiles_1.MdmProfiles();
+        this.policies = new policies_1.Policies(this.http);
+        this.profiles = new profiles_1.Profiles(this.http);
+        this.screenconnect = new screenconnect_1.ScreenConnect();
+        this.software = new software_1.Software(this.http);
+        this.users = new users_1.Users();
+    }
+}
+exports.Addigy = Addigy;

package/lib/addigy.utils.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export declare function getAxiosHttpAgents(): {
+    httpAgent: import("http").Agent;
+    httpsAgent: import("https").Agent;
+};

package/lib/addigy.utils.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAxiosHttpAgents = void 0;
+const http_1 = require("http-cookie-agent/http");
+const tough_cookie_1 = require("tough-cookie");
+function getAxiosHttpAgents() {
+    return {
+        httpAgent: new http_1.HttpCookieAgent({ cookies: { jar: new tough_cookie_1.CookieJar() } }),
+        httpsAgent: new http_1.HttpsCookieAgent({ cookies: { jar: new tough_cookie_1.CookieJar() } }),
+    };
+}
+exports.getAxiosHttpAgents = getAxiosHttpAgents;

package/lib/alerts/alert.types.d.ts

@@ -0,0 +1,5 @@
+export declare enum AlertStatus {
+    Acknowledged = "Acknowledged",
+    Resolved = "Resolved",
+    Unattended = "Unattended"
+}

package/lib/alerts/alert.types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertStatus = void 0;
+var AlertStatus;
+(function (AlertStatus) {
+    AlertStatus["Acknowledged"] = "Acknowledged";
+    AlertStatus["Resolved"] = "Resolved";
+    AlertStatus["Unattended"] = "Unattended";
+})(AlertStatus || (exports.AlertStatus = AlertStatus = {}));

package/lib/alerts/alerts.d.ts

@@ -0,0 +1,7 @@
+import { AlertStatus } from './alert.types';
+import { AxiosInstance } from 'axios';
+export declare class Alerts {
+    private readonly http;
+    constructor(http: AxiosInstance);
+    getAlerts(status: AlertStatus, page?: number, pageLength?: number): Promise<object[]>;
+}

package/lib/alerts/alerts.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Alerts = void 0;
+class Alerts {
+    constructor(http) {
+        this.http = http;
+    }
+    async getAlerts(status, page = 1, pageLength = 10) {
+        let statusUri = '';
+        if (status) {
+            statusUri = `&status=${status}`;
+        }
+        try {
+            let res = await this.http.get(`alerts?page=${page}&per_page=${pageLength}` + statusUri);
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+}
+exports.Alerts = Alerts;

package/lib/applications/applications.d.ts

@@ -0,0 +1,6 @@
+import { AxiosInstance } from 'axios';
+export declare class Applications {
+    private readonly http;
+    constructor(http: AxiosInstance);
+    getInstalledApplications(): Promise<object[]>;
+}

package/lib/applications/applications.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Applications = void 0;
+class Applications {
+    constructor(http) {
+        this.http = http;
+    }
+    async getInstalledApplications() {
+        try {
+            let res = await this.http.get('applications');
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+}
+exports.Applications = Applications;

package/lib/auth/auth.d.ts

@@ -0,0 +1,9 @@
+import { IAddigyConfig } from '../types';
+import { IAddigyInternalAuthObject } from './auth.types';
+export declare class Auth {
+    private readonly config;
+    private readonly http;
+    constructor(config: IAddigyConfig);
+    getAuthObject(): Promise<IAddigyInternalAuthObject>;
+    getImpersonationAuthObject(authObject: IAddigyInternalAuthObject, orgId: string): Promise<IAddigyInternalAuthObject>;
+}

package/lib/auth/auth.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth = void 0;
+const axios_1 = __importDefault(require("axios"));
+const addigy_constants_1 = require("../addigy.constants");
+const addigy_utils_1 = require("../addigy.utils");
+class Auth {
+    constructor(config) {
+        this.config = config;
+        this.http = axios_1.default.create({
+            baseURL: addigy_constants_1.Urls.api,
+            ...(0, addigy_utils_1.getAxiosHttpAgents)(),
+        });
+    }
+    async getAuthObject() {
+        let postBody = {
+            username: this.config.adminUsername,
+            password: this.config.adminPassword,
+        };
+        try {
+            if (!this.config.adminUsername || !this.config.adminPassword)
+                throw new Error("The function you are using hits Addigy's internal API, but no username or " +
+                    'password was provided in the constructor. Please fill out the adminUsername and ' +
+                    'adminPassword parameters.');
+            let res = await this.http.post('signin', postBody);
+            return {
+                orgId: res.data.orgid,
+                authToken: res.data.authtoken,
+                emailAddress: res.data.email,
+            };
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    async getImpersonationAuthObject(authObject, orgId) {
+        let postBody = {
+            parent_orgid: authObject.orgId,
+            child_orgid: orgId,
+            user_email: authObject.emailAddress,
+        };
+        try {
+            let res = await this.http.post('api/impersonation', postBody, {
+                headers: {
+                    Cookie: `prod_auth_token=${authObject.authToken};`,
+                    origin: addigy_constants_1.Urls.app,
+                },
+            });
+            const cookies = res.headers['set-cookie'];
+            if (!(cookies && cookies.length))
+                throw new Error('No set-cookie found in response');
+            const cookie = cookies.find((e) => e.includes('prod_auth_token') && !e.includes('original_auth_token'));
+            if (!cookie)
+                throw new Error('No auth cookie found');
+            const tokenPart1 = cookie.split('auth_token=')[1];
+            if (!tokenPart1)
+                throw new Error('No token found in cookie');
+            const authToken = tokenPart1.split(';')[0];
+            if (!authToken)
+                throw new Error('No token found in cookie');
+            return {
+                orgId: orgId,
+                authToken,
+                emailAddress: authObject.emailAddress,
+            };
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+}
+exports.Auth = Auth;

package/lib/auth/auth.types.d.ts

@@ -0,0 +1,5 @@
+export interface IAddigyInternalAuthObject {
+    orgId: string;
+    authToken: string;
+    emailAddress: string;
+}

package/lib/billing/billing.d.ts

@@ -0,0 +1,5 @@
+import { IAddigyInternalAuthObject } from '../auth/auth.types';
+export declare class Billing {
+    private readonly http;
+    getBillingData(authObject: IAddigyInternalAuthObject): Promise<object[]>;
+}

package/lib/billing/billing.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Billing = void 0;
+const axios_1 = __importDefault(require("axios"));
+const addigy_constants_1 = require("../addigy.constants");
+const addigy_utils_1 = require("../addigy.utils");
+class Billing {
+    constructor() {
+        this.http = axios_1.default.create({
+            baseURL: `${addigy_constants_1.Urls.appProd}/api/billing`,
+            ...(0, addigy_utils_1.getAxiosHttpAgents)(),
+            headers: {
+                origin: addigy_constants_1.Urls.appProd,
+            },
+        });
+    }
+    async getBillingData(authObject) {
+        try {
+            let res = await this.http.get('get_chargeover_billing_data', {
+                headers: {
+                    Cookie: `auth_token=${authObject.authToken};`,
+                    email: authObject.emailAddress,
+                    orgid: authObject.orgId,
+                },
+            });
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+}
+exports.Billing = Billing;

package/lib/certs/certs.d.ts

@@ -0,0 +1,5 @@
+import { IAddigyInternalAuthObject } from '../auth/auth.types';
+export declare class Certs {
+    private readonly http;
+    getApnsCerts(authObject: IAddigyInternalAuthObject, next?: string, previous?: string): Promise<object[]>;
+}

package/lib/certs/certs.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Certs = void 0;
+const axios_1 = __importDefault(require("axios"));
+const addigy_constants_1 = require("../addigy.constants");
+const addigy_utils_1 = require("../addigy.utils");
+class Certs {
+    constructor() {
+        this.http = axios_1.default.create({
+            baseURL: `${addigy_constants_1.Urls.appProd}/api`,
+            ...(0, addigy_utils_1.getAxiosHttpAgents)(),
+            headers: {
+                origin: addigy_constants_1.Urls.appProd,
+            },
+        });
+    }
+    async getApnsCerts(authObject, next, previous) {
+        let url = 'apn/user/apn/list';
+        if (next) {
+            url = `${url}?next=${next}`;
+        }
+        if (previous) {
+            url = `${url}?previous=${previous}`;
+        }
+        try {
+            let res = await this.http.get(url, {
+                headers: {
+                    Cookie: `auth_token=${authObject.authToken};`,
+                    email: authObject.emailAddress,
+                    orgid: authObject.orgId,
+                },
+            });
+            return res.data.items;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+}
+exports.Certs = Certs;

package/lib/commands/commands.d.ts

@@ -0,0 +1,7 @@
+import { AxiosInstance } from 'axios';
+export declare class Commands {
+    private readonly http;
+    constructor(http: AxiosInstance);
+    runCommand(agentIds: string[], command: string): Promise<object[]>;
+    getCommandOutput(actionId: string, agentId: string): Promise<object[]>;
+}

package/lib/commands/commands.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Commands = void 0;
+class Commands {
+    constructor(http) {
+        this.http = http;
+    }
+    async runCommand(agentIds, command) {
+        let postBody = {
+            agent_ids: agentIds,
+            command: command,
+        };
+        try {
+            let res = await this.http.post(`devices/commands`, postBody);
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    async getCommandOutput(actionId, agentId) {
+        try {
+            let res = await this.http.get(`devices/output?action_id=${actionId}&agentid=${agentId}`);
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+}
+exports.Commands = Commands;

package/lib/devices/devices.d.ts

@@ -0,0 +1,11 @@
+import { AxiosInstance } from 'axios';
+import { IAddigyConfig } from '../types';
+export declare class Devices {
+    private readonly http;
+    private readonly config;
+    constructor(http: AxiosInstance, config: IAddigyConfig);
+    getOnlineDevices(): Promise<object[]>;
+    getDevices(): Promise<object[]>;
+    getPolicyDevices(policyId: string): Promise<object[]>;
+    updateDevicePolicy(policyId: string, agentId: string): Promise<object[]>;
+}

package/lib/devices/devices.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Devices = void 0;
+class Devices {
+    constructor(http, config) {
+        this.http = http;
+        this.config = config;
+    }
+    async getOnlineDevices() {
+        try {
+            let res = await this.http.get(`devices/online`);
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    async getDevices() {
+        try {
+            let res = await this.http.get(`devices`);
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    async getPolicyDevices(policyId) {
+        try {
+            let res = await this.http.get(`policies/devices?policy_id=${policyId}`);
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    async updateDevicePolicy(policyId, agentId) {
+        let postBody = {
+            policy_id: policyId,
+            agent_id: agentId,
+        };
+        try {
+            let res = await this.http.post(`policies/devices`, postBody, {
+                headers: {
+                    'client-id': this.config.clientId,
+                    'client-secret': this.config.clientSecret,
+                },
+            });
+            return res.data;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+}
+exports.Devices = Devices;

package/lib/facts/facts.d.ts

@@ -0,0 +1,8 @@
+import { IAddigyInternalAuthObject } from '../auth/auth.types';
+import { CustomFact } from './facts.types';
+export declare class Facts {
+    private readonly http;
+    createCustomFact(authObject: IAddigyInternalAuthObject, name: string, script: string, scriptType: 'bash' | 'python' | 'zsh'): Promise<CustomFact>;
+    getCustomFacts(authObject: IAddigyInternalAuthObject): Promise<CustomFact[]>;
+    getCustomFactByName(authObject: IAddigyInternalAuthObject, name: string): Promise<CustomFact | undefined>;
+}

package/lib/facts/facts.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Facts = void 0;
+const axios_1 = __importDefault(require("axios"));
+const addigy_constants_1 = require("../addigy.constants");
+const addigy_utils_1 = require("../addigy.utils");
+class Facts {
+    constructor() {
+        this.http = axios_1.default.create({
+            baseURL: `${addigy_constants_1.Urls.appProd}/api/services/facts`,
+            ...(0, addigy_utils_1.getAxiosHttpAgents)(),
+            headers: {
+                origin: addigy_constants_1.Urls.appProd,
+            },
+        });
+    }
+    async createCustomFact(authObject, name, script, scriptType) {
+        const shebang = {
+            bash: '#!/bin/bash',
+            python: '#!/usr/bin/python',
+            zsh: '#!/bin/zsh',
+        };
+        const body = {
+            name,
+            os_architectures: {
+                linux_arm: {
+                    is_supported: false,
+                    language: '',
+                    shebang: '',
+                    script: '',
+                },
+                darwin_amd64: {
+                    is_supported: true,
+                    language: scriptType,
+                    shebang: shebang[scriptType],
+                    script,
+                },
+            },
+            return_type: 'string',
+        };
+        const res = await this.http.post('custom', body, {
+            headers: {
+                Cookie: `auth_token=${authObject.authToken};`,
+            },
+        });
+        return res.data;
+    }
+    async getCustomFacts(authObject) {
+        var _a;
+        const res = await this.http.get('custom', {
+            headers: {
+                Cookie: `auth_token=${authObject.authToken};`,
+            },
+        });
+        const results = res.data;
+        return (_a = results.custom_facts) !== null && _a !== void 0 ? _a : [];
+    }
+    async getCustomFactByName(authObject, name) {
+        const facts = await this.getCustomFacts(authObject);
+        return facts.find((e) => e.name === name);
+    }
+}
+exports.Facts = Facts;

package/lib/facts/facts.types.d.ts

@@ -0,0 +1,22 @@
+export interface CustomFact {
+    organization_id: string;
+    name: string;
+    return_type: string;
+    identifier: string;
+    version: number;
+    os_architectures: CustomFactOSArchitectures;
+    notes: string;
+    provider: string;
+    source: string;
+}
+export interface CustomFactOSArchitectures {
+    linux_arm: CustomFactOSArchitecturesData;
+    darwin_amd64: CustomFactOSArchitecturesData;
+}
+export interface CustomFactOSArchitecturesData {
+    language: string;
+    is_supported: boolean;
+    shebang: string;
+    script: string;
+    md5_hash: string;
+}

package/lib/facts/facts.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/files/files.d.ts

@@ -0,0 +1,10 @@
+import { IAddigyConfig } from '../types';
+import { IAddigyInternalAuthObject } from '../auth/auth.types';
+export declare class Files {
+    private readonly config;
+    private readonly http;
+    constructor(config: IAddigyConfig);
+    getFileUploadUrl(fileName: string, contentType?: string): Promise<string>;
+    uploadFile(uploadUrl: string, file: object, contentType?: string): Promise<object[]>;
+    getFileVaultKeys(authObject: IAddigyInternalAuthObject): Promise<object[]>;
+}