@dainprotocol/cli 1.2.26 → 1.2.30

package/dist/__tests__/integration.test.js

@@ -0,0 +1,134 @@
+"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"));
+var utils_1 = require("../utils");
+describe('Bug Detection Tests', function () {
+    describe('ENV parsing - CRITICAL: = in values', function () {
+        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 = (0, utils_1.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 = (0, utils_1.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 = (0, utils_1.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 = (0, utils_1.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();
+        });
+    });
+});

package/dist/__tests__/testchat.test.js

@@ -0,0 +1,214 @@
+"use strict";
+/**
+ * Testchat command tests - URL resolution, API key validation, message handling
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+describe('testchat.ts', function () {
+    describe('URL resolution', function () {
+        function resolveUrl(optionUrl, envUrl) {
+            if (optionUrl)
+                return { url: optionUrl, source: '--url option' };
+            if (envUrl)
+                return { url: envUrl, source: 'TEST_CHAT_URL env' };
+            return { url: undefined, source: null };
+        }
+        test('prioritizes --url option over env', function () {
+            var result = resolveUrl('http://cli-url.com', 'http://env-url.com');
+            expect(result.url).toBe('http://cli-url.com');
+            expect(result.source).toBe('--url option');
+        });
+        test('falls back to env when no option provided', function () {
+            var result = resolveUrl(undefined, 'http://env-url.com');
+            expect(result.url).toBe('http://env-url.com');
+            expect(result.source).toBe('TEST_CHAT_URL env');
+        });
+        test('returns undefined when neither provided', function () {
+            var result = resolveUrl(undefined, undefined);
+            expect(result.url).toBeUndefined();
+            expect(result.source).toBeNull();
+        });
+    });
+    describe('API key validation', function () {
+        test('requires ANTHROPIC_API_KEY', function () {
+            var apiKey = '';
+            var hasAnthropicKey = !!apiKey;
+            expect(hasAnthropicKey).toBe(false);
+        });
+        test('requires config api-key', function () {
+            var config = { 'api-key': '' };
+            var hasApiKey = !!config['api-key'];
+            expect(hasApiKey).toBe(false);
+        });
+        test('passes validation with all keys present', function () {
+            var anthropicKey = 'sk-ant-test';
+            var configApiKey = 'sk_agent_test';
+            var hasAllKeys = !!anthropicKey && !!configApiKey;
+            expect(hasAllKeys).toBe(true);
+        });
+    });
+    describe('exit command handling', function () {
+        test('recognizes "exit" command (lowercase)', function () {
+            var input = 'exit';
+            var shouldExit = input.toLowerCase() === 'exit';
+            expect(shouldExit).toBe(true);
+        });
+        test('recognizes "EXIT" command (uppercase)', function () {
+            var input = 'EXIT';
+            var shouldExit = input.toLowerCase() === 'exit';
+            expect(shouldExit).toBe(true);
+        });
+        test('recognizes "Exit" command (mixed case)', function () {
+            var input = 'Exit';
+            var shouldExit = input.toLowerCase() === 'exit';
+            expect(shouldExit).toBe(true);
+        });
+        test('does not exit on normal input', function () {
+            var input = 'hello';
+            var shouldExit = input.toLowerCase() === 'exit';
+            expect(shouldExit).toBe(false);
+        });
+        test('does not exit on input containing "exit"', function () {
+            var input = 'how do I exit vim';
+            var shouldExit = input.toLowerCase() === 'exit';
+            expect(shouldExit).toBe(false);
+        });
+    });
+    describe('message handling', function () {
+        test('adds user message to array', function () {
+            var messages = [];
+            var userInput = 'Hello world';
+            messages.push({ role: 'user', content: userInput });
+            expect(messages).toHaveLength(1);
+            expect(messages[0].role).toBe('user');
+            expect(messages[0].content).toBe('Hello world');
+        });
+        test('maintains message history', function () {
+            var messages = [];
+            messages.push({ role: 'user', content: 'First message' });
+            messages.push({ role: 'assistant', content: 'First response' });
+            messages.push({ role: 'user', content: 'Second message' });
+            expect(messages).toHaveLength(3);
+            expect(messages[0].role).toBe('user');
+            expect(messages[1].role).toBe('assistant');
+            expect(messages[2].role).toBe('user');
+        });
+    });
+    describe('tool response tracking', function () {
+        test('sets toolResponseAvailable when tool calls present', function () {
+            var toolCalls = [{ toolName: 'test', args: {} }];
+            var toolResponseAvailable = toolCalls.length > 0;
+            expect(toolResponseAvailable).toBe(true);
+        });
+        test('clears toolResponseAvailable when no tool calls', function () {
+            var toolCalls = [];
+            var toolResponseAvailable = toolCalls.length > 0;
+            expect(toolResponseAvailable).toBe(false);
+        });
+        test('skips user input when tool response available', function () {
+            var toolResponseAvailable = true;
+            var askedForInput = false;
+            // Simulates the chat loop logic
+            if (!toolResponseAvailable) {
+                askedForInput = true;
+            }
+            expect(askedForInput).toBe(false);
+        });
+    });
+    describe('toolbox loading', function () {
+        test('filters toolboxes without id', function () {
+            var toolboxes = [
+                { id: 'box1', tools: {} },
+                { id: null, tools: {} },
+                { id: 'box2', tools: {} },
+                { id: undefined, tools: {} },
+            ];
+            var validToolboxes = toolboxes.filter(function (tb) { return !!tb.id; });
+            expect(validToolboxes).toHaveLength(2);
+            expect(validToolboxes[0].id).toBe('box1');
+            expect(validToolboxes[1].id).toBe('box2');
+        });
+        test('merges tools from multiple toolboxes', function () {
+            var allTools = {};
+            var toolbox1 = { tool1: { name: 'Tool 1' } };
+            var toolbox2 = { tool2: { name: 'Tool 2' } };
+            allTools = __assign(__assign({}, allTools), toolbox1);
+            allTools = __assign(__assign({}, allTools), toolbox2);
+            expect(Object.keys(allTools)).toEqual(['tool1', 'tool2']);
+        });
+        test('later toolbox overwrites duplicate tool names', function () {
+            var allTools = {};
+            var toolbox1 = { duplicate: { name: 'Original' } };
+            var toolbox2 = { duplicate: { name: 'Overwritten' } };
+            allTools = __assign(__assign({}, allTools), toolbox1);
+            allTools = __assign(__assign({}, allTools), toolbox2);
+            expect(allTools.duplicate.name).toBe('Overwritten');
+        });
+    });
+    describe('tool output formatting', function () {
+        test('formats tool call output', function () {
+            var toolName = 'searchWeb';
+            var args = { query: 'test' };
+            var output = "Tool call: '".concat(toolName, "' ").concat(JSON.stringify(args));
+            expect(output).toBe("Tool call: 'searchWeb' {\"query\":\"test\"}");
+        });
+        test('formats tool response output', function () {
+            var toolName = 'searchWeb';
+            var result = { results: ['a', 'b'] };
+            var output = "Tool response: '".concat(toolName, "' ").concat(JSON.stringify(result));
+            expect(output).toBe("Tool response: 'searchWeb' {\"results\":[\"a\",\"b\"]}");
+        });
+    });
+    describe('max steps configuration', function () {
+        test('default max steps is 5', function () {
+            var maxSteps = 5;
+            expect(maxSteps).toBe(5);
+        });
+    });
+    describe('error handling', function () {
+        test('continues chat loop on error', function () {
+            var loopContinued = false;
+            var errorCaught = false;
+            try {
+                throw new Error('API Error');
+            }
+            catch (_a) {
+                errorCaught = true;
+                // Simulates continuing the loop after error
+                loopContinued = true;
+            }
+            expect(errorCaught).toBe(true);
+            expect(loopContinued).toBe(true);
+        });
+    });
+});
+describe('DainServiceConnection setup', function () {
+    test('constructs with url and auth', function () {
+        var url = 'https://service.example.com';
+        var apiKey = 'sk_agent_test';
+        var connection = {
+            url: url,
+            auth: { apiKey: apiKey },
+        };
+        expect(connection.url).toBe(url);
+        expect(connection.auth.apiKey).toBe(apiKey);
+    });
+});
+describe('system prompt', function () {
+    test('includes required instructions', function () {
+        var systemPrompt = "Keep your responses brief but insightful.\n    use lots of emojis, to show your enthusiasm!\n    Your name is Butterfly, Built by the team at Dain.";
+        expect(systemPrompt).toContain('brief');
+        expect(systemPrompt).toContain('emojis');
+        expect(systemPrompt).toContain('Butterfly');
+        expect(systemPrompt).toContain('Dain');
+    });
+});