@dainprotocol/cli 1.2.26 → 1.2.28

package/dist/__tests__/deploy.test.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Mock fs-extra before importing
+jest.mock('fs-extra', function () { return ({
+    readFile: jest.fn(),
+    readdir: jest.fn(),
+    existsSync: jest.fn(),
+    readFileSync: jest.fn(),
+}); });
+// Test the env parsing logic directly
+describe('loadEnvVariables', function () {
+    // Extract the parsing logic for testing
+    function parseEnvContent(envContent) {
+        return envContent
+            .split('\n')
+            .filter(function (line) { return line.trim() && !line.trim().startsWith('#'); })
+            .map(function (line) {
+            var equalsIndex = line.indexOf('=');
+            if (equalsIndex === -1)
+                return null;
+            var name = line.substring(0, equalsIndex).trim();
+            var value = line.substring(equalsIndex + 1).trim();
+            // Remove surrounding quotes if present
+            var unquotedValue = value.replace(/^["']|["']$/g, '');
+            return { name: name, value: unquotedValue };
+        })
+            .filter(function (env) {
+            return env !== null && env.name !== '' && env.value !== '';
+        });
+    }
+    test('parses simple key=value pairs', function () {
+        var content = "FOO=bar\nBAZ=qux";
+        var result = parseEnvContent(content);
+        expect(result).toEqual([
+            { name: 'FOO', value: 'bar' },
+            { name: 'BAZ', value: 'qux' },
+        ]);
+    });
+    test('handles values with = signs (like base64)', function () {
+        var content = "API_KEY=sk_test_abc123==\nSECRET=a=b=c=d";
+        var result = parseEnvContent(content);
+        expect(result).toEqual([
+            { name: 'API_KEY', value: 'sk_test_abc123==' },
+            { name: 'SECRET', value: 'a=b=c=d' },
+        ]);
+    });
+    test('ignores comment lines', function () {
+        var content = "# This is a comment\nFOO=bar\n# Another comment\nBAZ=qux";
+        var result = parseEnvContent(content);
+        expect(result).toEqual([
+            { name: 'FOO', value: 'bar' },
+            { name: 'BAZ', value: 'qux' },
+        ]);
+    });
+    test('ignores empty lines', function () {
+        var content = "FOO=bar\n\nBAZ=qux\n\n";
+        var result = parseEnvContent(content);
+        expect(result).toEqual([
+            { name: 'FOO', value: 'bar' },
+            { name: 'BAZ', value: 'qux' },
+        ]);
+    });
+    test('removes surrounding quotes from values', function () {
+        var content = "FOO=\"bar\"\nBAZ='qux'\nSINGLE=\"quoted value\"";
+        var result = parseEnvContent(content);
+        expect(result).toEqual([
+            { name: 'FOO', value: 'bar' },
+            { name: 'BAZ', value: 'qux' },
+            { name: 'SINGLE', value: 'quoted value' },
+        ]);
+    });
+    test('handles whitespace around = sign', function () {
+        var content = "  FOO  =  bar\n  BAZ=qux";
+        var result = parseEnvContent(content);
+        expect(result).toEqual([
+            { name: 'FOO', value: 'bar' },
+            { name: 'BAZ', value: 'qux' },
+        ]);
+    });
+    test('skips lines without = sign', function () {
+        var content = "FOO=bar\nINVALID LINE\nBAZ=qux";
+        var result = parseEnvContent(content);
+        expect(result).toEqual([
+            { name: 'FOO', value: 'bar' },
+            { name: 'BAZ', value: 'qux' },
+        ]);
+    });
+    test('skips lines with empty name or value', function () {
+        var content = "=bar\nFOO=\nVALID=value";
+        var result = parseEnvContent(content);
+        expect(result).toEqual([
+            { name: 'VALID', value: 'value' },
+        ]);
+    });
+    test('handles complex production-like env file', function () {
+        var content = "# Production environment\nDATABASE_URL=postgresql://user:pass@host:5432/db?schema=public\nJWT_SECRET=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ\nREDIS_URL=\"redis://localhost:6379\"\nAPI_KEY='sk_live_abc123=='\n\n# Comment in the middle\nEMPTY_LINE_AFTER=true";
+        var result = parseEnvContent(content);
+        expect(result).toHaveLength(5);
+        expect(result[0].name).toBe('DATABASE_URL');
+        expect(result[0].value).toContain('postgresql://');
+        expect(result[1].name).toBe('JWT_SECRET');
+        expect(result[1].value).toContain('eyJ');
+        expect(result[2].value).toBe('redis://localhost:6379');
+        expect(result[3].value).toBe('sk_live_abc123==');
+    });
+});
+describe('fetchWithTimeout', function () {
+    test('AbortController pattern is correct', function () {
+        // Test that our timeout pattern is implemented correctly
+        var controller = new AbortController();
+        // Signal starts as not aborted
+        expect(controller.signal.aborted).toBe(false);
+        // Abort changes the signal
+        controller.abort();
+        expect(controller.signal.aborted).toBe(true);
+    });
+    test('setTimeout + AbortController integration', function () {
+        jest.useFakeTimers();
+        var controller = new AbortController();
+        var timeoutMs = 100;
+        // Set up timeout to abort
+        var timeoutId = setTimeout(function () { return controller.abort(); }, timeoutMs);
+        expect(controller.signal.aborted).toBe(false);
+        // Advance time past timeout
+        jest.advanceTimersByTime(150);
+        expect(controller.signal.aborted).toBe(true);
+        clearTimeout(timeoutId);
+        jest.useRealTimers();
+    });
+    test('clearTimeout prevents abort', function () {
+        jest.useFakeTimers();
+        var controller = new AbortController();
+        var timeoutMs = 100;
+        var timeoutId = setTimeout(function () { return controller.abort(); }, timeoutMs);
+        // Clear before timeout
+        clearTimeout(timeoutId);
+        // Advance time past what would have been the timeout
+        jest.advanceTimersByTime(200);
+        // Should NOT be aborted since we cleared the timeout
+        expect(controller.signal.aborted).toBe(false);
+        jest.useRealTimers();
+    });
+});

package/dist/__tests__/dev.test.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var path_1 = __importDefault(require("path"));
+describe('dev.ts security', function () {
+    describe('path traversal protection', function () {
+        // Extract the validation logic for testing
+        function validateMainFilePath(mainFile, cwd) {
+            var resolvedMain = path_1.default.resolve(cwd, mainFile);
+            return resolvedMain.startsWith(cwd);
+        }
+        test('allows valid relative paths', function () {
+            var cwd = '/project';
+            expect(validateMainFilePath('src/index.ts', cwd)).toBe(true);
+            expect(validateMainFilePath('./src/index.ts', cwd)).toBe(true);
+            expect(validateMainFilePath('index.ts', cwd)).toBe(true);
+        });
+        test('blocks path traversal attempts', function () {
+            var cwd = '/project';
+            expect(validateMainFilePath('../other/index.ts', cwd)).toBe(false);
+            expect(validateMainFilePath('../../etc/passwd', cwd)).toBe(false);
+            expect(validateMainFilePath('src/../../other/file.ts', cwd)).toBe(false);
+        });
+        test('blocks absolute paths outside project', function () {
+            var cwd = '/project';
+            expect(validateMainFilePath('/etc/passwd', cwd)).toBe(false);
+            expect(validateMainFilePath('/other/project/index.ts', cwd)).toBe(false);
+        });
+        test('allows absolute paths inside project', function () {
+            var cwd = '/project';
+            expect(validateMainFilePath('/project/src/index.ts', cwd)).toBe(true);
+        });
+    });
+    describe('port validation', function () {
+        function validatePort(port) {
+            var portNumber = parseInt(port, 10);
+            var valid = !isNaN(portNumber) && portNumber >= 1 && portNumber <= 65535;
+            return { valid: valid, port: valid ? portNumber : 2022 };
+        }
+        test('accepts valid ports', function () {
+            expect(validatePort('3000')).toEqual({ valid: true, port: 3000 });
+            expect(validatePort('8080')).toEqual({ valid: true, port: 8080 });
+            expect(validatePort('1')).toEqual({ valid: true, port: 1 });
+            expect(validatePort('65535')).toEqual({ valid: true, port: 65535 });
+        });
+        test('rejects invalid ports', function () {
+            expect(validatePort('0').valid).toBe(false);
+            expect(validatePort('-1').valid).toBe(false);
+            expect(validatePort('65536').valid).toBe(false);
+            expect(validatePort('abc').valid).toBe(false);
+            expect(validatePort('').valid).toBe(false);
+        });
+        test('returns default port for invalid input', function () {
+            expect(validatePort('invalid').port).toBe(2022);
+            expect(validatePort('99999').port).toBe(2022);
+        });
+    });
+    describe('process spawn vs exec', function () {
+        test('spawn uses array for arguments (no shell injection)', function () {
+            // This tests the concept - spawn with an array is safe
+            // The key point: with spawn + array args, shell metacharacters
+            // are treated as literal characters, not commands
+            // If someone tried to inject: "src/index.ts; rm -rf /"
+            // With exec(), this would execute the rm command
+            // With spawn(['src/index.ts; rm -rf /']), it's treated as a filename
+            var maliciousInput = 'src/index.ts; rm -rf /';
+            // The resolved path will contain the malicious string as-is
+            var resolved = path_1.default.resolve('/project', maliciousInput);
+            // The malicious part is embedded in the path, proving it's not parsed
+            expect(resolved).toMatch(/index\.ts;/);
+            // But crucially, the semicolon stays in the path - it's never executed
+            expect(resolved.includes(';')).toBe(true);
+        });
+    });
+});
+describe('graceful shutdown', function () {
+    test('cleanup function sets isCleaningUp flag', function () {
+        // Simulate the cleanup behavior
+        var isCleaningUp = false;
+        var cleanupCalled = 0;
+        function cleanup() {
+            if (isCleaningUp)
+                return;
+            isCleaningUp = true;
+            cleanupCalled++;
+        }
+        cleanup();
+        expect(cleanupCalled).toBe(1);
+        // Second call should be no-op
+        cleanup();
+        expect(cleanupCalled).toBe(1);
+    });
+    test('cleanup handles null resources safely', function () {
+        var childProcess = null;
+        var watcher = null;
+        function cleanup() {
+            if (childProcess) {
+                childProcess.kill();
+                childProcess = null;
+            }
+            if (watcher) {
+                watcher.close();
+                watcher = null;
+            }
+        }
+        // Should not throw
+        expect(function () { return cleanup(); }).not.toThrow();
+    });
+});
+describe('error detection in stderr', function () {
+    function shouldMarkAsFailed(output) {
+        return output.includes('Error:') || output.includes('error:');
+    }
+    test('detects Error: pattern', function () {
+        expect(shouldMarkAsFailed('Error: Something went wrong')).toBe(true);
+        expect(shouldMarkAsFailed('TypeError: undefined is not a function')).toBe(true);
+    });
+    test('detects error: pattern', function () {
+        expect(shouldMarkAsFailed('error: cannot find module')).toBe(true);
+    });
+    test('ignores warnings', function () {
+        expect(shouldMarkAsFailed('Warning: deprecated API')).toBe(false);
+        expect(shouldMarkAsFailed('WARN: something')).toBe(false);
+        expect(shouldMarkAsFailed('DeprecationWarning: this is deprecated')).toBe(false);
+    });
+    test('ignores normal output', function () {
+        expect(shouldMarkAsFailed('Server started on port 3000')).toBe(false);
+        expect(shouldMarkAsFailed('Compiling...')).toBe(false);
+    });
+});

package/dist/__tests__/integration.test.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * Integration tests for bug detection
+ * Focus on actual bugs that the refactoring could have introduced
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var path_1 = __importDefault(require("path"));
+describe('Bug Detection Tests', function () {
+    describe('ENV parsing - CRITICAL: = in values', function () {
+        // This is the ACTUAL parsing logic from deploy.ts
+        function parseEnvContent(envContent) {
+            return envContent
+                .split('\n')
+                .filter(function (line) { return line.trim() && !line.trim().startsWith('#'); })
+                .map(function (line) {
+                var equalsIndex = line.indexOf('=');
+                if (equalsIndex === -1)
+                    return null;
+                var name = line.substring(0, equalsIndex).trim();
+                var value = line.substring(equalsIndex + 1).trim();
+                var unquotedValue = value.replace(/^["']|["']$/g, '');
+                return { name: name, value: unquotedValue };
+            })
+                .filter(function (env) {
+                return env !== null && env.name !== '' && env.value !== '';
+            });
+        }
+        test('REGRESSION: base64 values with == suffix must be preserved', function () {
+            // OLD BUG: line.split('=') would break this into ['JWT', 'eyJ...', '', '']
+            var content = 'JWT_SECRET=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.test==';
+            var result = parseEnvContent(content);
+            expect(result).toHaveLength(1);
+            expect(result[0].name).toBe('JWT_SECRET');
+            expect(result[0].value).toBe('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.test==');
+        });
+        test('REGRESSION: database URLs with query params', function () {
+            // OLD BUG: would only get 'postgresql://user:pass@host:5432/db?sslmode'
+            var content = 'DATABASE_URL=postgresql://user:pass@host:5432/db?sslmode=require';
+            var result = parseEnvContent(content);
+            expect(result[0].value).toBe('postgresql://user:pass@host:5432/db?sslmode=require');
+        });
+        test('REGRESSION: multiple = signs in value', function () {
+            var content = 'FORMULA=a=b=c=d';
+            var result = parseEnvContent(content);
+            expect(result[0].value).toBe('a=b=c=d');
+        });
+        test('handles Windows CRLF line endings', function () {
+            var content = 'FOO=bar\r\nBAZ=qux\r\n';
+            var result = parseEnvContent(content);
+            expect(result).toHaveLength(2);
+            // Values should not have trailing \r
+            expect(result[0].value.endsWith('\r')).toBe(false);
+            expect(result[1].value.endsWith('\r')).toBe(false);
+        });
+    });
+    describe('Path traversal protection', function () {
+        function validateMainFilePath(mainFile, cwd) {
+            var resolvedMain = path_1.default.resolve(cwd, mainFile);
+            return resolvedMain.startsWith(cwd);
+        }
+        test('SECURITY: blocks ../../../etc/passwd', function () {
+            expect(validateMainFilePath('../../../etc/passwd', '/project')).toBe(false);
+        });
+        test('SECURITY: blocks src/../../../etc/passwd', function () {
+            expect(validateMainFilePath('src/../../../etc/passwd', '/project')).toBe(false);
+        });
+        test('SECURITY: blocks absolute paths outside project', function () {
+            expect(validateMainFilePath('/etc/passwd', '/project')).toBe(false);
+        });
+        test('allows normal relative paths', function () {
+            expect(validateMainFilePath('src/index.ts', '/project')).toBe(true);
+            expect(validateMainFilePath('./src/index.ts', '/project')).toBe(true);
+        });
+    });
+    describe('Port validation', function () {
+        function validatePort(port) {
+            var portNumber = parseInt(port, 10);
+            var valid = !isNaN(portNumber) && portNumber >= 1 && portNumber <= 65535;
+            return { valid: valid, port: valid ? portNumber : 2022 };
+        }
+        test('rejects port 0', function () {
+            expect(validatePort('0').valid).toBe(false);
+        });
+        test('rejects port > 65535', function () {
+            expect(validatePort('65536').valid).toBe(false);
+        });
+        test('rejects non-numeric', function () {
+            expect(validatePort('abc').valid).toBe(false);
+        });
+        test('accepts valid ports', function () {
+            expect(validatePort('3000').valid).toBe(true);
+            expect(validatePort('8080').valid).toBe(true);
+        });
+    });
+    describe('Graceful shutdown - cleanup idempotency', function () {
+        test('cleanup can be called multiple times safely', function () {
+            var isCleaningUp = false;
+            var cleanupCount = 0;
+            function cleanup() {
+                if (isCleaningUp)
+                    return;
+                isCleaningUp = true;
+                cleanupCount++;
+            }
+            cleanup();
+            cleanup();
+            cleanup();
+            expect(cleanupCount).toBe(1);
+        });
+    });
+    describe('Interval-based polling vs recursive setTimeout', function () {
+        test('setInterval can be properly cleared', function () {
+            jest.useFakeTimers();
+            var callCount = 0;
+            var intervalId = null;
+            intervalId = setInterval(function () {
+                callCount++;
+            }, 1000);
+            jest.advanceTimersByTime(3000);
+            expect(callCount).toBe(3);
+            clearInterval(intervalId);
+            intervalId = null;
+            jest.advanceTimersByTime(3000);
+            expect(callCount).toBe(3); // Should NOT increase
+            jest.useRealTimers();
+        });
+    });
+    describe('AbortController timeout pattern', function () {
+        test('controller aborts after timeout', function () {
+            jest.useFakeTimers();
+            var controller = new AbortController();
+            setTimeout(function () { return controller.abort(); }, 100);
+            expect(controller.signal.aborted).toBe(false);
+            jest.advanceTimersByTime(150);
+            expect(controller.signal.aborted).toBe(true);
+            jest.useRealTimers();
+        });
+        test('clearTimeout prevents abort', function () {
+            jest.useFakeTimers();
+            var controller = new AbortController();
+            var timeoutId = setTimeout(function () { return controller.abort(); }, 100);
+            clearTimeout(timeoutId);
+            jest.advanceTimersByTime(200);
+            expect(controller.signal.aborted).toBe(false);
+            jest.useRealTimers();
+        });
+    });
+});

package/dist/__tests__/logs.test.js

@@ -0,0 +1,135 @@
+"use strict";
+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;
+};
+describe('logs.ts', function () {
+    describe('formatProjectLogs', function () {
+        function formatProjectLogs(projectLogs, deploymentId) {
+            try {
+                var _a = projectLogs.logs, logs = _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,
+                ];
+                return output.join('\n');
+            }
+            catch (error) {
+                return "Error formatting logs: ".concat(error.message);
+            }
+        }
+        test('formats basic log output', function () {
+            var logs = { logs: 'Server started', status: 'running' };
+            var result = formatProjectLogs(logs, 'codegen-test123');
+            expect(result).toContain('=== Project ===');
+            expect(result).toContain('=== Logs ===');
+            expect(result).toContain('Server started');
+            expect(result).toContain('test123-agent.dainapp.com');
+        });
+        test('formats date fields correctly', function () {
+            var logs = {
+                logs: 'test',
+                createdAt: '2024-01-15T10:30:00.000Z',
+            };
+            var result = formatProjectLogs(logs, 'codegen-test');
+            expect(result).toContain('created at:');
+            // Date formatting is locale-dependent, just check it's present
+            expect(result).toMatch(/\d/);
+        });
+        test('handles empty logs', function () {
+            var logs = { logs: '' };
+            var result = formatProjectLogs(logs, 'codegen-test');
+            expect(result).toContain('=== Logs ===');
+        });
+        test('handles camelCase key formatting', function () {
+            var logs = {
+                logs: '',
+                deploymentId: '123',
+                serviceStatus: 'running',
+            };
+            var result = formatProjectLogs(logs, 'codegen-test');
+            expect(result).toContain('deployment id:');
+            expect(result).toContain('service status:');
+        });
+        test('handles errors gracefully', function () {
+            var result = formatProjectLogs(null, 'test');
+            expect(result).toContain('Error formatting logs:');
+        });
+    });
+    describe('interval-based polling', function () {
+        jest.useFakeTimers();
+        test('setInterval is used instead of recursive setTimeout', function () {
+            var callCount = 0;
+            var intervalId = null;
+            function startPolling() {
+                intervalId = setInterval(function () {
+                    callCount++;
+                }, 1000);
+            }
+            function stopPolling() {
+                if (intervalId) {
+                    clearInterval(intervalId);
+                    intervalId = null;
+                }
+            }
+            startPolling();
+            jest.advanceTimersByTime(5000);
+            expect(callCount).toBe(5);
+            stopPolling();
+            jest.advanceTimersByTime(5000);
+            expect(callCount).toBe(5); // Should not increase after stopping
+        });
+        afterEach(function () {
+            jest.useRealTimers();
+        });
+    });
+    describe('cleanup on shutdown', function () {
+        test('cleanup clears interval and sets flag', function () {
+            var watchInterval = null;
+            var isShuttingDown = false;
+            function cleanup() {
+                isShuttingDown = true;
+                if (watchInterval) {
+                    clearInterval(watchInterval);
+                    watchInterval = null;
+                }
+            }
+            watchInterval = setInterval(function () { }, 1000);
+            expect(watchInterval).not.toBeNull();
+            cleanup();
+            expect(isShuttingDown).toBe(true);
+            expect(watchInterval).toBeNull();
+        });
+    });
+});