@chabokan.net/cli 0.8.10 → 0.9.0

package/dist/commands/deploy.js

@@ -1,144 +1,218 @@
 import { Flags } from "@oclif/core";
-import inquirer from "inquirer";
-import chalk from "chalk";
+import * as ui from "../ui.js";
 import Command from "../base.js";
-import { addIgnorePatterns, isEmptyObject } from "../helper.js";
+import { addIgnorePatterns, isDebug, handleApiError, logErrorDetails } from "../helper.js";
 import ProgressBar from "progress";
 import FormData from "form-data";
 import ignore from "ignore";
-import { dirname } from "path";
-import * as path from "path";
-import * as os from "os";
+import { dirname } from "node:path";
+import * as path from "node:path";
+import * as os from "node:os";
 import fs from "fs-extra";
 import * as tar from 'tar';
 const MAX_SOURCE_SIZE = 100 * 1024 * 1024; // 100 MB
+/** Renders a byte count the way a person would say it out loud. */
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ["KB", "MB", "GB"];
+    let size = bytes / 1024;
+    let unit = 0;
+    while (size >= 1024 && unit < units.length - 1) {
+        size /= 1024;
+        unit++;
+    }
+    return `${size < 10 ? size.toFixed(1) : Math.round(size)} ${units[unit]}`;
+}
 export default class Deploy extends Command {
-    static description = "this command help you build and deploy your service to chabokan in easy way.";
+    static description = "upload the current project and deploy it to a service";
+    static examples = [
+        {
+            description: 'Deploy the current directory, picking the service from a list',
+            command: '<%= config.bin %> deploy',
+        },
+        {
+            description: 'Deploy the current directory to a named service',
+            command: '<%= config.bin %> deploy --service my-app',
+        },
+        {
+            description: 'Deploy a project that lives somewhere else',
+            command: '<%= config.bin %> deploy --path ./apps/api --service my-api',
+        },
+        {
+            description: 'Pin the target service in the project, so plain `deploy` always works',
+            command: 'echo \'{"service": "my-app"}\' > chabok.json && <%= config.bin %> deploy',
+        },
+        {
+            description: 'See exactly which files are excluded from the upload',
+            command: 'CHABOK_DEBUG=true <%= config.bin %> deploy -s my-app',
+        },
+    ];
     static flags = {
         ...Command.flags,
         path: Flags.string({
             char: "p",
-            description: "service path in your computer",
+            description: "project directory to upload (defaults to the current directory)",
         }),
-        service: Flags.string({ char: "s", description: "service name" }),
+        service: Flags.string({ char: "s", description: "name of the service to deploy to" }),
     };
     async run() {
-        const { args, flags } = await this.parse(Deploy);
+        const { flags } = await this.parse(Deploy);
         const cli = this;
         await this.init_run();
-        const config_json = await this.read_config();
         let selected_service = flags.service;
-        let project_path = flags.path ? flags.path : process.cwd();
-        let chabok_file = { service: "" };
-        try {
-            chabok_file =
-                JSON.parse(fs
-                    .readFileSync(path.join(project_path, "chabok.json"))
-                    .toString("utf-8")) || {};
-            cli.log("Reading Config from chabok.json ...");
-        }
-        catch { }
+        const project_path = flags.path ? flags.path : process.cwd();
+        const chabok_file = this.read_chabok_file(project_path);
         if (chabok_file.service) {
             selected_service = chabok_file.service;
         }
-        if (isEmptyObject(config_json.users)) {
-            cli.log(`${chalk.red("[Error]")} first you should login!`);
+        if (!(await this.require_login())) {
             return;
         }
+        selected_service = await this.select_service(selected_service, { has_deploy: "true", status: "on" }, "Deploy");
         if (!selected_service) {
-            let all_services = await this.get_services({
-                has_deploy: "true",
-                status: "on",
-            });
-            if (all_services.length > 0) {
-                let { service } = await inquirer.prompt({
-                    type: "list",
-                    message: "Please select a service:",
-                    name: "service",
-                    choices: all_services,
-                });
-                selected_service = service;
+            return;
+        }
+        try {
+            const archive_path = await this.prepare_archive(project_path);
+            const upload_response = await this.upload(archive_path, selected_service, cli, chabok_file);
+            if (upload_response.success) {
+                cli.log(ui.success(upload_response.message));
+                cli.log(ui.hint(`Watch it come up with ${ui.cmd(`chabok service logs -s ${selected_service}`)}`));
             }
             else {
-                cli.log("first you should create service");
-                return;
+                cli.log(ui.error(upload_response.message));
             }
         }
-        let archive_path = await this.prepare_archive(project_path);
-        let upload_response = await this.upload(archive_path, selected_service, cli, chabok_file);
-        if (upload_response.success) {
-            cli.log(chalk.green(upload_response.message));
+        catch (error) {
+            const errorInfo = handleApiError(error, 'Deployment failed. Check your project files and try again.', {
+                endpoint: `services/${selected_service}/deploy/`,
+                serviceName: selected_service,
+                operation: 'Deploy'
+            });
+            cli.log(ui.error(errorInfo.message));
+            logErrorDetails(errorInfo, cli);
+        }
+    }
+    /**
+     * Loads chabok.json from the project root. A missing file is normal; a
+     * malformed one is reported rather than silently ignored, because deploying
+     * with the wrong options is worse than not deploying.
+     */
+    read_chabok_file(project_path) {
+        const chabokFilePath = path.join(project_path, "chabok.json");
+        if (!fs.existsSync(chabokFilePath)) {
+            return { service: "" };
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(fs.readFileSync(chabokFilePath).toString("utf8"));
+        }
+        catch (error) {
+            this.warn(`Ignoring chabok.json: it is not valid JSON. ${error instanceof Error ? error.message : ""}`);
+            return { service: "" };
+        }
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            this.warn("Ignoring chabok.json: expected a JSON object.");
+            return { service: "" };
         }
-        else {
-            cli.log(chalk.red("[Error] " + upload_response.message));
+        const chabok_file = parsed;
+        if (chabok_file.service !== undefined && typeof chabok_file.service !== "string") {
+            this.warn('Ignoring "service" in chabok.json: expected a string.');
+            delete chabok_file.service;
         }
+        this.log(ui.info('Using settings from chabok.json'));
+        return chabok_file;
     }
     async prepare_archive(project_path) {
-        const defaultIgnores = [
-            ".npm",
-            ".git",
-            ".idea",
-            ".DS_Store",
-            ".vscode",
-            "__pycache__",
-            ".next",
-            ".nuxt",
-            "*.*~",
-            "node_modules",
-            "bower_components",
-            "venv",
-            "/vendor",
-            "*.log",
-        ];
-        const ignoreCache = {};
-        const ignoreInstance = ignore.default({ ignorecase: false });
-        ignoreInstance.add(defaultIgnores);
-        const ignoreFN = (f) => {
-            const dir = dirname(f);
-            if (!ignoreCache[dir]) {
-                addIgnorePatterns(ignoreInstance, project_path, dir);
-                ignoreCache[dir] = true;
+        try {
+            if (!fs.existsSync(project_path)) {
+                throw new Error(`Project path does not exist: ${project_path}`);
             }
-            if (!ignoreInstance.ignores(f)) {
-                return true;
+            if (!fs.statSync(project_path).isDirectory()) {
+                throw new Error(`Project path is not a directory: ${project_path}`);
             }
-            console.log(`ignoring ${f}`);
-            return false;
-        };
-        const tmpDir = path.join(os.tmpdir(), "/chabok-cli");
-        const archivePath = path.join(tmpDir, `${Date.now()}.tar.gz`);
-        fs.ensureDirSync(tmpDir);
-        const fileList = fs.readdirSync(project_path).filter(ignoreFN);
-        tar.c({
-            gzip: {
-                level: 9,
-            },
-            sync: true,
-            cwd: project_path,
-            filter: ignoreFN,
-            file: archivePath,
-        }, fileList);
-        return archivePath;
+            const defaultIgnores = [
+                ".npm",
+                ".git",
+                ".idea",
+                ".DS_Store",
+                ".vscode",
+                "__pycache__",
+                ".next",
+                ".nuxt",
+                "*.*~",
+                "node_modules",
+                "bower_components",
+                "venv",
+                "/vendor",
+                "*.log",
+            ];
+            const ignoreCache = {};
+            const ignoreInstance = ignore({ ignorecase: false });
+            ignoreInstance.add(defaultIgnores);
+            const ignoreFN = (f) => {
+                const dir = dirname(f);
+                if (!ignoreCache[dir]) {
+                    addIgnorePatterns(ignoreInstance, project_path, dir);
+                    ignoreCache[dir] = true;
+                }
+                if (!ignoreInstance.ignores(f)) {
+                    return true;
+                }
+                if (isDebug()) {
+                    console.log(`ignoring ${f}`);
+                }
+                return false;
+            };
+            const tmpDir = path.join(os.tmpdir(), "/chabok-cli");
+            const archivePath = path.join(tmpDir, `${Date.now()}.tar.gz`);
+            fs.ensureDirSync(tmpDir);
+            const fileList = fs.readdirSync(project_path).filter(ignoreFN);
+            if (fileList.length === 0) {
+                throw new Error(`Nothing to upload from ${project_path} — the directory is empty, or every file in it is ignored. Check your .chabokignore, .dockerignore or .gitignore.`);
+            }
+            tar.c({
+                gzip: {
+                    level: 9,
+                },
+                sync: true,
+                cwd: project_path,
+                filter: ignoreFN,
+                file: archivePath,
+            }, fileList);
+            return archivePath;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                // eslint-disable-next-line unicorn/prefer-type-error -- this is an I/O failure, not a type check
+                throw new Error(`Failed to prepare archive: ${error.message}`);
+            }
+            throw new Error('Failed to prepare archive: Unknown error');
+        }
     }
     async upload(archive_path, selected_service, cli, chabok_file) {
-        let upload_response = {
+        const upload_response = {
             success: false,
             message: "some problem",
         };
         const body = new FormData();
-        // @ts-ignore
         body.append("file", fs.createReadStream(archive_path));
         body.append("options", JSON.stringify(chabok_file));
-        const { size: sourceSize } = fs.statSync(archive_path);
+        const stats = fs.statSync(archive_path);
+        const sourceSize = stats.size;
         if (sourceSize > MAX_SOURCE_SIZE) {
-            upload_response.message = "Source is too large. (max: 100MB)";
+            upload_response.message =
+                `Your project is ${formatBytes(sourceSize)} compressed, over the ${formatBytes(MAX_SOURCE_SIZE)} limit. ` +
+                    `Add large files to .chabokignore and try again.`;
             return upload_response;
         }
-        const bar = new ProgressBar("Uploading [:bar] :percent :etas", {
+        cli.log(ui.info(`Uploading ${ui.value(formatBytes(sourceSize))} to ${ui.value(selected_service)}`));
+        const bar = new ProgressBar("  [:bar] :percent  :etas left", {
             total: sourceSize,
-            width: 20,
-            complete: "=",
-            incomplete: "",
+            width: 24,
+            complete: "█",
+            incomplete: "░",
             clear: true,
         });
         try {
@@ -150,24 +224,31 @@ export default class Deploy extends Command {
                 .json();
             if (response.success) {
                 upload_response.success = true;
-                upload_response.message = "Deployment finished successfully.";
+                upload_response.message = `Deployed to ${ui.value(selected_service)}.`;
             }
             else {
-                if (process.env.CHABOK_DEBUG == "true") {
-                    cli.log(response);
+                upload_response.message = `Deployment failed. ${String(response.message || "The server did not say why — try again.")}`;
+                if (isDebug()) {
+                    cli.log(JSON.stringify(response, null, 2));
                 }
             }
             return upload_response;
         }
         catch (error) {
-            if (process.env.CHABOK_DEBUG == "true") {
-                cli.log(error);
-            }
+            const errorInfo = handleApiError(error, 'Deployment failed. Please check your project files and network connection.', {
+                endpoint: `services/${selected_service}/deploy/`,
+                serviceName: selected_service,
+                operation: 'Upload Deployment'
+            });
+            upload_response.message = errorInfo.message;
+            logErrorDetails(errorInfo, cli);
             return upload_response;
         }
         finally {
             // cleanup
-            fs.unlink(archive_path).catch(() => { });
+            fs.unlink(archive_path).catch(() => {
+                // Ignore cleanup errors
+            });
         }
     }
 }

package/dist/commands/login.d.ts

@@ -1,11 +1,15 @@
 import Command from "../base.js";
 export default class Login extends Command {
     static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
     static flags: {
-        username: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        password: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        token: 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>;
+        username: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        password: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        token: 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/login.js

@@ -1,32 +1,89 @@
 import { Flags } from '@oclif/core';
 import inquirer from 'inquirer';
 import axios from "axios";
-import chalk from "chalk";
-import { isObject } from "../helper.js";
+import * as ui from "../ui.js";
+import { isObject, handleApiError, logErrorDetails } from "../helper.js";
 import Command from "../base.js";
 export default class Login extends Command {
-    static description = 'login to hub.chabokan.net account';
+    static description = 'sign in to your hub.chabokan.net account';
+    static examples = [
+        {
+            description: 'Sign in interactively (prompts for email and password)',
+            command: '<%= config.bin %> login',
+        },
+        {
+            description: 'Sign in with an API token — the right choice for CI',
+            command: '<%= config.bin %> login --token <your-api-token>',
+        },
+        {
+            description: 'Pass the email up front and be prompted only for the password',
+            command: '<%= config.bin %> login --email me@example.com',
+        },
+        {
+            description: 'Add a second account (both stay signed in; switch with `account use`)',
+            command: '<%= config.bin %> login --email other@example.com',
+        },
+    ];
     static flags = {
         ...Command.flags,
-        username: Flags.string({ char: 'u', description: 'your username' }),
-        password: Flags.string({ char: 'p', description: 'your password' }),
-        token: Flags.string({ char: 't', description: 'login with api token' }),
+        // The API still calls this field "username", but it only accepts emails;
+        // --email is accepted as an alias so the flag matches what users type.
+        username: Flags.string({ char: 'u', aliases: ['email'], description: 'your email address' }),
+        password: Flags.string({ char: 'p', description: 'your password (prompted for if omitted)' }),
+        token: Flags.string({ char: 't', description: 'API token, for non-interactive sign-in' }),
     };
     async run() {
-        const { args, flags } = await this.parse(Login);
+        const { flags } = await this.parse(Login);
         const cli = this;
         await this.init_run();
         const config_json = await this.read_config();
-        const body = { username: flags.username, password: flags.password };
-        if (!flags.token) {
+        const body = {
+            username: flags.username,
+            password: flags.password
+        };
+        if (flags.token) {
+            try {
+                if (!this.axiosConfig.headers) {
+                    this.axiosConfig.headers = {};
+                }
+                this.axiosConfig.headers.Authorization = `Token ${flags.token}`;
+                const { data } = await axios.get("accounts/info/", this.axiosConfig);
+                if (!isObject(config_json.users)) {
+                    config_json.users = {};
+                }
+                const { email } = data.user;
+                config_json.users[email] = {
+                    token: flags.token
+                };
+                config_json.default_user = email;
+                await this.write_config(config_json);
+                cli.log(ui.success(`Signed in as ${ui.value(email)} using an API token.`));
+                cli.log(ui.hint(`See what you can reach with ${ui.cmd('chabok service list')}`));
+            }
+            catch (error) {
+                const errorInfo = handleApiError(error, 'That API token was not accepted.', {
+                    endpoint: 'accounts/info/',
+                    operation: 'Token Login'
+                });
+                cli.log(ui.error(errorInfo.message));
+                cli.log(ui.hint('Generate a token from your account settings at https://hub.chabokan.net'));
+                logErrorDetails(errorInfo, cli);
+            }
+        }
+        else {
             if (!flags.username) {
-                let { username } = await inquirer.prompt({
+                const { username } = await inquirer.prompt({
                     type: 'input',
-                    message: 'Enter your username:',
+                    message: 'Email address:',
                     name: 'username',
                     validate(input) {
                         if (input.length === 0) {
-                            return false;
+                            return 'Email address cannot be empty';
+                        }
+                        // Basic email validation
+                        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                        if (!emailRegex.test(input)) {
+                            return 'Please enter a valid email address';
                         }
                         return true;
                     }
@@ -34,57 +91,48 @@ export default class Login extends Command {
                 body.username = username;
             }
             if (!flags.password) {
-                let { password } = await inquirer.prompt({
+                const { password } = await inquirer.prompt({
                     type: 'password',
                     name: 'password',
-                    message: 'Enter your password:',
+                    message: 'Password:',
                     validate(input) {
                         if (input.length === 0) {
-                            return false;
+                            return 'Password cannot be empty';
                         }
                         return true;
                     }
                 });
                 body.password = password;
             }
-            const { data } = await axios.post("accounts/login/", body, this.axiosConfig);
-            if (data.success) {
-                if (!isObject(config_json.users)) {
-                    config_json.users = {};
-                }
-                // @ts-ignore
-                config_json.users[body.username] = {
-                    "token": data.token
-                };
-                config_json["default_user"] = body.username;
-                this.write_config(config_json);
-                cli.log(`${chalk.green('[Success]')} you are logged in successfully.`);
-            }
-            else {
-                cli.log(`${chalk.red('[Error]')} your username or password is wrong!`);
+            if (!body.username || !body.password) {
+                cli.log(ui.error('Both an email address and a password are required.'));
+                return;
             }
-        }
-        else {
             try {
-                this.axiosConfig.headers.Authorization = `Token ${flags.token}`;
-                const { data } = await axios.get("accounts/info/", this.axiosConfig);
-                if (!isObject(config_json.users)) {
-                    config_json.users = {};
+                const { data } = await axios.post("accounts/login/", body, this.axiosConfig);
+                if (data.success && data.token) {
+                    if (!isObject(config_json.users)) {
+                        config_json.users = {};
+                    }
+                    config_json.users[body.username] = {
+                        token: data.token
+                    };
+                    config_json.default_user = body.username;
+                    await this.write_config(config_json);
+                    cli.log(ui.success(`Signed in as ${ui.value(body.username)}.`));
+                    cli.log(ui.hint(`See what you can reach with ${ui.cmd('chabok service list')}`));
                 }
-                // @ts-ignore
-                config_json.users[data.user.email] = {
-                    "token": flags.token
-                };
-                config_json["default_user"] = data.user.email;
-                await this.write_config(config_json);
-                cli.log(`${chalk.green('[Success]')} you are logged in successfully.`);
-            }
-            catch (e) {
-                if (process.env.CHABOK_DEBUG == "true") {
-                    // @ts-ignore
-                    cli.log(e);
+                else {
+                    cli.log(ui.error('That email address and password did not match an account.'));
                 }
-                cli.log(`${chalk.red('[Error]')} your token is wrong!`);
+            }
+            catch (error) {
+                const errorInfo = handleApiError(error, 'Sign-in failed. Check your credentials and try again.', {
+                    endpoint: 'accounts/login/',
+                    operation: 'Login'
+                });
+                cli.log(ui.error(errorInfo.message));
+                logErrorDetails(errorInfo, cli);
             }
         }
     }

package/dist/commands/service/domain/add.d.ts

@@ -0,0 +1,15 @@
+import Command from "../../../base.js";
+export default class ServiceDomainAdd extends Command {
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        service: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+    };
+    run(): Promise<void>;
+    send_request(cli: Command, selected_service: string, domain_name: string): Promise<void>;
+}

package/dist/commands/service/domain/add.js

@@ -0,0 +1,74 @@
+import { Flags } from '@oclif/core';
+import Command from "../../../base.js";
+import { handleApiError, logErrorDetails } from "../../../helper.js";
+import * as ui from "../../../ui.js";
+import inquirer from 'inquirer';
+import axios from "axios";
+export default class ServiceDomainAdd extends Command {
+    static description = 'connect a custom domain to a service';
+    static examples = [
+        {
+            description: 'Pick the service and enter the domain interactively',
+            command: '<%= config.bin %> service domain add',
+        },
+        {
+            description: 'Connect a domain in one non-interactive command',
+            command: '<%= config.bin %> service domain add -s my-app -d www.example.com',
+        },
+    ];
+    static flags = {
+        ...Command.flags,
+        service: Flags.string({ char: 's', description: 'name of the service to connect the domain to' }),
+        domain: Flags.string({ char: 'd', description: 'domain name to connect, e.g. www.example.com' }),
+    };
+    async run() {
+        const { flags } = await this.parse(ServiceDomainAdd);
+        const cli = this;
+        await this.init_run();
+        if (!(await this.require_login())) {
+            return;
+        }
+        const selected_service = await this.select_service(flags.service, {}, 'Connect Domain');
+        if (!selected_service) {
+            return;
+        }
+        let domain_name = flags.domain;
+        if (!domain_name) {
+            ({ domain_name } = await inquirer.prompt({
+                type: 'input',
+                message: 'Domain name:',
+                name: 'domain_name',
+                validate(input) {
+                    return input.trim().length > 0 || 'Domain name cannot be empty';
+                },
+            }));
+        }
+        await this.send_request(cli, selected_service, domain_name.trim());
+    }
+    async send_request(cli, selected_service, domain_name) {
+        try {
+            const { data } = await axios.post(`services/${selected_service}/domain/`, { domain_name }, this.axiosConfig);
+            if (data.success === false) {
+                cli.log(ui.error(`Could not connect ${ui.value(domain_name)}. ${data.message || 'Check the domain name and try again.'}`));
+                return;
+            }
+            cli.log(ui.success(`Connected ${ui.value(domain_name)} to ${ui.value(selected_service)}.`));
+            cli.log(ui.hint('Point the domain\'s DNS records at Chabokan for it to start serving traffic'));
+        }
+        catch (error) {
+            const errorInfo = handleApiError(error, 'Failed to connect domain.', {
+                endpoint: `services/${selected_service}/domain/`,
+                serviceName: selected_service,
+                operation: 'Connect Domain'
+            });
+            if (errorInfo.status === 404) {
+                cli.log(ui.error(`Service ${ui.value(selected_service)} was not found.`));
+                cli.log(ui.hint(`Check the available names with ${ui.cmd('chabok service list')}`));
+            }
+            else {
+                cli.log(ui.error(errorInfo.message));
+            }
+            logErrorDetails(errorInfo, cli);
+        }
+    }
+}