@heroku/skynet 1.13.0 → 2.0.0

package/dist/commands/suspensions.js

@@ -0,0 +1,25 @@
+import SkynetAPI from '../lib/skynet.js';
+import { Command } from '@heroku-cli/command';
+import { Flags, ux } from '@oclif/core';
+export default class Suspensions extends Command {
+    static description = '(requires sudo) suspension history of the given user account';
+    static examples = [
+        '$ heroku skynet:suspensions -a [user account]'
+    ];
+    static flags = {
+        account: Flags.string({
+            name: 'account',
+            char: 'a',
+            description: 'user account email',
+            hasValue: true,
+            required: true
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(Suspensions);
+        const skynet = new SkynetAPI(this.heroku.auth);
+        let response = await skynet.suspensions(flags.account);
+        response = JSON.parse(response);
+        ux.log(response);
+    }
+}

package/dist/commands/unsuspend/apps.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@heroku-cli/command';
+export default class UnsuspendApp extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        category: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        notes: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/unsuspend/apps.js

@@ -0,0 +1,48 @@
+import SkynetAPI from '../../lib/skynet.js';
+import { Command } from '@heroku-cli/command';
+import { color } from '@heroku-cli/color';
+import { Flags, ux } from '@oclif/core';
+import { processUnsuspendResult } from '../../lib/utils.js';
+export default class UnsuspendApp extends Command {
+    static description = '(requires sudo) unsuspends an app';
+    static examples = [
+        '$ heroku skynet:unsuspend:app -a test-app -n "helpful unsuspend message" -c "unsuspend-apology"'
+    ];
+    static flags = {
+        app: Flags.string({
+            name: 'app',
+            char: 'a',
+            description: 'app to unsuspend',
+            hasValue: true,
+            required: true
+        }),
+        category: Flags.string({
+            name: 'category',
+            char: 'c',
+            description: 'unsuspension category',
+            hasValue: true,
+            required: true
+        }),
+        notes: Flags.string({
+            name: 'notes',
+            char: 'n',
+            description: 'unsuspend notes',
+            hasValue: true,
+            required: true
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(UnsuspendApp);
+        const skynet = new SkynetAPI(this.heroku.auth);
+        const app = flags.app;
+        const category = flags.category;
+        const notes = flags.notes;
+        if (!app) {
+            ux.error('Required flag: --app APP');
+        }
+        ux.action.start(`Unsuspending app ${color.cyan(app)}`);
+        let response = await skynet.unsuspendApp(app, category, notes);
+        response = JSON.parse(response);
+        processUnsuspendResult(app, response);
+    }
+}

package/dist/commands/unsuspend/user.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@heroku-cli/command';
+export default class UnsuspendUser extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        user: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        category: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        notes: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/unsuspend/user.js

@@ -0,0 +1,49 @@
+import SkynetAPI from '../../lib/skynet.js';
+import { requireSudo } from '../../lib/sudo.js';
+import { Command } from '@heroku-cli/command';
+import { color } from '@heroku-cli/color';
+import { Flags, ux } from '@oclif/core';
+import { processUnsuspendResult } from '../../lib/utils.js';
+export default class UnsuspendUser extends Command {
+    static description = '(requires sudo) unsuspends a user';
+    static examples = [
+        '$ heroku skynet:unsuspend:user -u foo@bar.com -n "helpful unsuspend message" -c "unsuspend-account-recovery"'
+    ];
+    static flags = {
+        user: Flags.string({
+            name: 'user',
+            char: 'u',
+            description: 'user to unsuspend',
+            hasValue: true
+        }),
+        category: Flags.string({
+            name: 'category',
+            char: 'c',
+            description: 'unsuspension category',
+            hasValue: true,
+            required: true
+        }),
+        notes: Flags.string({
+            name: 'notes',
+            char: 'n',
+            description: 'unsuspend notes',
+            hasValue: true,
+            required: true
+        })
+    };
+    async run() {
+        requireSudo();
+        const { flags } = await this.parse(UnsuspendUser);
+        const skynet = new SkynetAPI(this.heroku.auth);
+        const user = flags.user || process.env.HEROKU_USER;
+        const category = flags.category;
+        const notes = flags.notes;
+        if (!user) {
+            ux.error('Required flag: --user USER');
+        }
+        ux.action.start(`Unsuspending ${color.cyan(user)}`);
+        let response = await skynet.unsuspendUser(user, category, notes);
+        response = JSON.parse(response);
+        processUnsuspendResult(user, response);
+    }
+}

package/dist/commands/userpass/add.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@heroku-cli/command';
+export default class AddUserpass extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        user: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        flag: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/userpass/add.js

@@ -0,0 +1,33 @@
+import SkynetAPI from '../../lib/skynet.js';
+import { Command } from '@heroku-cli/command';
+import { color } from '@heroku-cli/color';
+import { Flags, ux } from '@oclif/core';
+export default class AddUserpass extends Command {
+    static description = 'adds a userpass flag to a given user';
+    static examples = [
+        '$ heroku skynet:userpass:add -u foo@bar.com -f cant-install-abused-addons'
+    ];
+    static flags = {
+        user: Flags.string({
+            name: 'user',
+            char: 'u',
+            description: 'user to apply userpass flag to',
+            hasValue: true,
+            required: true
+        }),
+        flag: Flags.string({
+            name: 'flag',
+            char: 'f',
+            description: 'flag to add to the given user',
+            hasValue: true,
+            required: true
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(AddUserpass);
+        const skynet = new SkynetAPI(this.heroku.auth);
+        ux.action.start(`adding ${color.cyan(flags.flag)} to ${color.cyan(flags.user)}`);
+        await skynet.addUserpass(flags.user, flags.flag);
+        ux.action.stop();
+    }
+}

package/dist/commands/userpass/remove.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@heroku-cli/command';
+export default class RemoveUserpass extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        user: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        flag: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/userpass/remove.js

@@ -0,0 +1,33 @@
+import SkynetAPI from '../../lib/skynet.js';
+import { Command } from '@heroku-cli/command';
+import { color } from '@heroku-cli/color';
+import { Flags, ux } from '@oclif/core';
+export default class RemoveUserpass extends Command {
+    static description = 'removes given flag from a given user';
+    static examples = [
+        '$ heroku skynet:userpass:remove -u foo@bar.com -f cant-install-abused-addons'
+    ];
+    static flags = {
+        user: Flags.string({
+            name: 'user',
+            char: 'u',
+            description: 'user to remove user_pass from',
+            hasValue: true,
+            required: true
+        }),
+        flag: Flags.string({
+            name: 'flag',
+            char: 'f',
+            description: 'flag to remove from given user',
+            hasValue: true,
+            required: true
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(RemoveUserpass);
+        const skynet = new SkynetAPI(this.heroku.auth);
+        ux.action.start(`removing ${color.cyan(flags.flag)} from ${color.cyan(flags.user)}`);
+        await skynet.removeUserpass(flags.user, flags.flag);
+        ux.action.stop();
+    }
+}

package/dist/lib/heroku.d.ts

@@ -0,0 +1,13 @@
+import { Method } from 'got';
+interface RequestOptions {
+    method?: Method;
+    headers?: Record<string, string>;
+    body?: string;
+    json?: Record<string, any>;
+}
+export default class HerokuAPI {
+    private token;
+    constructor(token: string);
+    request(url: string, options?: RequestOptions): Promise<string>;
+}
+export {};

package/dist/lib/heroku.js

@@ -0,0 +1,32 @@
+'use strict';
+import got from 'got';
+const apiHost = 'https://api.heroku.com';
+export default class HerokuAPI {
+    token;
+    constructor(token) {
+        this.token = token;
+    }
+    async request(url, options = {}) {
+        const gotOptions = {
+            ...options,
+            headers: Object.assign({
+                Authorization: `Bearer ${this.token}`,
+                Accept: 'application/json',
+                'Content-type': 'application/x-www-form-urlencoded',
+                'X-Heroku-Sudo': 'true'
+            }, options.headers)
+        };
+        switch (options.method) {
+            case 'delete':
+                try {
+                    await got.delete(apiHost + url, gotOptions);
+                    return 'done';
+                }
+                catch {
+                    return 'failed';
+                }
+            default:
+                return '';
+        }
+    }
+}

package/dist/lib/skynet.d.ts

@@ -0,0 +1,32 @@
+import FormData from 'form-data';
+interface RequestOptions {
+    method?: 'GET' | 'POST' | 'DELETE';
+    headers?: Record<string, string>;
+    body?: FormData | any;
+    json?: any;
+    form?: any;
+}
+export default class SkynetAPI {
+    private version;
+    private token;
+    constructor(token: string);
+    request(url: string, options?: RequestOptions): Promise<any>;
+    categories(): Promise<any>;
+    addCategory(name: string, description: string): Promise<any>;
+    removeCategory(name: string): Promise<any>;
+    allowlists(): Promise<any>;
+    addAllowlist(appOrUserEmail: string, notes: string): Promise<any>;
+    removeAllowlist(appOrUserEmail: string): Promise<any>;
+    removeUserpass(user: string, flag: string): Promise<any>;
+    addUserpass(user: string, flag: string): Promise<any>;
+    suspendAppOwner(app: string, notes: string, category: string, force?: boolean, deprovision?: boolean, async?: boolean): Promise<any>;
+    suspendApp(app: string, notes: string, category: string, force?: boolean, async?: boolean): Promise<any>;
+    unsuspendApp(app: string, category: string, notes: string): Promise<any>;
+    suspendUser(user: string, notes: string, category: string, notify: boolean, force?: boolean, deprovision?: boolean, async?: boolean): Promise<any>;
+    unsuspendUser(user: string, category: string, notes: string): Promise<any>;
+    bulkSuspendUsers(file: string, notes: string, category: string, notify: boolean, force?: boolean, deprovision?: boolean): Promise<any>;
+    bulkSuspendAppOwner(apps: string, notes: string, category: string, deprovision?: boolean): Promise<any>;
+    deprovision(user: string, notes: string, category: string, notify?: boolean, force?: boolean): Promise<any>;
+    suspensions(account: string): Promise<any>;
+}
+export {};

package/dist/lib/skynet.js

@@ -0,0 +1,215 @@
+import got from 'got';
+import fs from 'fs';
+import FormData from 'form-data';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+let skynetHost = 'https://skynet.risk.herokai.com';
+// If test against local skynet environment, change skynet host to localhost:5000
+// let skynetHost = 'http://localhost:5000'
+if (process.env.SKYNET_HOST) {
+    skynetHost = process.env.SKYNET_HOST;
+}
+const SKYNET_BASE_URL = `${skynetHost}/api-h`;
+export default class SkynetAPI {
+    version;
+    token;
+    constructor(token) {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const packageJSON = JSON.parse(readFileSync(join(__dirname, '../../package.json'), 'utf8'));
+        this.version = `skynet-${packageJSON.version}`;
+        this.token = token;
+    }
+    request(url, options = {}) {
+        if (options.body && options.body instanceof FormData) {
+            options.headers = Object.assign({
+                Authorization: `Bearer ${this.token}`,
+                'User-Agent': this.version
+            }, options.body.getHeaders(), options.headers);
+        }
+        else {
+            options.headers = Object.assign({
+                Authorization: `Bearer ${this.token}`,
+                'User-Agent': this.version
+            }, options.headers);
+        }
+        switch (options.method) {
+            case 'DELETE':
+                return got.delete(SKYNET_BASE_URL + url, options).then(res => res.body);
+            case 'GET':
+                return got.get(SKYNET_BASE_URL + url, options).then(res => res.body);
+            case 'POST':
+                return got.post(SKYNET_BASE_URL + url, options).then(res => res.body);
+            default:
+                return Promise.resolve(null);
+        }
+    }
+    categories() {
+        return this.request('/categories', {
+            method: 'GET'
+        });
+    }
+    addCategory(name, description) {
+        return this.request('/categories', {
+            method: 'POST',
+            json: {
+                category: name,
+                description
+            }
+        });
+    }
+    removeCategory(name) {
+        return this.request(`/categories/${name}`, {
+            method: 'DELETE'
+        });
+    }
+    allowlists() {
+        return this.request('/whitelist', {
+            method: 'GET'
+        });
+    }
+    addAllowlist(appOrUserEmail, notes) {
+        const body = {
+            value: appOrUserEmail,
+            notes
+        };
+        return this.request('/whitelist', {
+            method: 'POST',
+            form: body
+        });
+    }
+    removeAllowlist(appOrUserEmail) {
+        return this.request(`/whitelist/${appOrUserEmail}`, {
+            method: 'DELETE',
+            json: {}
+        });
+    }
+    removeUserpass(user, flag) {
+        const body = {
+            user,
+            flag
+        };
+        return this.request('/userpass/remove', {
+            method: 'POST',
+            form: body
+        });
+    }
+    addUserpass(user, flag) {
+        const body = {
+            user,
+            flag
+        };
+        return this.request('/userpass/add', {
+            method: 'POST',
+            form: body
+        });
+    }
+    suspendAppOwner(app, notes, category, force = false, deprovision = false, async = false) {
+        const body = {
+            value: app,
+            reason: notes,
+            method: 'skynet-cli',
+            category,
+            force,
+            deprovision,
+            sync: !async,
+        };
+        return this.request('/suspend/app-owner', {
+            method: 'POST',
+            form: body
+        });
+    }
+    suspendApp(app, notes, category, force = false, async = false) {
+        const body = {
+            value: app,
+            reason: notes,
+            category,
+            force,
+            method: 'skynet-cli',
+            sync: !async,
+        };
+        return this.request('/suspend/app', {
+            method: 'POST',
+            form: body
+        });
+    }
+    unsuspendApp(app, category, notes) {
+        return this.request(`/suspensions/app/${app}?category=${category}&reason=${notes}`, {
+            method: 'DELETE',
+            json: {}
+        });
+    }
+    suspendUser(user, notes, category, notify, force = false, deprovision = false, async = false) {
+        const body = {
+            value: user,
+            reason: notes,
+            method: 'skynet-cli',
+            category,
+            force,
+            notify,
+            deprovision,
+            sync: !async,
+        };
+        return this.request('/suspend/user', {
+            method: 'POST',
+            form: body
+        });
+    }
+    unsuspendUser(user, category, notes) {
+        return this.request(`/suspensions/user/${user}?category=${category}&reason=${notes}`, {
+            method: 'DELETE',
+            json: {}
+        });
+    }
+    bulkSuspendUsers(file, notes, category, notify, force = false, deprovision = false) {
+        const fileStream = fs.createReadStream(file);
+        const form = new FormData();
+        form.append('file', fileStream);
+        form.append('reason', notes);
+        form.append('method', 'skynet-cli');
+        form.append('category', category);
+        form.append('bulk', 'true');
+        form.append('force', String(force));
+        form.append('notify', String(notify));
+        form.append('deprovision', String(deprovision));
+        return this.request('/bulk-suspend/user', {
+            method: 'POST',
+            body: form
+        });
+    }
+    bulkSuspendAppOwner(apps, notes, category, deprovision = false) {
+        const body = {
+            value: apps,
+            reason: notes,
+            method: 'skynet-cli',
+            category,
+            bulk: 'true',
+            deprovision
+        };
+        return this.request('/suspend/app-owner', {
+            method: 'POST',
+            form: body
+        });
+    }
+    deprovision(user, notes, category, notify = true, force = false) {
+        const body = {
+            value: user,
+            reason: notes,
+            method: 'skynet-cli',
+            category,
+            force,
+            notify
+        };
+        return this.request('/deprovision', {
+            method: 'POST',
+            form: body
+        });
+    }
+    suspensions(account) {
+        return this.request(`/v2/suspensions/${account}`, {
+            method: 'GET'
+        });
+    }
+}
+;

package/dist/lib/sudo.d.ts

@@ -0,0 +1 @@
+export declare function requireSudo(): void;

package/dist/lib/sudo.js

@@ -0,0 +1,7 @@
+'use strict';
+import { ux } from '@oclif/core';
+import { color } from '@heroku-cli/color';
+export function requireSudo() {
+    if (process.env.HEROKU_SUDO !== '1')
+        ux.error(color.bgRed('sudo is required for this command'));
+}

package/dist/lib/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function readlines(file: string): Promise<string[]>;
+export declare function arrayChunks<T>(array: T[], chunkSize: number): T[][];
+export declare function processSuspensionResult(suspendObject: any, response: any): void;
+export declare function processUnsuspendResult(unsuspendObject: any, response: any): void;
+export declare function logError(response: any): void;

package/dist/lib/utils.js

@@ -0,0 +1,57 @@
+import split from 'split';
+import fs from 'fs';
+import { ux } from '@oclif/core';
+import { color } from '@heroku-cli/color';
+export function readlines(file) {
+    return new Promise(function (resolve, reject) {
+        const entries = [];
+        fs.createReadStream(file).pipe(split())
+            .on('data', function (line) {
+            line = line.trim();
+            if (line) {
+                entries.push(line);
+            }
+        })
+            .on('end', function () {
+            resolve(entries);
+        })
+            .on('error', function (err) {
+            reject(err);
+        });
+    });
+}
+export function arrayChunks(array, chunkSize) {
+    const chunks = [];
+    if (array.length <= chunkSize) {
+        chunks.push(array);
+    }
+    else {
+        for (let i = 0; i < array.length; i += chunkSize) {
+            chunks.push(array.slice(i, i + chunkSize));
+        }
+    }
+    return chunks;
+}
+export function processSuspensionResult(suspendObject, response) {
+    if (response.statusCode === 200) {
+        ux.action.stop(color.green(`Suspended ${suspendObject}`));
+    }
+    else {
+        logError(response);
+        ux.action.stop(color.bgRed(`Failed to suspend ${suspendObject}`));
+    }
+}
+export function processUnsuspendResult(unsuspendObject, response) {
+    if (response.statusCode === 200) {
+        ux.action.stop(color.green(`Unsuspended ${unsuspendObject}`));
+    }
+    else {
+        logError(response);
+        ux.action.stop(color.bgRed(`Failed to unsuspend ${unsuspendObject}`));
+    }
+}
+export function logError(response) {
+    ux.log(`${color.red(response.status)} \'${response.statusCode}\'.`);
+    ux.log(color.red(response.message));
+    ux.log(color.red(`Error: ${response.error}`));
+}