@dainprotocol/cli 1.2.28 → 1.2.31

package/dist/__tests__/utils.test.js

@@ -0,0 +1,324 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../utils");
+var path_1 = __importDefault(require("path"));
+describe('normalizeBaseUrl', function () {
+    describe('trailing slash handling', function () {
+        test('removes single trailing slash', function () {
+            expect((0, utils_1.normalizeBaseUrl)('https://example.com/')).toBe('https://example.com');
+        });
+        test('removes multiple trailing slashes', function () {
+            expect((0, utils_1.normalizeBaseUrl)('https://example.com///')).toBe('https://example.com');
+        });
+        test('handles URL without trailing slash', function () {
+            expect((0, utils_1.normalizeBaseUrl)('https://example.com')).toBe('https://example.com');
+        });
+        test('preserves path while removing trailing slash', function () {
+            expect((0, utils_1.normalizeBaseUrl)('https://example.com/api/v1/')).toBe('https://example.com/api/v1');
+        });
+    });
+    describe('protocol handling', function () {
+        test('handles https protocol', function () {
+            expect((0, utils_1.normalizeBaseUrl)('https://example.com')).toBe('https://example.com');
+        });
+        test('handles http protocol', function () {
+            expect((0, utils_1.normalizeBaseUrl)('http://example.com')).toBe('http://example.com');
+        });
+        test('handles wss protocol', function () {
+            expect((0, utils_1.normalizeBaseUrl)('wss://tunnel.example.com')).toBe('wss://tunnel.example.com');
+        });
+        test('handles ws protocol', function () {
+            expect((0, utils_1.normalizeBaseUrl)('ws://localhost:3000')).toBe('ws://localhost:3000');
+        });
+        test('fixes malformed triple-slash URLs', function () {
+            expect((0, utils_1.normalizeBaseUrl)('wss:///tunnel.dain-local.com')).toBe('wss://tunnel.dain-local.com');
+        });
+    });
+    describe('edge cases', function () {
+        test('handles empty string', function () {
+            expect((0, utils_1.normalizeBaseUrl)('')).toBe('');
+        });
+        test('handles whitespace-only string', function () {
+            expect((0, utils_1.normalizeBaseUrl)('   ')).toBe('');
+        });
+        test('trims whitespace', function () {
+            expect((0, utils_1.normalizeBaseUrl)('  https://example.com  ')).toBe('https://example.com');
+        });
+        test('handles localhost with port', function () {
+            expect((0, utils_1.normalizeBaseUrl)('http://localhost:3000/')).toBe('http://localhost:3000');
+        });
+        test('handles URL with query params', function () {
+            expect((0, utils_1.normalizeBaseUrl)('https://example.com/api?key=value/')).toBe('https://example.com/api?key=value');
+        });
+        test('handles invalid URL gracefully (no protocol)', function () {
+            // Falls back to string manipulation when URL parsing fails
+            expect((0, utils_1.normalizeBaseUrl)('example.com///')).toBe('example.com');
+        });
+        test('handles URL with auth credentials', function () {
+            expect((0, utils_1.normalizeBaseUrl)('https://user:pass@example.com/')).toBe('https://user:pass@example.com');
+        });
+    });
+});
+describe('joinUrl', function () {
+    describe('slash normalization', function () {
+        test('joins base with trailing slash and path with leading slash', function () {
+            expect((0, utils_1.joinUrl)('https://example.com/', '/api/test')).toBe('https://example.com/api/test');
+        });
+        test('joins base without trailing slash and path with leading slash', function () {
+            expect((0, utils_1.joinUrl)('https://example.com', '/api/test')).toBe('https://example.com/api/test');
+        });
+        test('joins base with trailing slash and path without leading slash', function () {
+            expect((0, utils_1.joinUrl)('https://example.com/', 'api/test')).toBe('https://example.com/api/test');
+        });
+        test('joins base without trailing slash and path without leading slash', function () {
+            expect((0, utils_1.joinUrl)('https://example.com', 'api/test')).toBe('https://example.com/api/test');
+        });
+        test('handles multiple leading slashes in path', function () {
+            expect((0, utils_1.joinUrl)('https://example.com', '///api/test')).toBe('https://example.com/api/test');
+        });
+    });
+    describe('path handling', function () {
+        test('handles empty path', function () {
+            expect((0, utils_1.joinUrl)('https://example.com', '')).toBe('https://example.com/');
+        });
+        test('handles complex nested paths', function () {
+            expect((0, utils_1.joinUrl)('https://example.com/v1', '/users/123/profile')).toBe('https://example.com/v1/users/123/profile');
+        });
+        test('preserves query parameters in path', function () {
+            expect((0, utils_1.joinUrl)('https://example.com', '/api?foo=bar')).toBe('https://example.com/api?foo=bar');
+        });
+    });
+});
+describe('parseEnvContent', function () {
+    describe('basic parsing', function () {
+        test('parses simple key=value pairs', function () {
+            var content = 'FOO=bar\nBAZ=qux';
+            var result = (0, utils_1.parseEnvContent)(content);
+            expect(result).toEqual([
+                { name: 'FOO', value: 'bar' },
+                { name: 'BAZ', value: 'qux' },
+            ]);
+        });
+        test('handles single variable', function () {
+            var result = (0, utils_1.parseEnvContent)('SINGLE=value');
+            expect(result).toEqual([{ name: 'SINGLE', value: 'value' }]);
+        });
+        test('handles empty content', function () {
+            expect((0, utils_1.parseEnvContent)('')).toEqual([]);
+        });
+    });
+    describe('special values', function () {
+        test('preserves values with = signs (base64)', function () {
+            var content = 'JWT_SECRET=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.test==';
+            var result = (0, utils_1.parseEnvContent)(content);
+            expect(result[0].value).toBe('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.test==');
+        });
+        test('preserves URLs with query params', function () {
+            var content = 'DATABASE_URL=postgresql://user:pass@host:5432/db?sslmode=require';
+            var result = (0, utils_1.parseEnvContent)(content);
+            expect(result[0].value).toBe('postgresql://user:pass@host:5432/db?sslmode=require');
+        });
+        test('handles values with spaces', function () {
+            var content = 'MESSAGE=Hello World';
+            var result = (0, utils_1.parseEnvContent)(content);
+            expect(result[0].value).toBe('Hello World');
+        });
+        test('handles quoted values', function () {
+            var content = 'QUOTED="hello world"';
+            var result = (0, utils_1.parseEnvContent)(content);
+            expect(result[0].value).toBe('hello world');
+        });
+        test('handles single-quoted values', function () {
+            var content = "QUOTED='hello world'";
+            var result = (0, utils_1.parseEnvContent)(content);
+            expect(result[0].value).toBe('hello world');
+        });
+        test('handles values with special characters (non-comment)', function () {
+            // Note: # starts a comment in dotenv, so use other special chars
+            var content = 'SPECIAL=!@$%^&*()';
+            var result = (0, utils_1.parseEnvContent)(content);
+            expect(result[0].value).toBe('!@$%^&*()');
+        });
+        test('handles # in quoted values', function () {
+            // Quoted values preserve # character
+            var content = 'SPECIAL="!@#$%^&*()"';
+            var result = (0, utils_1.parseEnvContent)(content);
+            expect(result[0].value).toBe('!@#$%^&*()');
+        });
+    });
+    describe('comments and whitespace', function () {
+        test('ignores comment lines', function () {
+            var content = '# This is a comment\nFOO=bar\n# Another comment';
+            var result = (0, utils_1.parseEnvContent)(content);
+            expect(result).toEqual([{ name: 'FOO', value: 'bar' }]);
+        });
+        test('ignores inline comments', function () {
+            var content = 'FOO=bar # this is a comment';
+            var result = (0, utils_1.parseEnvContent)(content);
+            // Note: dotenv.parse treats everything after = as value
+            expect(result[0].name).toBe('FOO');
+        });
+        test('ignores empty lines', function () {
+            var content = 'FOO=bar\n\n\nBAZ=qux';
+            var result = (0, utils_1.parseEnvContent)(content);
+            expect(result).toHaveLength(2);
+        });
+        test('handles Windows CRLF line endings', function () {
+            var content = 'FOO=bar\r\nBAZ=qux\r\n';
+            var result = (0, utils_1.parseEnvContent)(content);
+            expect(result).toHaveLength(2);
+            expect(result[0].value).toBe('bar');
+            expect(result[1].value).toBe('qux');
+        });
+    });
+    describe('edge cases', function () {
+        test('filters out empty names', function () {
+            // This would be invalid env syntax, but we handle it gracefully
+            var content = 'VALID=value';
+            var result = (0, utils_1.parseEnvContent)(content);
+            expect(result.every(function (e) { return e.name !== ''; })).toBe(true);
+        });
+        test('handles multiline values with quotes', function () {
+            var content = 'MULTI="line1\nline2"';
+            var result = (0, utils_1.parseEnvContent)(content);
+            expect(result[0].value).toContain('line1');
+        });
+    });
+    describe('production scenarios', function () {
+        test('parses complex production env file', function () {
+            var _a, _b, _c;
+            var content = "# Production environment\nDATABASE_URL=postgresql://user:pass@host:5432/db?schema=public\nJWT_SECRET=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9==\nREDIS_URL=\"redis://localhost:6379\"\nAPI_KEY='sk_live_abc123=='\n\n# Feature flags\nENABLE_FEATURE=true";
+            var result = (0, utils_1.parseEnvContent)(content);
+            expect(result).toHaveLength(5);
+            expect((_a = result.find(function (e) { return e.name === 'DATABASE_URL'; })) === null || _a === void 0 ? void 0 : _a.value).toContain('postgresql://');
+            expect((_b = result.find(function (e) { return e.name === 'JWT_SECRET'; })) === null || _b === void 0 ? void 0 : _b.value).toContain('==');
+            expect((_c = result.find(function (e) { return e.name === 'REDIS_URL'; })) === null || _c === void 0 ? void 0 : _c.value).toBe('redis://localhost:6379');
+        });
+    });
+});
+describe('extractOrgId', function () {
+    describe('standard format: sk_agent_{agentId}_{orgId}_{secret}', function () {
+        test('extracts org ID from standard format', function () {
+            expect((0, utils_1.extractOrgId)('sk_agent_agent123_org456_secretkey')).toBe('org456');
+        });
+        test('handles org ID with numbers', function () {
+            expect((0, utils_1.extractOrgId)('sk_agent_a1_o2_s3')).toBe('o2');
+        });
+        test('handles long secret with underscores', function () {
+            expect((0, utils_1.extractOrgId)('sk_agent_myagent_myorg_secret_with_underscores')).toBe('myorg');
+        });
+    });
+    describe('org/agent format: sk_agent_org_{orgId}_agent_{agentId}_{secret}', function () {
+        test('extracts org ID from org/agent format', function () {
+            expect((0, utils_1.extractOrgId)('sk_agent_org_myorg_agent_myagent_secret')).toBe('myorg');
+        });
+        test('handles org ID with special characters', function () {
+            expect((0, utils_1.extractOrgId)('sk_agent_org_org-with-dash_agent_agent1_secret')).toBe('org-with-dash');
+        });
+        test('handles long secret in org/agent format', function () {
+            expect((0, utils_1.extractOrgId)('sk_agent_org_testorg_agent_testagent_long_secret_key')).toBe('testorg');
+        });
+    });
+    describe('invalid keys', function () {
+        test('returns empty string for undefined', function () {
+            expect((0, utils_1.extractOrgId)(undefined)).toBe('');
+        });
+        test('returns empty string for empty string', function () {
+            expect((0, utils_1.extractOrgId)('')).toBe('');
+        });
+        test('returns empty string for invalid prefix', function () {
+            expect((0, utils_1.extractOrgId)('invalid_agent_a_b_c')).toBe('');
+        });
+        test('returns empty string for too few parts', function () {
+            expect((0, utils_1.extractOrgId)('sk_agent_only_two')).toBe('');
+        });
+        test('returns empty string for malformed org format', function () {
+            expect((0, utils_1.extractOrgId)('sk_agent_org_myorg_notaagent_id_secret')).toBe('');
+        });
+        test('returns empty string when secret is missing', function () {
+            expect((0, utils_1.extractOrgId)('sk_agent_org_myorg_agent_myagent')).toBe('');
+        });
+    });
+});
+describe('resolveOrgId', function () {
+    var originalEnv = process.env.DAIN_ORG_ID;
+    afterEach(function () {
+        if (originalEnv !== undefined) {
+            process.env.DAIN_ORG_ID = originalEnv;
+        }
+        else {
+            delete process.env.DAIN_ORG_ID;
+        }
+    });
+    test('prioritizes config org-id over everything', function () {
+        process.env.DAIN_ORG_ID = 'env-org';
+        var config = {
+            'main-file': 'src/index.ts',
+            'org-id': 'config-org',
+            'api-key': 'sk_agent_a_apiorg_s',
+        };
+        expect((0, utils_1.resolveOrgId)(config)).toBe('config-org');
+    });
+    test('falls back to env var when config org-id not set', function () {
+        process.env.DAIN_ORG_ID = 'env-org';
+        var config = {
+            'main-file': 'src/index.ts',
+            'api-key': 'sk_agent_a_apiorg_s',
+        };
+        expect((0, utils_1.resolveOrgId)(config)).toBe('env-org');
+    });
+    test('falls back to API key when env var not set', function () {
+        delete process.env.DAIN_ORG_ID;
+        var config = {
+            'main-file': 'src/index.ts',
+            'api-key': 'sk_agent_a_apiorg_s',
+        };
+        expect((0, utils_1.resolveOrgId)(config)).toBe('apiorg');
+    });
+    test('returns empty string when nothing available', function () {
+        delete process.env.DAIN_ORG_ID;
+        var config = {
+            'main-file': 'src/index.ts',
+        };
+        expect((0, utils_1.resolveOrgId)(config)).toBe('');
+    });
+    test('handles empty string org-id in config', function () {
+        process.env.DAIN_ORG_ID = 'env-org';
+        var config = {
+            'main-file': 'src/index.ts',
+            'org-id': '',
+            'api-key': 'sk_agent_a_apiorg_s',
+        };
+        // Empty string is falsy, so falls back to env
+        expect((0, utils_1.resolveOrgId)(config)).toBe('env-org');
+    });
+});
+describe('getStaticFilesPath', function () {
+    test('returns path to static directory in cwd', function () {
+        var result = (0, utils_1.getStaticFilesPath)();
+        expect(result).toBe(path_1.default.join(process.cwd(), 'static'));
+    });
+    test('is an absolute path', function () {
+        var result = (0, utils_1.getStaticFilesPath)();
+        expect(path_1.default.isAbsolute(result)).toBe(true);
+    });
+});
+describe('default constants', function () {
+    test('DEFAULT_TUNNEL_BASE_URL is valid WebSocket URL', function () {
+        expect(utils_1.DEFAULT_TUNNEL_BASE_URL).toMatch(/^wss?:\/\//);
+    });
+    test('DEFAULT_PLATFORM_BASE_URL is valid HTTPS URL', function () {
+        expect(utils_1.DEFAULT_PLATFORM_BASE_URL).toMatch(/^https:\/\//);
+    });
+    test('DEFAULT_API_BASE_URL is valid HTTPS URL', function () {
+        expect(utils_1.DEFAULT_API_BASE_URL).toMatch(/^https:\/\//);
+    });
+    test('default URLs do not have trailing slashes', function () {
+        expect(utils_1.DEFAULT_TUNNEL_BASE_URL.endsWith('/')).toBe(false);
+        expect(utils_1.DEFAULT_PLATFORM_BASE_URL.endsWith('/')).toBe(false);
+        expect(utils_1.DEFAULT_API_BASE_URL.endsWith('/')).toBe(false);
+    });
+});

package/dist/commands/build.js

@@ -78,10 +78,6 @@ 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"));
-/**
- * Finds all WASM files in node_modules that might be needed at runtime.
- * These files are loaded via fs.readFileSync and can't be bundled by esbuild.
- */
 function findWasmFiles(nodeModulesPath) {
     return __awaiter(this, void 0, void 0, function () {
         function scanDir(dir) {
@@ -90,39 +86,34 @@ function findWasmFiles(nodeModulesPath) {
                 return __generator(this, function (_b) {
                     switch (_b.label) {
                         case 0:
-                            _b.trys.push([0, 8, , 9]);
+                            _b.trys.push([0, 7, , 8]);
                             return [4 /*yield*/, fs_extra_1.default.readdir(dir, { withFileTypes: true })];
                         case 1:
                             entries = _b.sent();
                             _i = 0, entries_1 = entries;
                             _b.label = 2;
                         case 2:
-                            if (!(_i < entries_1.length)) return [3 /*break*/, 7];
+                            if (!(_i < entries_1.length)) return [3 /*break*/, 6];
                             entry = entries_1[_i];
                             fullPath = path_1.default.join(dir, entry.name);
-                            if (!entry.isDirectory()) return [3 /*break*/, 5];
-                            if (!(entry.name !== '.bin' && entry.name !== '.cache')) return [3 /*break*/, 4];
+                            if (!(entry.isDirectory() && entry.name !== '.bin' && entry.name !== '.cache')) return [3 /*break*/, 4];
                             return [4 /*yield*/, scanDir(fullPath)];
                         case 3:
                             _b.sent();
-                            _b.label = 4;
-                        case 4: return [3 /*break*/, 6];
-                        case 5:
-                            if (entry.name.endsWith('.wasm')) {
-                                // Only include WASM files in dist/nodejs directories (Node.js bindings)
-                                if (fullPath.includes('/dist/') || fullPath.includes('/build/')) {
-                                    wasmFiles.push(fullPath);
-                                }
+                            return [3 /*break*/, 5];
+                        case 4:
+                            if (entry.name.endsWith('.wasm') && (fullPath.includes('/dist/') || fullPath.includes('/build/'))) {
+                                wasmFiles.push(fullPath);
                             }
-                            _b.label = 6;
-                        case 6:
+                            _b.label = 5;
+                        case 5:
                             _i++;
                             return [3 /*break*/, 2];
-                        case 7: return [3 /*break*/, 9];
-                        case 8:
+                        case 6: return [3 /*break*/, 8];
+                        case 7:
                             _a = _b.sent();
-                            return [3 /*break*/, 9];
-                        case 9: return [2 /*return*/];
+                            return [3 /*break*/, 8];
+                        case 8: return [2 /*return*/];
                     }
                 });
             });
@@ -140,13 +131,9 @@ function findWasmFiles(nodeModulesPath) {
         });
     });
 }
-/**
- * Copies WASM files that are referenced in the bundle to the output directory.
- * Scans the bundle for WASM filename references and copies matching files.
- */
 function copyWasmDependencies(bundlePath, nodeModulesPath, outDir) {
     return __awaiter(this, void 0, void 0, function () {
-        var copiedFiles, bundleContent, wasmFiles, _i, wasmFiles_1, wasmPath, wasmName, destPath, error_1;
+        var copiedFiles, bundleContent, wasmFiles, _i, wasmFiles_1, wasmPath, wasmName, error_1;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -167,8 +154,7 @@ function copyWasmDependencies(bundlePath, nodeModulesPath, outDir) {
                     wasmPath = wasmFiles_1[_i];
                     wasmName = path_1.default.basename(wasmPath);
                     if (!bundleContent.includes(wasmName)) return [3 /*break*/, 6];
-                    destPath = path_1.default.join(outDir, wasmName);
-                    return [4 /*yield*/, fs_extra_1.default.copy(wasmPath, destPath)];
+                    return [4 /*yield*/, fs_extra_1.default.copy(wasmPath, path_1.default.join(outDir, wasmName))];
                 case 5:
                     _a.sent();
                     copiedFiles.push(wasmName);
@@ -179,8 +165,7 @@ function copyWasmDependencies(bundlePath, nodeModulesPath, outDir) {
                 case 7: return [3 /*break*/, 9];
                 case 8:
                     error_1 = _a.sent();
-                    // Non-fatal: continue without WASM files
-                    console.warn('Warning: Could not process WASM dependencies:', error_1);
+                    (0, utils_1.logInfo)("Warning: Could not process WASM dependencies: ".concat(error_1));
                     return [3 /*break*/, 9];
                 case 9: return [2 /*return*/, copiedFiles];
             }
@@ -189,7 +174,7 @@ function copyWasmDependencies(bundlePath, nodeModulesPath, outDir) {
 }
 function build(options) {
     return __awaiter(this, void 0, void 0, function () {
-        var spinner, config, runtime, outDir, dainDir, nodeModulesPath, buildOptions, context, targetDir, bundlePath, copiedWasm, staticDir, staticOutDir, error_2;
+        var spinner, config, runtime, outDir, dainDir, nodeModulesPath, buildOptions, context, targetDir, bundlePath, copiedWasm, staticDir, error_2;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -201,11 +186,9 @@ function build(options) {
                     nodeModulesPath = path_1.default.join(process.cwd(), 'node_modules');
                     _a.label = 1;
                 case 1:
-                    _a.trys.push([1, 15, , 16]);
-                    // Ensure build directory exists
+                    _a.trys.push([1, 14, , 15]);
                     return [4 /*yield*/, fs_extra_1.default.ensureDir(outDir)];
                 case 2:
-                    // Ensure build directory exists
                     _a.sent();
                     buildOptions = {
                         entryPoints: [config['main-file']],
@@ -214,15 +197,9 @@ function build(options) {
                         outdir: outDir,
                     };
                     if (runtime === 'node') {
-                        // Node.js build process
-                        Object.assign(buildOptions, {
-                            platform: 'node',
-                            target: 'es2020',
-                            minify: !options.watch,
-                        });
+                        Object.assign(buildOptions, { platform: 'node', target: 'es2020', minify: !options.watch });
                     }
                     else if (runtime === 'workers') {
-                        // Cloudflare Workers build process
                         Object.assign(buildOptions, {
                             format: 'esm',
                             target: 'esnext',
@@ -234,10 +211,8 @@ function build(options) {
                         throw new Error("Unsupported runtime: ".concat(runtime));
                     }
                     if (!options.watch) return [3 /*break*/, 6];
-                    // Ensure .dain directory exists for watch mode
                     return [4 /*yield*/, fs_extra_1.default.ensureDir(dainDir)];
                 case 3:
-                    // Ensure .dain directory exists for watch mode
                     _a.sent();
                     return [4 /*yield*/, esbuild.context(buildOptions)];
                 case 4:
@@ -261,39 +236,31 @@ function build(options) {
                     return [4 /*yield*/, copyWasmDependencies(bundlePath, nodeModulesPath, targetDir)];
                 case 10:
                     copiedWasm = _a.sent();
-                    if (copiedWasm.length > 0) {
+                    if (copiedWasm.length > 0)
                         spinner.info("WASM files copied: ".concat(copiedWasm.join(', ')));
-                    }
                     _a.label = 11;
                 case 11:
                     staticDir = config['static-dir']
                         ? path_1.default.join(process.cwd(), config['static-dir'])
                         : path_1.default.join(process.cwd(), 'static');
                     if (!fs_extra_1.default.existsSync(staticDir)) return [3 /*break*/, 13];
-                    staticOutDir = path_1.default.join(targetDir, 'static');
-                    return [4 /*yield*/, fs_extra_1.default.copy(staticDir, staticOutDir)];
+                    return [4 /*yield*/, fs_extra_1.default.copy(staticDir, path_1.default.join(targetDir, 'static'))];
                 case 12:
                     _a.sent();
-                    spinner.info("Static files copied to ".concat(staticOutDir));
-                    return [3 /*break*/, 14];
+                    spinner.info("Static files copied to ".concat(path_1.default.join(targetDir, 'static')));
+                    _a.label = 13;
                 case 13:
-                    spinner.info('No static directory found. Skipping static file copy.');
-                    _a.label = 14;
-                case 14:
-                    spinner.info('Build completed successfully.');
-                    spinner.info("Project built and ready for ".concat(runtime, " runtime in ").concat(targetDir, "."));
-                    // Explicitly exit with success if not in watch mode
-                    if (!options.watch && !options.deploy) {
+                    spinner.succeed("Build complete: ".concat(runtime, " runtime in ").concat(targetDir));
+                    if (!options.watch && !options.deploy)
                         process.exit(0);
-                    }
-                    return [3 /*break*/, 16];
-                case 15:
+                    return [3 /*break*/, 15];
+                case 14:
                     error_2 = _a.sent();
                     spinner.fail('Build failed.');
                     (0, utils_1.logError)('Build process encountered an error', error_2);
                     process.exit(1);
-                    return [3 /*break*/, 16];
-                case 16: return [2 /*return*/];
+                    return [3 /*break*/, 15];
+                case 15: return [2 /*return*/];
             }
         });
     });