@albinberisha/codex-cli/src/utils/queries.js

Codex cli to scaffold plugins with Node

import axios from 'axios'
import { createSpinner } from 'nanospinner';
import { getEnvParams } from '../envParams.js';
import path from 'path'
import { returnFailedMessage } from './returnMessage.js';
import helpers from '../helpers/index.js'

// process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';

async function getFilePaths() {
    const envParams = await getEnvParams();
    const spinner = createSpinner('Fetching templates...').start();

    try {
        const res = await axios.get(`${envParams.baseUrl}/api/template/default`, {
            headers: envParams.headers
        });

        spinner.success({
            text: 'Templates fetched successfully.',
        })

        return res.data;
    } catch (error) {
        spinner.error({
            text: "Failed fetching templates."
        });
        returnFailedMessage(error);
        process.exit(1);
    }
}


async function getFileFromUrl(filePath) {
    const spinner = createSpinner(`Fetching file: ${path.basename(filePath)}`).start();

    try {
        const res = await axios({
            method: "get",
            url: filePath,
            responseType: "stream"
        });

        spinner.success({
            text: `Successfully fetched file: ${path.basename(filePath)}`,
        })

        return res.data;
    } catch (error) {
        spinner.error({
            text: `Failed fetching file: ${path.basename(filePath)}`
        });
        returnFailedMessage(error);
        process.exit(1);
    }
}

async function createSession() {
    const envParams = await getEnvParams();
    const spinner = createSpinner(`Creating a session...`).start();

    try {
        const res = await axios.post(`${envParams.baseUrl}/api/session`,
            { id: envParams.sessionId },
            { headers: envParams.headers }
        );

        if (!res.data.success) {
            throw ('');
        }

        spinner.success({
            text: `[${getCurrentDateTime()}]: Session created successfully.`,
        })

        return res.data;
    } catch (error) {
        spinner.error({
            text: `[${getCurrentDateTime()}]: Failed creating session.`
        });
        returnFailedMessage(error);
        process.exit(1);
    }
}

async function terminateSession() {
    const envParams = await getEnvParams();
    const spinner = createSpinner(`Terminating session...`).start();

    try {
        const res = await axios.put(`${envParams.baseUrl}/api/session/${envParams.sessionId}`,
            {
                id: envParams.sessionId,
                status: 3
            },
            { headers: envParams.headers }
        );

        spinner.success({
            text: `[${getCurrentDateTime()}]: Session terminated.`,
        })

        return res.data;
    } catch (error) {
        spinner.error({
            text: `[${getCurrentDateTime()}]: Failed terminating session.`
        });
        returnFailedMessage(error);
        process.exit(1);
    }
}

async function deleteFile(query) {
    const envParams = await getEnvParams();
    const spinner = createSpinner(`Deleting file: ${query.path}...`).start();

    try {
        const res = await axios.delete(`${envParams.baseUrl}/api/filemanager/delete-file/${envParams.sessionId}?path=${query.path}`, {
            headers: envParams.headers
        });

        spinner.success({
            text: `[${getCurrentDateTime()}]: File deleted successfully: ${query.path}`,
        })

        return res.data;
    } catch (error) {
        spinner.error({
            text: `[${getCurrentDateTime()}]: Failed deleting file: ${query.path}`,
        });
        returnFailedMessage(error);
        process.exit(1);
    }
}

async function deleteDirectory(query) {
    const envParams = await getEnvParams();
    const spinner = createSpinner(`Deleting file: ${query.path}...`).start();

    try {
        const res = await axios.delete(`${envParams.baseUrl}/api/filemanager/delete-dir/${envParams.sessionId}?path=${query.path}`, {
            headers: envParams.headers
        });

        spinner.success({
            text: `[${getCurrentDateTime()}]: Directory deleted successfully: ${query.path}`,
        })

        return res.data;
    } catch (error) {
        spinner.error({
            text: `[${getCurrentDateTime()}]: Failed deleting directory: ${query.path}`,
        });
        returnFailedMessage(error);
        process.exit(1);
    }
}

async function uploadFile(query, form) {
    const envParams = await getEnvParams();

    const formHeaders = {
        ...envParams.headers,
        "Content-Type": "multipart/form-data",
    };

    const spinner = createSpinner(`Uploading file ${query.path} ...`).start();

    const fileUploadProgress = (progress) => {
        let percentage = Math.floor((progress.loaded * 100) / progress.total)

        spinner.update({
            text: `Uploading file ${query.path} - ${percentage}% uploaded...`,
        })
    }

    try {
        const res = await axios.put(`${envParams.baseUrl}/api/filemanager/upload-file/${envParams.sessionId}?path=${query.path}`,
            form,
            {
                headers: formHeaders,
                // onUploadProgress: fileUploadProgress
            }
        );

        spinner.success({
            text: `[${getCurrentDateTime()}]: File uploaded successfully: ${query.path}`,
        })

        return res.data;
    } catch (error) {
        console.log(error)
        spinner.error({
            text: `[${getCurrentDateTime()}]: Failed uploading file: ${query.path}`,
        });
        returnFailedMessage(error);
        process.exit(1);
    }
}

async function createDirectory(query) {
    const envParams = await getEnvParams();
    const spinner = createSpinner(`Creating directory: ${query.path}...`).start();

    try {
        const res = await axios.post(`${envParams.baseUrl}/api/filemanager/create-dir/${envParams.sessionId}?path=${query.path}`, {}, {
            headers: envParams.headers
        });

        spinner.success({
            text: `[${getCurrentDateTime()}]: Directory created successfully: ${query.path}`,
        })

        return res.data;
    } catch (error) {
        spinner.error({
            text: `[${getCurrentDateTime()}]: Failed creating directory: ${query.path}`,
        });
        returnFailedMessage(error);
        process.exit(1);
    }
}

function getCurrentDateTime() {
    return helpers.formatDateTime(new Date());
}

export default {
    getFilePaths,
    getFileFromUrl,
    createSession,
    terminateSession,
    deleteFile,
    deleteDirectory,
    uploadFile,
    createDirectory
}