@dainprotocol/cli 1.2.28 → 1.2.31

package/dist/__tests__/init.test.js

@@ -0,0 +1,290 @@
+"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"));
+/**
+ * Init command tests - project initialization, template handling, validation
+ */
+describe('init.ts', function () {
+    describe('Node.js version validation', function () {
+        function validateNodeVersion(version) {
+            var versionNum = Number(version.slice(1).split('.')[0]);
+            return { valid: versionNum >= 20, major: versionNum };
+        }
+        test('accepts Node.js 20+', function () {
+            expect(validateNodeVersion('v20.0.0').valid).toBe(true);
+            expect(validateNodeVersion('v20.7.0').valid).toBe(true);
+            expect(validateNodeVersion('v21.0.0').valid).toBe(true);
+            expect(validateNodeVersion('v22.3.0').valid).toBe(true);
+        });
+        test('rejects Node.js < 20', function () {
+            expect(validateNodeVersion('v18.0.0').valid).toBe(false);
+            expect(validateNodeVersion('v19.9.0').valid).toBe(false);
+            expect(validateNodeVersion('v16.20.0').valid).toBe(false);
+        });
+        test('parses version correctly', function () {
+            expect(validateNodeVersion('v20.7.0').major).toBe(20);
+            expect(validateNodeVersion('v18.15.0').major).toBe(18);
+            expect(validateNodeVersion('v22.0.0').major).toBe(22);
+        });
+        test('handles pre-release versions', function () {
+            // Pre-release versions have format like v21.0.0-nightly
+            expect(validateNodeVersion('v21.0.0-nightly').major).toBe(21);
+        });
+    });
+    describe('project directory handling', function () {
+        test('creates project path from cwd and name', function () {
+            var cwd = '/home/user/projects';
+            var projectName = 'my-service';
+            var projectDir = path_1.default.join(cwd, projectName);
+            expect(projectDir).toBe('/home/user/projects/my-service');
+        });
+        test('handles project names with special characters', function () {
+            var cwd = '/project';
+            expect(path_1.default.join(cwd, 'my-service')).toBe('/project/my-service');
+            expect(path_1.default.join(cwd, 'my_service')).toBe('/project/my_service');
+            expect(path_1.default.join(cwd, '@scope/pkg')).toBe('/project/@scope/pkg');
+        });
+        test('handles spaces in project name', function () {
+            var cwd = '/project';
+            var projectDir = path_1.default.join(cwd, 'my service');
+            expect(projectDir).toBe('/project/my service');
+        });
+    });
+    describe('template directory resolution', function () {
+        test('resolves template path from __dirname', function () {
+            // The actual path is: __dirname/../templates/default
+            var dirname = '/path/to/dain-dev-cli/dist/commands';
+            var templateDir = path_1.default.join(dirname, '..', '..', 'templates', 'default');
+            expect(templateDir).toBe('/path/to/dain-dev-cli/templates/default');
+        });
+        test('uses "default" template', function () {
+            var templateName = 'default';
+            expect(templateName).toBe('default');
+        });
+    });
+    describe('package.json modification', function () {
+        test('updates package name', function () {
+            var packageJson = { name: 'template-name', version: '1.0.0' };
+            var projectName = 'my-new-project';
+            packageJson.name = projectName;
+            expect(packageJson.name).toBe('my-new-project');
+        });
+        test('preserves other package.json fields', function () {
+            var packageJson = {
+                name: 'template',
+                version: '1.0.0',
+                dependencies: { 'some-dep': '^1.0.0' },
+                scripts: { dev: 'node index.js' },
+            };
+            var projectName = 'updated-name';
+            packageJson.name = projectName;
+            expect(packageJson.name).toBe('updated-name');
+            expect(packageJson.version).toBe('1.0.0');
+            expect(packageJson.dependencies).toEqual({ 'some-dep': '^1.0.0' });
+            expect(packageJson.scripts).toEqual({ dev: 'node index.js' });
+        });
+    });
+    describe('project name validation', function () {
+        // Valid npm package name patterns
+        function isValidProjectName(name) {
+            // Simple validation: non-empty, no path separators at start
+            if (!name || name.startsWith('/') || name.startsWith('..')) {
+                return false;
+            }
+            return true;
+        }
+        test('accepts valid project names', function () {
+            expect(isValidProjectName('my-project')).toBe(true);
+            expect(isValidProjectName('my_project')).toBe(true);
+            expect(isValidProjectName('myproject123')).toBe(true);
+            expect(isValidProjectName('@scope/package')).toBe(true);
+        });
+        test('rejects empty names', function () {
+            expect(isValidProjectName('')).toBe(false);
+        });
+        test('rejects absolute paths', function () {
+            expect(isValidProjectName('/etc/passwd')).toBe(false);
+        });
+        test('rejects path traversal', function () {
+            expect(isValidProjectName('../other')).toBe(false);
+        });
+    });
+    describe('success messages', function () {
+        test('includes project name in success message', function () {
+            var projectName = 'my-service';
+            var message = "Initialized Dain project: ".concat(projectName);
+            expect(message).toContain('my-service');
+        });
+        test('includes project directory in message', function () {
+            var projectDir = '/home/user/projects/my-service';
+            var message = "Project created at ".concat(projectDir);
+            expect(message).toContain('/home/user/projects/my-service');
+        });
+        test('includes getting started instructions', function () {
+            var projectName = 'my-project';
+            var commands = ["cd ".concat(projectName), 'npm install', 'npm run dev'];
+            expect(commands[0]).toBe('cd my-project');
+            expect(commands[1]).toBe('npm install');
+            expect(commands[2]).toBe('npm run dev');
+        });
+    });
+});
+describe('status.ts', function () {
+    describe('URL construction', function () {
+        test('builds correct status URL', function () {
+            var baseUrl = 'https://api.example.com';
+            var orgId = 'org123';
+            var serviceId = 'svc456';
+            var deploymentId = 'dep789';
+            var environment = 'production';
+            var statusUrl = "".concat(baseUrl, "/codegen-deploy/status/").concat(orgId, "/").concat(serviceId, "/").concat(deploymentId, "/").concat(environment);
+            expect(statusUrl).toBe('https://api.example.com/codegen-deploy/status/org123/svc456/dep789/production');
+        });
+        test('handles different environments', function () {
+            var buildUrl = function (env) {
+                return "https://api.example.com/codegen-deploy/status/org/svc/dep/".concat(env);
+            };
+            expect(buildUrl('production')).toContain('/production');
+            expect(buildUrl('staging')).toContain('/staging');
+            expect(buildUrl('development')).toContain('/development');
+        });
+    });
+    describe('predefined parameters override', function () {
+        test('uses predefined values over config', function () {
+            var config = {
+                'deployment-id': 'config-dep',
+                'service-id': 'config-svc',
+                environment: 'config-env',
+            };
+            var predefined = {
+                deploymentId: 'pre-dep',
+                serviceId: 'pre-svc',
+                environment: 'pre-env',
+            };
+            var deploymentId = predefined.deploymentId || config['deployment-id'];
+            var serviceId = predefined.serviceId || config['service-id'];
+            var environment = predefined.environment || config.environment;
+            expect(deploymentId).toBe('pre-dep');
+            expect(serviceId).toBe('pre-svc');
+            expect(environment).toBe('pre-env');
+        });
+        test('falls back to config when predefined is undefined', function () {
+            var config = {
+                'deployment-id': 'config-dep',
+                'service-id': 'config-svc',
+            };
+            var predefinedDeploymentId = undefined;
+            var predefinedServiceId = undefined;
+            var deploymentId = predefinedDeploymentId || config['deployment-id'];
+            var serviceId = predefinedServiceId || config['service-id'];
+            expect(deploymentId).toBe('config-dep');
+            expect(serviceId).toBe('config-svc');
+        });
+    });
+    describe('response handling', function () {
+        test('returns result when predefined params are provided', function () {
+            var preDefinedDeploymentId = 'dep123';
+            var shouldReturn = !!preDefinedDeploymentId;
+            expect(shouldReturn).toBe(true);
+        });
+        test('exits when no predefined params', function () {
+            var preDefinedDeploymentId = undefined;
+            var shouldExit = !preDefinedDeploymentId;
+            expect(shouldExit).toBe(true);
+        });
+    });
+});
+describe('undeploy.ts', function () {
+    describe('URL construction', function () {
+        test('builds correct undeploy URL', function () {
+            var baseUrl = 'https://api.example.com';
+            var orgId = 'org123';
+            var serviceId = 'svc456';
+            var deploymentId = 'dep789';
+            var environment = 'production';
+            var undeployUrl = "".concat(baseUrl, "/codegen-deploy/undeploy/").concat(orgId, "/").concat(serviceId, "/").concat(deploymentId, "/").concat(environment);
+            expect(undeployUrl).toBe('https://api.example.com/codegen-deploy/undeploy/org123/svc456/dep789/production');
+        });
+    });
+    describe('HTTP method', function () {
+        test('uses DELETE method for undeploy', function () {
+            var method = 'DELETE';
+            expect(method).toBe('DELETE');
+        });
+    });
+    describe('validation requirements', function () {
+        test('requires org ID', function () {
+            var orgId = '';
+            var hasError = !orgId;
+            expect(hasError).toBe(true);
+        });
+        test('requires deployment ID', function () {
+            var deploymentId = '';
+            var hasError = !deploymentId;
+            expect(hasError).toBe(true);
+        });
+        test('requires service ID', function () {
+            var serviceId = '';
+            var hasError = !serviceId;
+            expect(hasError).toBe(true);
+        });
+        test('passes validation with all required fields', function () {
+            var orgId = 'org123';
+            var deploymentId = 'dep456';
+            var serviceId = 'svc789';
+            var allValid = orgId && deploymentId && serviceId;
+            expect(allValid).toBeTruthy();
+        });
+    });
+});
+describe('shared patterns across commands', function () {
+    describe('fetchWithTimeout pattern', function () {
+        var FETCH_TIMEOUT_MS = 30000;
+        test('default timeout is 30 seconds', function () {
+            expect(FETCH_TIMEOUT_MS).toBe(30000);
+        });
+        test('uses AbortController for cancellation', function () {
+            var controller = new AbortController();
+            expect(controller.signal.aborted).toBe(false);
+            controller.abort();
+            expect(controller.signal.aborted).toBe(true);
+        });
+    });
+    describe('Authorization header', function () {
+        test('formats Bearer token correctly', function () {
+            var apiKey = 'sk_agent_test_key';
+            var header = "Bearer ".concat(apiKey);
+            expect(header).toBe('Bearer sk_agent_test_key');
+        });
+    });
+    describe('error response handling', function () {
+        test('creates error message from response', function () {
+            var status = 404;
+            var statusText = 'Not Found';
+            var errorMessage = "failed: ".concat(status, " ").concat(statusText);
+            expect(errorMessage).toBe('failed: 404 Not Found');
+        });
+        test('handles various HTTP status codes', function () {
+            var createError = function (status, text) { return "".concat(status, " ").concat(text); };
+            expect(createError(400, 'Bad Request')).toBe('400 Bad Request');
+            expect(createError(401, 'Unauthorized')).toBe('401 Unauthorized');
+            expect(createError(403, 'Forbidden')).toBe('403 Forbidden');
+            expect(createError(404, 'Not Found')).toBe('404 Not Found');
+            expect(createError(500, 'Internal Server Error')).toBe('500 Internal Server Error');
+        });
+    });
+    describe('config resolution pattern', function () {
+        test('uses platform-base-url from config or default', function () {
+            var DEFAULT_PLATFORM_BASE_URL = 'https://default.example.com';
+            var config1 = { 'platform-base-url': 'https://custom.example.com' };
+            var config2 = {};
+            var url1 = config1['platform-base-url'] || DEFAULT_PLATFORM_BASE_URL;
+            var url2 = config2['platform-base-url'] || DEFAULT_PLATFORM_BASE_URL;
+            expect(url1).toBe('https://custom.example.com');
+            expect(url2).toBe('https://default.example.com');
+        });
+    });
+});

package/dist/__tests__/integration.test.js

@@ -8,30 +8,13 @@ var __importDefault = (this && this.__importDefault) || function (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 () {
-        // 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);
+            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==');
@@ -39,17 +22,17 @@ describe('Bug Detection Tests', function () {
         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);
+            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 = parseEnvContent(content);
+            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 = parseEnvContent(content);
+            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);

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');
+    });
+});