@chabokan.net/cli 0.8.10 → 0.9.0

package/dist/base.d.ts

@@ -1,15 +1,40 @@
 import { Command } from '@oclif/core';
-export default abstract class extends Command {
+import { AxiosRequestConfig } from 'axios';
+import type { CloudServerRef, ConfigFile, Service, WalletRef } from './types.js';
+export default abstract class BaseCommand extends Command {
     static flags: {
-        help: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<void>;
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
     };
-    axiosConfig: any;
+    axiosConfig: AxiosRequestConfig;
     got: import("got").Got<never>;
-    read_config(): Promise<{
-        users: {};
-        default_user: string;
-    }>;
-    write_config(object: any): Promise<void>;
-    get_services(filter?: {}): Promise<any>;
+    read_config(): Promise<ConfigFile>;
+    write_config(object: ConfigFile): Promise<void>;
+    get_services(filter?: Record<string, string>): Promise<Service[]>;
+    /**
+     * Returns true when an account is logged in. Otherwise prints a consistent
+     * message telling the user how to fix it and returns false, so callers can
+     * simply `if (!(await this.require_login())) return`.
+     */
+    require_login(): Promise<boolean>;
+    /**
+     * Resolves which service to act on. Returns `flagValue` untouched when the
+     * user passed --service, otherwise fetches the account's services and
+     * prompts. Returns undefined (having already logged why) when the service
+     * cannot be determined, so callers should bail out on a falsy result.
+     */
+    select_service(flagValue: string | undefined, filter?: Record<string, string>, operation?: string): Promise<string | undefined>;
+    /**
+     * Resolves which cloud server (VPS) to act on, by hostname. The API needs
+     * an internal `cloud_server_id` for every action, but that id is plumbing
+     * only — it is never shown to, or asked of, the user. Both the flag path
+     * and the interactive path fetch the list and match on hostname, so a
+     * bogus `--hostname` is reported clearly instead of silently sent as-is.
+     */
+    select_cloud_server(flagValue: string | undefined, operation?: string): Promise<CloudServerRef | undefined>;
+    /**
+     * Prompts the user to pick a wallet, by name — mirrors `select_cloud_server`
+     * in keeping the internal id out of both the flag and the prompt.
+     */
+    select_wallet(flagValue: string | undefined): Promise<undefined | WalletRef>;
     init_run(): Promise<void>;
 }

package/dist/base.js

@@ -1,57 +1,209 @@
 import { Command, Flags } from '@oclif/core';
 import axios from 'axios';
-import { BASE_API_URL, GLOBAL_CONF_PATH } from './constants.js';
-import { checkUpdate, get_all_services, isEmptyObject, read_config_file } from './helper.js';
-import HttpsProxyAgent from 'https-proxy-agent';
-import * as fs from 'fs';
+import { BASE_API_URL, REQUEST_TIMEOUT, UPLOAD_TIMEOUT } from './constants.js';
+import { checkUpdate, extractRecords, get_all_services, handleApiError, isEmptyObject, logErrorDetails, read_config_file, write_config_file, } from './helper.js';
+import { HttpsProxyAgent } from 'https-proxy-agent';
+import * as ui from './ui.js';
+import inquirer from 'inquirer';
 import got from 'got';
-import * as https from 'https';
-export default class default_1 extends Command {
+import * as https from 'node:https';
+export default class BaseCommand extends Command {
     static flags = {
         help: Flags.help({ char: 'h' }),
     };
     axiosConfig = {
-        ...axios.defaults
+        ...axios.defaults,
+        headers: {},
+        timeout: REQUEST_TIMEOUT,
     };
     got = got.extend();
     async read_config() {
         return read_config_file();
     }
     async write_config(object) {
-        fs.writeFileSync(GLOBAL_CONF_PATH, JSON.stringify(object));
+        write_config_file(object);
     }
     async get_services(filter = {}) {
-        return await get_all_services(filter, this.axiosConfig);
+        return get_all_services(filter, this.axiosConfig);
+    }
+    /**
+     * Returns true when an account is logged in. Otherwise prints a consistent
+     * message telling the user how to fix it and returns false, so callers can
+     * simply `if (!(await this.require_login())) return`.
+     */
+    async require_login() {
+        const config_json = await this.read_config();
+        if (isEmptyObject(config_json.users) || Object.keys(config_json.users).length === 0) {
+            this.log(ui.error('You are not logged in.'));
+            this.log(ui.hint(`Run ${ui.cmd('chabok login')} to sign in with your email, or ${ui.cmd('chabok login -t <token>')} to use an API token`));
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Resolves which service to act on. Returns `flagValue` untouched when the
+     * user passed --service, otherwise fetches the account's services and
+     * prompts. Returns undefined (having already logged why) when the service
+     * cannot be determined, so callers should bail out on a falsy result.
+     */
+    async select_service(flagValue, filter = {}, operation = 'Fetch Services') {
+        if (flagValue) {
+            return flagValue;
+        }
+        let all_services;
+        try {
+            all_services = await this.get_services(filter);
+        }
+        catch (error) {
+            const errorInfo = handleApiError(error, 'Failed to fetch services list.', {
+                endpoint: 'services/',
+                operation,
+            });
+            this.log(ui.error(errorInfo.message));
+            logErrorDetails(errorInfo, this);
+            return undefined;
+        }
+        if (all_services.length === 0) {
+            this.log(ui.info('No services available for this action.'));
+            this.log(ui.hint(`See everything on your account with ${ui.cmd('chabok service list')}`));
+            return undefined;
+        }
+        const { service } = await inquirer.prompt({
+            type: 'select',
+            message: 'Please select a service:',
+            name: 'service',
+            choices: all_services,
+        });
+        return service;
+    }
+    /**
+     * Resolves which cloud server (VPS) to act on, by hostname. The API needs
+     * an internal `cloud_server_id` for every action, but that id is plumbing
+     * only — it is never shown to, or asked of, the user. Both the flag path
+     * and the interactive path fetch the list and match on hostname, so a
+     * bogus `--hostname` is reported clearly instead of silently sent as-is.
+     */
+    async select_cloud_server(flagValue, operation = 'Fetch Cloudservers') {
+        let records;
+        try {
+            const { data } = await axios.get('cloudservers/', this.axiosConfig);
+            records = extractRecords(data, ['user_cloud_servers', 'cloudservers', 'results', 'data']);
+        }
+        catch (error) {
+            const errorInfo = handleApiError(error, 'Failed to fetch cloud servers list.', {
+                endpoint: 'cloudservers/',
+                operation,
+            });
+            this.log(ui.error(errorInfo.message));
+            logErrorDetails(errorInfo, this);
+            return undefined;
+        }
+        if (records.length === 0) {
+            this.log(ui.info('No cloud servers available for this action.'));
+            this.log(ui.hint(`See everything on your account with ${ui.cmd('chabok cloudserver list')}`));
+            return undefined;
+        }
+        const refs = records
+            .filter((record) => record.id !== undefined && record.hostname !== undefined)
+            .map((record) => ({ id: String(record.id), hostname: String(record.hostname) }));
+        if (flagValue) {
+            const match = refs.find((ref) => ref.hostname === flagValue);
+            if (!match) {
+                this.log(ui.error(`Cloud server ${ui.value(flagValue)} was not found.`));
+                this.log(ui.hint(`Check the available hostnames with ${ui.cmd('chabok cloudserver list')}`));
+                return undefined;
+            }
+            return match;
+        }
+        const { hostname } = await inquirer.prompt({
+            type: 'select',
+            message: 'Please select a cloud server:',
+            name: 'hostname',
+            choices: refs.map((ref) => ({ value: ref.hostname, name: ref.hostname })),
+        });
+        return refs.find((ref) => ref.hostname === hostname);
+    }
+    /**
+     * Prompts the user to pick a wallet, by name — mirrors `select_cloud_server`
+     * in keeping the internal id out of both the flag and the prompt.
+     */
+    async select_wallet(flagValue) {
+        let wallets;
+        try {
+            const { data } = await axios.get('wallets/', this.axiosConfig);
+            wallets = extractRecords(data, ['wallets', 'results', 'data']);
+        }
+        catch (error) {
+            const errorInfo = handleApiError(error, 'Failed to fetch wallets.', {
+                endpoint: 'wallets/',
+                operation: 'List Wallets',
+            });
+            this.log(ui.error(errorInfo.message));
+            logErrorDetails(errorInfo, this);
+            return undefined;
+        }
+        if (wallets.length === 0) {
+            this.log(ui.info('You have no wallets to pay from.'));
+            return undefined;
+        }
+        const refs = wallets
+            .filter((record) => record.id !== undefined && record.name !== undefined)
+            .map((record) => ({ id: String(record.id), name: String(record.name) }));
+        if (flagValue) {
+            const match = refs.find((ref) => ref.name === flagValue);
+            if (!match) {
+                this.log(ui.error(`Wallet ${ui.value(flagValue)} was not found.`));
+                return undefined;
+            }
+            return match;
+        }
+        const { name } = await inquirer.prompt({
+            type: 'select',
+            message: 'Pay from which wallet?',
+            name: 'name',
+            choices: refs.map((ref) => ({ value: ref.name, name: ref.name })),
+        });
+        return refs.find((ref) => ref.name === name);
     }
     async init_run() {
         await checkUpdate(this.config.version);
+        // Certificate verification stays on by default. CHABOK_INSECURE_TLS is an
+        // explicit escape hatch for self-signed endpoints, and it warns loudly.
+        const insecure = process.env.CHABOK_INSECURE_TLS === 'true';
+        if (insecure) {
+            this.warn('TLS certificate verification is disabled (CHABOK_INSECURE_TLS=true). Your credentials are not protected against interception.');
+        }
         const main_agent = new https.Agent({
-            rejectUnauthorized: false
+            rejectUnauthorized: !insecure
         });
-        // @ts-ignore
-        const gotConfig = {};
+        const gotConfig = {
+            prefixUrl: BASE_API_URL,
+            agent: { https: main_agent },
+            timeout: { request: UPLOAD_TIMEOUT },
+        };
         this.axiosConfig.httpsAgent = main_agent;
         this.axiosConfig.baseURL = BASE_API_URL;
-        gotConfig.prefixUrl = this.axiosConfig.baseURL;
-        gotConfig.agent = { https: main_agent };
         const proxy = process.env.http_proxy || process.env.https_proxy;
         if (proxy) {
             this.log(`Using proxy server ${proxy}`);
-            // @ts-ignore
-            const agent = new HttpsProxyAgent(proxy);
+            const agent = new HttpsProxyAgent(proxy, { rejectUnauthorized: !insecure });
             this.axiosConfig.httpsAgent = agent;
             this.axiosConfig.proxy = false;
-            // @ts-ignore
+            // HttpsProxyAgent is a drop-in https.Agent at runtime, but its
+            // getName() signature is not structurally compatible with @types/node.
             gotConfig.agent = { https: agent };
         }
         const config_json = read_config_file();
-        this.got = got.extend(gotConfig);
         if (isEmptyObject(config_json) || isEmptyObject(config_json.users)) {
+            this.got = got.extend(gotConfig);
             return;
         }
-        // @ts-ignore
-        const token = config_json.users[config_json.default_user]["token"] || null;
+        const defaultUser = config_json.default_user;
+        const token = defaultUser && config_json.users[defaultUser]?.token;
         if (token) {
+            if (!this.axiosConfig.headers) {
+                this.axiosConfig.headers = {};
+            }
             this.axiosConfig.headers.Authorization = `Token ${token}`;
             gotConfig.headers = { Authorization: `Token ${token}` };
         }

package/dist/commands/account/info.d.ts

@@ -0,0 +1,12 @@
+import Command from "../../base.js";
+export default class AccountInfo extends Command {
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/account/info.js

@@ -0,0 +1,40 @@
+import Command from "../../base.js";
+import * as ui from "../../ui.js";
+import { handleApiError, logErrorDetails, isObject } from "../../helper.js";
+import axios from "axios";
+export default class AccountInfo extends Command {
+    static description = "show information about the active account";
+    static examples = [
+        {
+            description: 'Show the active account\'s details',
+            command: '<%= config.bin %> account info',
+        },
+    ];
+    static flags = {
+        ...Command.flags,
+    };
+    async run() {
+        await this.parse(AccountInfo);
+        const cli = this;
+        await this.init_run();
+        if (!(await this.require_login())) {
+            return;
+        }
+        try {
+            const { data } = await axios.get('accounts/info/', this.axiosConfig);
+            if (!isObject(data.user)) {
+                cli.log(ui.info('No account information was returned.'));
+                return;
+            }
+            ui.printRecord(data.user);
+        }
+        catch (error) {
+            const errorInfo = handleApiError(error, 'Failed to fetch account information.', {
+                endpoint: 'accounts/info/',
+                operation: 'Account Info'
+            });
+            cli.log(ui.error(errorInfo.message));
+            logErrorDetails(errorInfo, cli);
+        }
+    }
+}

package/dist/commands/account/list.d.ts

@@ -1,8 +1,12 @@
 import Command from "../../base.js";
 export default class AccountList extends Command {
     static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
     static flags: {
-        help: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<void>;
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
     };
     run(): Promise<void>;
 }

package/dist/commands/account/list.js

@@ -1,28 +1,47 @@
 import Command from "../../base.js";
-import { ux } from "@oclif/core";
+import { printTable } from "@oclif/table";
+import * as ui from "../../ui.js";
+import { isDebug } from "../../helper.js";
 export default class AccountList extends Command {
-    static description = "show accounts list";
+    static description = "list the accounts you are logged in to";
+    static examples = [
+        {
+            description: 'Show every logged-in account and which one is active',
+            command: '<%= config.bin %> account list',
+        },
+    ];
     static flags = {
         ...Command.flags,
     };
     async run() {
-        const { args, flags } = await this.parse(AccountList);
+        await this.parse(AccountList);
         const cli = this;
-        await this.init_run();
-        const config_json = await this.read_config();
-        if (Object.keys(config_json.users).length > 0) {
-            const accounts_data = Object.keys(config_json.users).map((account) => {
-                return {
-                    Name: account,
-                };
+        try {
+            await this.init_run();
+            const config_json = await this.read_config();
+            const accounts = Object.keys(config_json.users);
+            if (accounts.length === 0) {
+                cli.log(ui.info('You are not logged in to any account.'));
+                cli.log(ui.hint(`Run ${ui.cmd('chabok login')} to get started`));
+                return;
+            }
+            const accounts_data = accounts.map((account) => ({
+                Account: account,
+                Active: account === config_json.default_user ? "yes" : "",
+            }));
+            printTable({
+                data: accounts_data,
+                columns: ["Account", "Active"],
             });
-            ux.table(accounts_data, {
-                Name: {},
-            }, flags);
+            if (accounts.length > 1) {
+                cli.log(ui.hint(`Switch with ${ui.cmd('chabok account use')}`));
+            }
         }
-        else {
-            cli.log("first you should login");
-            return;
+        catch (error) {
+            cli.log(ui.error('Could not read your accounts.'));
+            if (isDebug()) {
+                cli.log(String(error));
+            }
         }
     }
 }

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

@@ -1,8 +1,12 @@
 import Command from "../../base.js";
 export default class AccountRemove extends Command {
     static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
     static flags: {
-        help: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<void>;
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
     };
     run(): Promise<void>;
 }

package/dist/commands/account/remove.js

@@ -1,34 +1,49 @@
 import inquirer from "inquirer";
-import chalk from "chalk";
+import * as ui from "../../ui.js";
 import { isEmptyObject, read_config_file } from "../../helper.js";
 import Command from "../../base.js";
-import { GLOBAL_CONF_PATH } from "../../constants.js";
-import fs from "fs";
 export default class AccountRemove extends Command {
-    static description = "remove account from list";
+    static description = "sign out of an account and forget its stored token";
+    static examples = [
+        {
+            description: 'Pick the account to sign out of',
+            command: '<%= config.bin %> account remove',
+        },
+    ];
     static flags = {
         ...Command.flags,
     };
     async run() {
         const cli = this;
-        const { args, flags } = await this.parse(AccountRemove);
+        await this.parse(AccountRemove);
         const config_json = read_config_file();
         if (isEmptyObject(config_json.users)) {
-            cli.log(`${chalk.red("[Error]")} first you should login!`);
+            cli.log(ui.info('There are no logged-in accounts to remove.'));
             return;
         }
-        let { user } = await inquirer.prompt({
-            type: "list",
-            message: "Please select a user:",
+        const { user } = await inquirer.prompt({
+            type: "select",
+            message: "Sign out of which account?",
             name: "user",
             choices: Object.keys(config_json.users),
         });
-        // @ts-ignore
-        delete config_json.users[user];
-        if (config_json["default_user"] == user) {
-            config_json["default_user"] = "";
+        if (user in config_json.users) {
+            delete config_json.users[user];
+            if (config_json.default_user === user) {
+                // Fall back to any remaining account so the CLI stays usable.
+                config_json.default_user = Object.keys(config_json.users)[0] ?? "";
+            }
+            await this.write_config(config_json);
+            cli.log(ui.success(`Signed out of ${ui.value(user)}.`));
+            if (config_json.default_user) {
+                cli.log(ui.hint(`Now using ${ui.value(config_json.default_user)}`));
+            }
+            else {
+                cli.log(ui.hint(`No accounts left — run ${ui.cmd('chabok login')} to sign in again`));
+            }
+        }
+        else {
+            cli.log(ui.error(`No account named ${ui.value(user)} is logged in.`));
         }
-        fs.writeFileSync(GLOBAL_CONF_PATH, JSON.stringify(config_json));
-        cli.log(`${chalk.green("[Success]")} user deleted successfully.`);
     }
 }

package/dist/commands/account/use.d.ts

@@ -1,9 +1,13 @@
 import Command from "../../base.js";
 export default class AccountUse extends Command {
     static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
     static flags: {
-        user: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        help: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<void>;
+        user: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
     };
     run(): Promise<void>;
 }

package/dist/commands/account/use.js

@@ -1,41 +1,52 @@
 import { Flags } from "@oclif/core";
 import inquirer from "inquirer";
-import * as fs from "fs";
-import chalk from "chalk";
+import * as ui from "../../ui.js";
 import { isEmptyObject, read_config_file } from "../../helper.js";
 import Command from "../../base.js";
-import { GLOBAL_CONF_PATH } from "../../constants.js";
 export default class AccountUse extends Command {
-    static description = "switch your default user between logged in users";
+    static description = "switch the active account";
+    static examples = [
+        {
+            description: 'Pick the account to switch to from a list',
+            command: '<%= config.bin %> account use',
+        },
+        {
+            description: 'Switch to a specific account without prompting',
+            command: '<%= config.bin %> account use --user me@example.com',
+        },
+    ];
     static flags = {
         ...Command.flags,
-        user: Flags.string({ char: "u", description: "default user" }),
+        user: Flags.string({ char: "u", description: "email of the account to switch to" }),
     };
     async run() {
         const cli = this;
-        const { args, flags } = await this.parse(AccountUse);
+        const { flags } = await this.parse(AccountUse);
         const config_json = read_config_file();
         let default_user = flags.user;
         if (isEmptyObject(config_json.users)) {
-            cli.log(`${chalk.red("[Error]")} first you should login!`);
+            cli.log(ui.error('You are not logged in to any account.'));
+            cli.log(ui.hint(`Run ${ui.cmd('chabok login')} first`));
             return;
         }
         if (!flags.user) {
-            let { user } = await inquirer.prompt({
-                type: "list",
-                message: "Please select a user:",
+            const { user } = await inquirer.prompt({
+                type: "select",
+                message: "Switch to which account?",
                 name: "user",
+                default: config_json.default_user,
                 choices: Object.keys(config_json.users),
             });
             default_user = user;
         }
-        if (default_user in config_json.users) {
-            config_json["default_user"] = default_user;
-            fs.writeFileSync(GLOBAL_CONF_PATH, JSON.stringify(config_json));
-            cli.log(`${chalk.green("[Success]")} user changed successfully.`);
+        if (default_user && default_user in config_json.users) {
+            config_json.default_user = default_user;
+            await this.write_config(config_json);
+            cli.log(ui.success(`Now using ${ui.value(default_user)}.`));
         }
         else {
-            cli.log(`${chalk.red("[Error]")} selected user not exist!`);
+            cli.log(ui.error(`No account named ${ui.value(String(default_user))} is logged in.`));
+            cli.log(ui.hint(`See your accounts with ${ui.cmd('chabok account list')}`));
         }
     }
 }

package/dist/commands/cloudserver/create.d.ts

@@ -0,0 +1,40 @@
+import Command from "../../base.js";
+interface Choice {
+    value: string;
+    name: string;
+}
+export default class CloudserverCreate extends Command {
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        hostname: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        wallet: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+    };
+    run(): Promise<void>;
+    /**
+     * Fetches locations for `cloudId` and lets the user pick one. Some
+     * locations (notably Iranian ones) come with a legal disclaimer under
+     * `extra_data.description` that the user must read and accept before the
+     * server can be created — this isn't documented in the OpenAPI schema at
+     * all, only discovered by hitting the create endpoint's rejection message.
+     */
+    pick_location(cloudId: string): Promise<undefined | {
+        location: Choice;
+        descriptionConfirmed: boolean | undefined;
+    }>;
+    pick_hostname(flagValue: string | undefined): Promise<string | undefined>;
+    /**
+     * Fetches a list from `endpoint`, lets the user pick one, and returns its
+     * {value, name}. `toChoice` defaults to a generic id/name mapper, but most
+     * of these endpoints have a known shape (learned by hand against the live
+     * API), so callers pass an explicit mapper for a clearer label. `value` is
+     * whatever the create request needs (an id) — the choice list itself only
+     * ever shows `name`.
+     */
+    pick(label: string, method: 'get' | 'post', endpoint: string, body: Record<string, unknown> | undefined, wrapperKeys: string[], toChoice?: (record: Record<string, unknown>) => Choice): Promise<Choice | undefined>;
+}
+export {};