@dainprotocol/cli 1.0.43 → 1.0.45

package/README.md

@@ -15,3 +15,71 @@ npm install @dainprotocol/cli -g
 For detailed documentation, usage guides, and additional information, please visit:
 [https://docs.dain.org](https://docs.dain.org)
 
+## Usage
+
+```bash
+dain --help
+```
+
+## Init
+
+```bash
+dain init <project-name>
+```
+
+The following commands require a dain.json file to be present in the root of the project with the following structure:
+
+```json
+{
+  "out-dir": "your-build-output-directory(build/dist)",
+  "main-file": "your-main-file.(ts/js)",
+  "deployment-id": "your deploymentId that you will have after the deploy",
+  "api-key": "your-api-key"
+}
+```
+
+## Build
+
+```bash
+dain build
+```
+
+## Dev
+
+```bash
+dain dev
+```
+
+### Deploy
+
+An .env file must be present in the root of the project with the following variables:
+
+```bash
+DAIN_API_KEY=your_api_key
+```
+
+To deploy the project, run the following command:
+
+```bash
+dain deploy
+```
+
+### Status
+
+```bash
+dain status
+```
+
+### Logs
+
+```bash
+dain logs [-w|--watch]
+```
+
+The `-w` or `--watch` parameter allows you to monitor logs in real time.
+
+### Undeploy
+
+```bash
+dain undeploy
+```

package/dist/commands/build.js

@@ -77,7 +77,7 @@ function build(options) {
                     spinner = (0, ora_1.default)('Building project...').start();
                     config = (0, utils_1.getDainConfig)(options.config);
                     runtime = options.runtime || config.runtime || 'node';
-                    outDir = config['out-dir'] || 'build';
+                    outDir = path_1.default.join(process.cwd(), config['out-dir'] || 'build');
                     dainDir = path_1.default.join(process.cwd(), '.dain');
                     _a.label = 1;
                 case 1:
@@ -91,13 +91,13 @@ function build(options) {
                         entryPoints: [config['main-file']],
                         bundle: true,
                         sourcemap: true,
-                        outdir: options.watch ? dainDir : outDir,
+                        outdir: outDir,
                     };
                     if (runtime === 'node') {
                         // Node.js build process
                         Object.assign(buildOptions, {
                             platform: 'node',
-                            target: 'node14',
+                            target: 'es2020',
                             minify: !options.watch,
                         });
                     }
@@ -140,16 +140,16 @@ function build(options) {
                     return [4 /*yield*/, fs_extra_1.default.copy(staticDir, staticOutDir)];
                 case 9:
                     _a.sent();
-                    (0, utils_1.logInfo)("Static files copied to ".concat(staticOutDir));
+                    spinner.info("Static files copied to ".concat(staticOutDir));
                     return [3 /*break*/, 11];
                 case 10:
-                    (0, utils_1.logInfo)('No static directory found. Skipping static file copy.');
+                    spinner.info('No static directory found. Skipping static file copy.');
                     _a.label = 11;
                 case 11:
-                    spinner.succeed('Build completed successfully.');
-                    (0, utils_1.logSuccess)("Project built and ready for ".concat(runtime, " runtime in ").concat(options.watch ? dainDir : outDir, "."));
+                    spinner.info('Build completed successfully.');
+                    spinner.info("Project built and ready for ".concat(runtime, " runtime in ").concat(options.watch ? dainDir : outDir, "."));
                     // Explicitly exit with success if not in watch mode
-                    if (!options.watch) {
+                    if (!options.watch && !options.deploy) {
                         process.exit(0);
                     }
                     return [3 /*break*/, 13];

package/dist/commands/deploy.js

@@ -40,89 +40,190 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = deploy;
-var build_1 = __importDefault(require("./build"));
 var utils_1 = require("../utils");
 var ora_1 = __importDefault(require("ora"));
 var fs_extra_1 = __importDefault(require("fs-extra"));
 var path_1 = __importDefault(require("path"));
+var archiver_1 = __importDefault(require("archiver"));
+var build_1 = __importDefault(require("./build"));
+var status_1 = __importDefault(require("./status"));
+var START_DEPLOY_URI = '/api/app/data/deployments/start-deploy';
 function deploy(options) {
     return __awaiter(this, void 0, void 0, function () {
-        var config, spinner, outDir_1, platformBaseUrl, deployUrl, files, deployFiles, deployData, response, result, error_1;
-        var _this = this;
+        var config, spinner, basePath, deployPath, envArray, result, deploymentId, error_1;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     config = (0, utils_1.getDainConfig)(options.config);
-                    // disable for now only availible for internal testing for now
-                    (0, utils_1.logError)("Deployment is not supported for now. Only available for internal testing.");
-                    return [2 /*return*/, process.exit(1)];
+                    spinner = (0, ora_1.default)('Deploying project...').start();
+                    basePath = config['api-base-url'] || 'https://dain-platform-ochre.vercel.app';
+                    deployPath = "".concat(basePath).concat(START_DEPLOY_URI);
+                    _a.label = 1;
                 case 1:
-                    _a.trys.push([1, 7, , 8]);
-                    // First, build the project
-                    return [4 /*yield*/, (0, build_1.default)({ config: options.config })];
+                    _a.trys.push([1, 6, , 7]);
+                    return [4 /*yield*/, loadAndValidateEnvVariables()];
                 case 2:
-                    // First, build the project
-                    _a.sent();
-                    outDir_1 = config['out-dir'] || 'build';
-                    platformBaseUrl = config['platform-base-url'] || 'https://platform.dain.org';
-                    deployUrl = "".concat(platformBaseUrl, "/api/platform-api/v1/service/deploy");
-                    return [4 /*yield*/, fs_extra_1.default.readdir(outDir_1)];
+                    envArray = _a.sent();
+                    return [4 /*yield*/, (0, build_1.default)({ config: options.config, deploy: true })];
                 case 3:
-                    files = _a.sent();
-                    return [4 /*yield*/, Promise.all(files.map(function (file) { return __awaiter(_this, void 0, void 0, function () {
-                            var fileType, content;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        fileType = path_1.default.extname(file).slice(1);
-                                        if (!['js', 'mjs', 'wasm'].includes(fileType)) return [3 /*break*/, 2];
-                                        return [4 /*yield*/, fs_extra_1.default.readFile(path_1.default.join(outDir_1, file), 'utf-8')];
-                                    case 1:
-                                        content = _a.sent();
-                                        return [2 /*return*/, {
-                                                name: file,
-                                                content: content,
-                                                type: fileType,
-                                            }];
-                                    case 2: return [2 /*return*/, null];
-                                }
-                            });
-                        }); })).then(function (files) { return files.filter(Boolean); })];
+                    _a.sent();
+                    return [4 /*yield*/, deployAndPushFiles(deployPath, envArray)];
                 case 4:
-                    deployFiles = _a.sent();
-                    deployData = {
-                        serviceIdentifer: config['project-id'],
-                        files: deployFiles,
-                    };
-                    return [4 /*yield*/, fetch(deployUrl, {
+                    result = _a.sent();
+                    deploymentId = result.deploymentId.replace('codegen-', '');
+                    return [4 /*yield*/, recursiveStatusUntilRunning(JSON.stringify(config), deploymentId)];
+                case 5:
+                    _a.sent();
+                    console.log('\n-----------------------');
+                    spinner.succeed("Deployment URL: ".concat(result.service.url));
+                    spinner.succeed("Deployment ID: ".concat(result.deploymentId));
+                    spinner.succeed('Deployment completed at: ' + new Date().toISOString());
+                    spinner.succeed('Deployment completed successfully.');
+                    spinner.info('You can access logs using `dain logs -w` command.');
+                    console.log('-----------------------');
+                    process.exit(0);
+                    return [3 /*break*/, 7];
+                case 6:
+                    error_1 = _a.sent();
+                    spinner.fail('Deployment failed.');
+                    (0, utils_1.logError)('Error during deployment: ', error_1);
+                    process.exit(1);
+                    return [3 /*break*/, 7];
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+}
+// Loads and validates environment variables
+function loadAndValidateEnvVariables() {
+    return __awaiter(this, void 0, void 0, function () {
+        var envArray;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, loadEnvVariables()];
+                case 1:
+                    envArray = _a.sent();
+                    if (envArray.length === 0) {
+                        (0, utils_1.logError)('No environment variables found. Please ensure your .env file is correctly set up.');
+                        process.exit(1);
+                    }
+                    if (!envArray.some(function (env) { return env.name === 'DAIN_API_KEY'; })) {
+                        (0, utils_1.logError)('DAIN_API_KEY not found in environment variables. Please check your .env file.');
+                        process.exit(1);
+                    }
+                    return [2 /*return*/, envArray];
+            }
+        });
+    });
+}
+// Deploys and pushes files to the platform
+function deployAndPushFiles(startDeployUrl, envArray) {
+    return __awaiter(this, void 0, void 0, function () {
+        var projectZip, projectZipBuffer, formData, response, errorText, result, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, zipDirectory('./', 'project.zip')];
+                case 1:
+                    projectZip = _a.sent();
+                    return [4 /*yield*/, fs_extra_1.default.readFile(projectZip)];
+                case 2:
+                    projectZipBuffer = _a.sent();
+                    formData = new FormData();
+                    formData.append('array', JSON.stringify(envArray));
+                    formData.append('file', new Blob([projectZipBuffer]), 'project.zip');
+                    _a.label = 3;
+                case 3:
+                    _a.trys.push([3, 8, , 9]);
+                    return [4 /*yield*/, fetch(startDeployUrl, {
                             method: 'POST',
-                            headers: {
-                                'Content-Type': 'application/json',
-                                "X-DAIN-SIGNATORY-ADDRESS": "TODO: X-DAIN-SIGNATORY-ADDRESS",
-                                "X-DAIN-SIGNATURE": "TODO: X-DAIN-SIGNATORY-SIGNATURE",
-                            },
-                            body: JSON.stringify(deployData),
+                            body: formData,
                         })];
-                case 5:
+                case 4:
                     response = _a.sent();
-                    if (!response.ok) {
-                        throw new Error("Deployment failed: ".concat(response.statusText));
-                    }
-                    return [4 /*yield*/, response.json()];
-                case 6:
-                    result = _a.sent();
-                    (0, utils_1.logSuccess)("Deployment completed successfully.");
-                    spinner.succeed("Deployment completed successfully.");
-                    (0, utils_1.logInfo)("Deployment result: ".concat(JSON.stringify(result, null, 2)));
-                    return [3 /*break*/, 8];
+                    if (!!response.ok) return [3 /*break*/, 6];
+                    return [4 /*yield*/, response.text()];
+                case 5:
+                    errorText = _a.sent();
+                    throw new Error("Deployment failed: ".concat(response.statusText, ". Response: ").concat(errorText));
+                case 6: return [4 /*yield*/, response.json()];
                 case 7:
-                    error_1 = _a.sent();
-                    spinner.fail("Deployment failed.");
-                    (0, utils_1.logError)("Error during deployment", error_1);
+                    result = _a.sent();
+                    return [2 /*return*/, result];
+                case 8:
+                    error_2 = _a.sent();
+                    (0, utils_1.logError)('Error during deployment and push files: ', error_2.stack);
+                    console.error('Detailed error:', error_2);
                     process.exit(1);
-                    return [3 /*break*/, 8];
-                case 8: return [2 /*return*/];
+                    return [3 /*break*/, 9];
+                case 9: return [2 /*return*/];
+            }
+        });
+    });
+}
+// Reads the .env file and returns an array of key-value pairs
+function loadEnvVariables() {
+    return __awaiter(this, void 0, void 0, function () {
+        var files, envFile, envContent;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fs_extra_1.default.readdir('./')];
+                case 1:
+                    files = _a.sent();
+                    envFile = files.find(function (file) { return file === '.env'; });
+                    if (!envFile) {
+                        (0, utils_1.logError)('Environment file not found. Please create a .env file in the build directory.');
+                        process.exit(1);
+                    }
+                    return [4 /*yield*/, fs_extra_1.default.readFile(path_1.default.join('./', envFile), 'utf-8')];
+                case 2:
+                    envContent = _a.sent();
+                    return [2 /*return*/, envContent
+                            .split('\n')
+                            .map(function (line) {
+                            var _a = line.split('='), name = _a[0], value = _a[1];
+                            return { name: name, value: value };
+                        })
+                            .filter(function (env) { return env.name && env.value; })];
             }
         });
     });
 }
+// Zips the current directory and returns the path to the zip file
+function zipDirectory(sourceDir, outputZip) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, new Promise(function (resolve, reject) {
+                    var output = fs_extra_1.default.createWriteStream(outputZip);
+                    var archive = (0, archiver_1.default)('zip', { zlib: { level: 9 } });
+                    output.on('close', function () { return resolve(outputZip); });
+                    archive.on('error', function (err) {
+                        (0, utils_1.logError)('Error during zipping the directory: ', err);
+                        reject(err);
+                    });
+                    archive.pipe(output);
+                    archive.glob('**/*', { ignore: ['node_modules/**', 'project.zip'] });
+                    archive.finalize();
+                })];
+        });
+    });
+}
+var recursiveStatusUntilRunning = function (config, deploymentId) { return __awaiter(void 0, void 0, void 0, function () {
+    var statusResult;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, status_1.default)({}, deploymentId)];
+            case 1:
+                statusResult = _a.sent();
+                if (statusResult.status === 'RUNNING') {
+                    return [2 /*return*/];
+                }
+                return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1000); })];
+            case 2:
+                _a.sent();
+                return [4 /*yield*/, recursiveStatusUntilRunning(config, deploymentId)];
+            case 3:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };

package/dist/commands/dev.js

@@ -106,16 +106,16 @@ function dev(options) {
             switch (_a.label) {
                 case 0:
                     config = (0, utils_1.getDainConfig)(options.config);
-                    console.log("Config: " + JSON.stringify(config));
+                    console.log('Config: ' + JSON.stringify(config));
                     runtime = options.runtime || config.runtime || 'node';
-                    console.log("Runtime: " + runtime);
-                    command = "ts-node ".concat(config['main-file']);
+                    console.log('Runtime: ' + runtime);
+                    command = "./node_modules/.bin/ts-node ".concat(config['main-file']);
                     envVars = {
                         PORT: options.port,
                         DAIN_API_KEY: config['api-key'],
                         DAIN_PROJECT_ID: config['project-id'],
                         DAIN_ENVIRONMENT: config['environment'],
-                        DAIN_OUT_DIR: config['out-dir']
+                        DAIN_OUT_DIR: config['out-dir'],
                     };
                     proxyServer = null;
                     _a.label = 1;
@@ -135,11 +135,13 @@ function dev(options) {
                     startProcess(command, envVars);
                     watchPaths = [
                         path_1.default.dirname(config['main-file']),
-                        config['static-dir'] ? path_1.default.join(process.cwd(), config['static-dir']) : (0, utils_1.getStaticFilesPath)()
+                        config['static-dir']
+                            ? path_1.default.join(process.cwd(), config['static-dir'])
+                            : (0, utils_1.getStaticFilesPath)(),
                     ];
                     watcher = chokidar_1.default.watch(watchPaths, {
                         ignored: /(^|[\/\\])\../, // ignore dotfiles
-                        persistent: true
+                        persistent: true,
                     });
                     watcher.on('change', function (path) {
                         (0, utils_1.logInfo)("File ".concat(path, " has been changed. Restarting..."));
@@ -204,7 +206,7 @@ function dev(options) {
                     dainDir = path_1.default.join(process.cwd(), '.dain');
                     outFile = path_1.default.join(dainDir, path_1.default.basename(config['main-file'], '.ts') + '.mjs');
                     // Start the build process in watch mode
-                    return [4 /*yield*/, (0, build_1.default)({ config: options.config, runtime: 'workers', watch: true, })];
+                    return [4 /*yield*/, (0, build_1.default)({ config: options.config, runtime: 'workers', watch: true })];
                 case 5:
                     // Start the build process in watch mode
                     _a.sent();

package/dist/commands/help.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = help;
+function help() {
+    console.log("\n  Usage: dain [command] [options]\n\n  Options:\n    -w, --watch                                                   monitor logs in real time\n\n  Commands:\n    init                                                          initialize the project\n    build                                                         build the project\n    dev                                                           run the project in development mode\n    deploy                                                        deploy the project\n    status                                                        display the project status\n    logs [-w|--watch]                                             monitor logs in real time\n    undeploy                                                      undeploy the project\n  ");
+    process.exit(0);
+}

package/dist/commands/logs.js

@@ -0,0 +1,174 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = logs;
+var ora_1 = __importDefault(require("ora"));
+var utils_1 = require("../utils");
+function logs(options_1) {
+    return __awaiter(this, arguments, void 0, function (options, isWatching) {
+        var config, _a, apiKey, deploymentId, logsUrl, orgId, spinner, result, formatLogs, error_1;
+        if (isWatching === void 0) { isWatching = false; }
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    config = (0, utils_1.getDainConfig)(options.config);
+                    _a = initializeConfig(config), apiKey = _a.apiKey, deploymentId = _a.deploymentId, logsUrl = _a.logsUrl;
+                    orgId = 'hackathon';
+                    if (!orgId || !deploymentId) {
+                        (0, utils_1.logError)('Org ID or deployment ID not found');
+                        return [2 /*return*/];
+                    }
+                    spinner = (0, ora_1.default)("Fetching logs for project ".concat(config['project-id'], "...")).start();
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, 4, 5]);
+                    result = null;
+                    return [4 /*yield*/, fetchLogs(logsUrl, apiKey)];
+                case 2:
+                    result = _b.sent();
+                    formatLogs = formatProjectLogs(result, deploymentId);
+                    if (isWatching) {
+                        // clear terminal before printing logs when watching
+                        process.stdout.write('\x1Bc');
+                    }
+                    (0, utils_1.logInfo)("Project logs: ".concat(formatLogs));
+                    if (options.watch) {
+                        setTimeout(function () { return logs(options, true); }, 10000);
+                    }
+                    if (!options.watch) {
+                        process.exit(0);
+                    }
+                    return [3 /*break*/, 5];
+                case 3:
+                    error_1 = _b.sent();
+                    handleError(spinner, error_1);
+                    return [3 /*break*/, 5];
+                case 4:
+                    spinner.stop();
+                    return [7 /*endfinally*/];
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
+var initializeConfig = function (config) {
+    var baseUrl = config['platform-base-url'] || 'https://codegen-deploy-service.dainapp.com/';
+    var apiKey = config['api-key'];
+    var orgId = (0, utils_1.extractOrgId)(apiKey);
+    var deploymentId = config['deployment-id'];
+    var logsUrl = "".concat(baseUrl, "/codegen-deploy/logs/").concat(orgId, "/").concat(deploymentId);
+    return { baseUrl: baseUrl, apiKey: apiKey, orgId: orgId, deploymentId: deploymentId, logsUrl: logsUrl };
+};
+var fetchLogs = function (logsUrl, apiKey) { return __awaiter(void 0, void 0, void 0, function () {
+    var response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fetch(logsUrl, {
+                    method: 'GET',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-DAIN-SIGNATORY-ADDRESS': 'TODO: X-DAIN-SIGNATORY-ADDRESS',
+                        'X-DAIN-SIGNATURE': 'TODO: X-DAIN-SIGNATORY-SIGNATURE',
+                        Authorization: "Bearer ".concat(apiKey),
+                    },
+                })];
+            case 1:
+                response = _a.sent();
+                if (!response.ok) {
+                    throw new Error("Log fetch failed: ".concat(response.statusText));
+                }
+                return [4 /*yield*/, response.json()];
+            case 2: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+var handleError = function (spinner, error) {
+    spinner.fail('Failed to retrieve project logs.');
+    (0, utils_1.logError)('Error during log fetch', error);
+};
+var formatProjectLogs = function (projectLogs, deploymentId) {
+    try {
+        var _a = projectLogs.logs, logs_1 = _a === void 0 ? '' : _a, metadata = __rest(projectLogs, ["logs"]);
+        var formatDate_1 = function (dateString) {
+            try {
+                return new Date(dateString).toLocaleString();
+            }
+            catch (_a) {
+                return dateString;
+            }
+        };
+        var formattedMetadata = Object.entries(metadata)
+            .map(function (_a) {
+            var _b;
+            var key = _a[0], value = _a[1];
+            var formattedValue = ((_b = value === null || value === void 0 ? void 0 : value.includes) === null || _b === void 0 ? void 0 : _b.call(value, 'T'))
+                ? formatDate_1(value)
+                : value;
+            var formattedKey = key.replace(/([A-Z])/g, ' $1').toLowerCase();
+            return "\u001B[36m".concat(formattedKey, ":\u001B[0m ").concat(formattedValue);
+        })
+            .join('\n');
+        var projectUrl = "\nurl: https://".concat(deploymentId.replace('codegen-', ''), "-agent.dainapp.com");
+        var output = [
+            '\n',
+            '\x1b[1m=== Project ===\x1b[0m',
+            formattedMetadata,
+            projectUrl,
+            '\n\x1b[1m=== Logs ===\x1b[0m',
+            logs_1,
+        ];
+        return output.join('\n');
+    }
+    catch (error) {
+        return "Error formatting logs: ".concat(error.message);
+    }
+};