@positronic/cli 0.0.2

package/dist/src/commands/project.test.js

@@ -0,0 +1,1201 @@
+/**
+ * CLI Integration Tests - Testing Philosophy
+ *
+ * These tests are designed to be maintainable and resilient to UI changes.
+ *
+ * Key principles:
+ * 1. **Test behavior, not formatting** - Don't check for specific icons, emojis, or exact formatting
+ * 2. **Look for essential keywords only** - Focus on the minimum text that indicates success/failure
+ * 3. **Use simple assertions** - Prefer toContain() over complex regex when possible
+ * 4. **Be case-insensitive** - Use toLowerCase() to avoid breaking on capitalization changes
+ *
+ * Examples:
+ * - For success: look for "added", "switched", etc. (not specific success emojis)
+ * - For errors: look for "not found", "invalid", "already exists" (not error icons)
+ * - For data: check that project names and URLs appear, but not their exact formatting
+ *
+ * This approach ensures tests remain stable as the CLI's output formatting evolves,
+ * while still verifying that core functionality works correctly.
+ */ // Import nock to use in tests, but configuration happens in jest.setup.js
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { describe, it, expect, afterEach } from '@jest/globals';
+import { createTestEnv, px } from './test-utils.js';
+describe('CLI Integration: positronic server with project', function() {
+    it('runs a brain', function() {
+        return _async_to_generator(function() {
+            var env, px, waitForOutput, outputContainsRunId, outputContainsRunPrefix;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            createTestEnv()
+                        ];
+                    case 1:
+                        env = _state.sent();
+                        // Setup test brain
+                        env.setup(function(dir) {
+                            var brainsDir = path.join(dir, 'brains');
+                            fs.mkdirSync(brainsDir, {
+                                recursive: true
+                            });
+                            // Create a simple test brain
+                            fs.writeFileSync(path.join(brainsDir, 'test-brain.ts'), "\n        export default function testBrain() {\n          return {\n            title: 'Test Brain',\n            steps: [\n              {\n                title: 'Test Step',\n                run: async () => {\n                  return { success: true };\n                }\n              }\n            ]\n          };\n        }\n        ");
+                        });
+                        return [
+                            4,
+                            env.start()
+                        ];
+                    case 2:
+                        px = _state.sent();
+                        _state.label = 3;
+                    case 3:
+                        _state.trys.push([
+                            3,
+                            ,
+                            7,
+                            9
+                        ]);
+                        return [
+                            4,
+                            px([
+                                'run',
+                                'test-brain'
+                            ])
+                        ];
+                    case 4:
+                        waitForOutput = _state.sent().waitForOutput;
+                        return [
+                            4,
+                            waitForOutput(/Run ID:/)
+                        ];
+                    case 5:
+                        outputContainsRunId = _state.sent();
+                        return [
+                            4,
+                            waitForOutput(/run-/)
+                        ];
+                    case 6:
+                        outputContainsRunPrefix = _state.sent();
+                        expect(outputContainsRunId).toBe(true);
+                        expect(outputContainsRunPrefix).toBe(true);
+                        return [
+                            3,
+                            9
+                        ];
+                    case 7:
+                        return [
+                            4,
+                            env.stopAndCleanup()
+                        ];
+                    case 8:
+                        _state.sent();
+                        return [
+                            7
+                        ];
+                    case 9:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+});
+describe('CLI Integration: project commands', function() {
+    var tempDir;
+    var configDir;
+    beforeEach(function() {
+        // Create a temp directory for testing
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'positronic-project-test-'));
+        configDir = path.join(tempDir, '.positronic');
+    });
+    afterEach(function() {
+        // Clean up test directory
+        fs.rmSync(tempDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    describe('project add', function() {
+        it('should add a new project successfully', function() {
+            return _async_to_generator(function() {
+                var _ref, waitForOutput, instance, isReady, output, configPath, config;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'My App',
+                                    '--url',
+                                    'https://my-app.positronic.sh'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            _ref = _state.sent(), waitForOutput = _ref.waitForOutput, instance = _ref.instance;
+                            return [
+                                4,
+                                waitForOutput(/added/i)
+                            ];
+                        case 2:
+                            isReady = _state.sent();
+                            expect(isReady).toBe(true);
+                            output = instance.lastFrame();
+                            expect(output).toMatch(/my app/i);
+                            expect(output).toContain('https://my-app.positronic.sh');
+                            // Verify config file was created
+                            configPath = path.join(configDir, 'config.json');
+                            expect(fs.existsSync(configPath)).toBe(true);
+                            config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                            expect(config.projects).toHaveLength(1);
+                            expect(config.projects[0].name).toBe('My App');
+                            expect(config.currentProject).toBe('My App');
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('should reject duplicate project names', function() {
+            return _async_to_generator(function() {
+                var addFirstProject, addDuplicateProject;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'My App',
+                                    '--url',
+                                    'https://my-app.positronic.sh'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            addFirstProject = _state.sent();
+                            return [
+                                4,
+                                addFirstProject.waitForOutput(/added/i)
+                            ];
+                        case 2:
+                            expect.apply(void 0, [
+                                _state.sent()
+                            ]).toBe(true);
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'My App',
+                                    '--url',
+                                    'https://other.positronic.sh'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 3:
+                            addDuplicateProject = _state.sent();
+                            return [
+                                4,
+                                addDuplicateProject.waitForOutput(/already exists/i)
+                            ];
+                        case 4:
+                            expect.apply(void 0, [
+                                _state.sent()
+                            ]).toBe(true);
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('should reject invalid URLs', function() {
+            return _async_to_generator(function() {
+                var waitForOutput;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'My App',
+                                    '--url',
+                                    'not-a-valid-url'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            waitForOutput = _state.sent().waitForOutput;
+                            return [
+                                4,
+                                waitForOutput(/invalid/i)
+                            ];
+                        case 2:
+                            expect.apply(void 0, [
+                                _state.sent()
+                            ]).toBe(true);
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('should handle project names with spaces', function() {
+            return _async_to_generator(function() {
+                var _ref, waitForOutput, instance, config;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'My Production App',
+                                    '--url',
+                                    'https://prod.positronic.sh'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            _ref = _state.sent(), waitForOutput = _ref.waitForOutput, instance = _ref.instance;
+                            return [
+                                4,
+                                waitForOutput(/added/i)
+                            ];
+                        case 2:
+                            expect.apply(void 0, [
+                                _state.sent()
+                            ]).toBe(true);
+                            expect(instance.lastFrame()).toMatch(/my production app/i);
+                            config = JSON.parse(fs.readFileSync(path.join(configDir, 'config.json'), 'utf-8'));
+                            expect(config.projects[0].name).toBe('My Production App');
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+    });
+    describe('project list', function() {
+        it('should show empty state when no projects configured', function() {
+            return _async_to_generator(function() {
+                var instance, output;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'list'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            instance = _state.sent().instance;
+                            output = instance.lastFrame() || '';
+                            expect(output.toLowerCase()).toContain('no projects');
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('should list all projects with current indicator', function() {
+            return _async_to_generator(function() {
+                var instance, output;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            // Add some projects
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'Project One',
+                                    '--url',
+                                    'https://one.positronic.sh'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            _state.sent();
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'Project Two',
+                                    '--url',
+                                    'https://two.positronic.sh'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 2:
+                            _state.sent();
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'select',
+                                    'Project Two'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 3:
+                            _state.sent();
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'list'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 4:
+                            instance = _state.sent().instance;
+                            output = instance.lastFrame() || '';
+                            expect(output).toMatch(/project one/i);
+                            expect(output).toMatch(/project two/i);
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+    });
+    describe('project select', function() {
+        beforeEach(function() {
+            return _async_to_generator(function() {
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            // Add some projects for selection tests
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'Project Alpha',
+                                    '--url',
+                                    'https://alpha.positronic.sh'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            _state.sent();
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'Project Beta',
+                                    '--url',
+                                    'https://beta.positronic.sh'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 2:
+                            _state.sent();
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'Project Gamma',
+                                    '--url',
+                                    'https://gamma.positronic.sh'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 3:
+                            _state.sent();
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('should select a project by name', function() {
+            return _async_to_generator(function() {
+                var instance, output, config;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'select',
+                                    'Project Beta'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            instance = _state.sent().instance;
+                            output = instance.lastFrame() || '';
+                            expect(output.toLowerCase()).toMatch(/switched|selected/);
+                            expect(output).toMatch(/project beta/i);
+                            // Verify config was updated
+                            config = JSON.parse(fs.readFileSync(path.join(configDir, 'config.json'), 'utf-8'));
+                            expect(config.currentProject).toBe('Project Beta');
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('should show error for non-existent project', function() {
+            return _async_to_generator(function() {
+                var instance, output;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'select',
+                                    'Non Existent'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            instance = _state.sent().instance;
+                            output = instance.lastFrame() || '';
+                            expect(output.toLowerCase()).toContain('not found');
+                            expect(output).toMatch(/project alpha/i);
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('should show interactive selection when no name provided', function() {
+            return _async_to_generator(function() {
+                var instance, output;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'select'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            instance = _state.sent().instance;
+                            output = instance.lastFrame() || '';
+                            // In test environment, raw mode isn't supported so it shows a non-interactive list
+                            expect(output).toMatch(/project alpha/i);
+                            expect(output).toMatch(/project beta/i);
+                            expect(output).toMatch(/project gamma/i);
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+    });
+    describe('project show', function() {
+        it('should show no project selected when empty', function() {
+            return _async_to_generator(function() {
+                var instance, output;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'show'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            instance = _state.sent().instance;
+                            output = instance.lastFrame() || '';
+                            expect(output.toLowerCase()).toContain('no project');
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('should show current project details', function() {
+            return _async_to_generator(function() {
+                var instance, output;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'My Current Project',
+                                    '--url',
+                                    'https://current.positronic.sh'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            _state.sent();
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'show'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 2:
+                            instance = _state.sent().instance;
+                            output = instance.lastFrame() || '';
+                            expect(output).toMatch(/my current project/i);
+                            expect(output).toContain('https://current.positronic.sh');
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('should show other projects count when multiple exist', function() {
+            return _async_to_generator(function() {
+                var instance, output;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'Project 1',
+                                    '--url',
+                                    'https://one.positronic.sh'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            _state.sent();
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'Project 2',
+                                    '--url',
+                                    'https://two.positronic.sh'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 2:
+                            _state.sent();
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'Project 3',
+                                    '--url',
+                                    'https://three.positronic.sh'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 3:
+                            _state.sent();
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'show'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 4:
+                            instance = _state.sent().instance;
+                            output = instance.lastFrame() || '';
+                            expect(output.toLowerCase()).toContain('2 other');
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+    });
+    describe('project rm', function() {
+        beforeEach(function() {
+            return _async_to_generator(function() {
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            // Add some projects for removal tests
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'Project A',
+                                    '--url',
+                                    'https://a.positronic.sh'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            _state.sent();
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'Project B',
+                                    '--url',
+                                    'https://b.positronic.sh'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 2:
+                            _state.sent();
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'Project C',
+                                    '--url',
+                                    'https://c.positronic.sh'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 3:
+                            _state.sent();
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('should remove a project successfully', function() {
+            return _async_to_generator(function() {
+                var _ref, waitForOutput, instance, isReady, output, config;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'rm',
+                                    'Project B'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            _ref = _state.sent(), waitForOutput = _ref.waitForOutput, instance = _ref.instance;
+                            return [
+                                4,
+                                waitForOutput(/removed successfully/i)
+                            ];
+                        case 2:
+                            isReady = _state.sent();
+                            expect(isReady).toBe(true);
+                            output = instance.lastFrame() || '';
+                            expect(output).toMatch(/project b/i);
+                            // Verify project was removed from config
+                            config = JSON.parse(fs.readFileSync(path.join(configDir, 'config.json'), 'utf-8'));
+                            expect(config.projects).toHaveLength(2);
+                            expect(config.projects.find(function(p) {
+                                return p.name === 'Project B';
+                            })).toBeUndefined();
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('should handle removing the current project', function() {
+            return _async_to_generator(function() {
+                var _ref, waitForOutput, instance, isReady, output, config;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            // Select Project B as current
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'select',
+                                    'Project B'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            _state.sent();
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'rm',
+                                    'Project B'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 2:
+                            _ref = _state.sent(), waitForOutput = _ref.waitForOutput, instance = _ref.instance;
+                            return [
+                                4,
+                                waitForOutput(/removed successfully/i)
+                            ];
+                        case 3:
+                            isReady = _state.sent();
+                            expect(isReady).toBe(true);
+                            output = instance.lastFrame() || '';
+                            expect(output).toMatch(/project b/i);
+                            // Verify current project was switched to another project
+                            config = JSON.parse(fs.readFileSync(path.join(configDir, 'config.json'), 'utf-8'));
+                            expect(config.currentProject).not.toBe('Project B');
+                            expect(config.currentProject).toBeTruthy(); // Should be either Project A or Project C
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('should handle removing the last project', function() {
+            return _async_to_generator(function() {
+                var _ref, waitForOutput, instance, isReady, output, config;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            // Remove all but one project
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'rm',
+                                    'Project A'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            _state.sent();
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'rm',
+                                    'Project B'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 2:
+                            _state.sent();
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'rm',
+                                    'Project C'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 3:
+                            _ref = _state.sent(), waitForOutput = _ref.waitForOutput, instance = _ref.instance;
+                            return [
+                                4,
+                                waitForOutput(/removed successfully/i)
+                            ];
+                        case 4:
+                            isReady = _state.sent();
+                            expect(isReady).toBe(true);
+                            output = instance.lastFrame() || '';
+                            expect(output.toLowerCase()).toMatch(/no active project/);
+                            // Verify no projects remain and current project is null
+                            config = JSON.parse(fs.readFileSync(path.join(configDir, 'config.json'), 'utf-8'));
+                            expect(config.projects).toHaveLength(0);
+                            expect(config.currentProject).toBeNull();
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        it('should show error for non-existent project', function() {
+            return _async_to_generator(function() {
+                var _ref, waitForOutput, instance, isReady, output;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'rm',
+                                    'Non Existent'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            _ref = _state.sent(), waitForOutput = _ref.waitForOutput, instance = _ref.instance;
+                            return [
+                                4,
+                                waitForOutput(/failed to remove/i)
+                            ];
+                        case 2:
+                            isReady = _state.sent();
+                            expect(isReady).toBe(true);
+                            output = instance.lastFrame() || '';
+                            expect(output.toLowerCase()).toMatch(/not found/);
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+    });
+    describe('project command interactions', function() {
+        it('should maintain state across commands', function() {
+            return _async_to_generator(function() {
+                var instance, output;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            // Add multiple projects
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'First',
+                                    '--url',
+                                    'https://first.positronic.sh'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 1:
+                            _state.sent();
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'add',
+                                    'Second',
+                                    '--url',
+                                    'https://second.positronic.sh'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 2:
+                            _state.sent();
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'show'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 3:
+                            instance = _state.sent().instance;
+                            output = instance.lastFrame() || '';
+                            expect(output).toMatch(/first/i);
+                            // Switch projects
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'select',
+                                    'Second'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 4:
+                            _state.sent();
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'show'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 5:
+                            // Verify switch worked
+                            instance = _state.sent().instance;
+                            output = instance.lastFrame() || '';
+                            expect(output).toMatch(/second/i);
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'list'
+                                ], {
+                                    configDir: configDir
+                                })
+                            ];
+                        case 6:
+                            // List should show second project
+                            instance = _state.sent().instance;
+                            output = instance.lastFrame() || '';
+                            expect(output).toMatch(/second/i);
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+    });
+    describe('CLI Integration: project new', function() {
+        var tmpRoot;
+        var originalLocalPath;
+        beforeEach(function() {
+            // Set POSITRONIC_LOCAL_PATH to use local template instead of npm
+            originalLocalPath = process.env.POSITRONIC_LOCAL_PATH;
+            process.env.POSITRONIC_LOCAL_PATH = path.resolve('.');
+        });
+        afterEach(function() {
+            // Restore original environment
+            if (originalLocalPath) {
+                process.env.POSITRONIC_LOCAL_PATH = originalLocalPath;
+            } else {
+                delete process.env.POSITRONIC_LOCAL_PATH;
+            }
+            if (tmpRoot && fs.existsSync(tmpRoot)) {
+                fs.rmSync(tmpRoot, {
+                    recursive: true,
+                    force: true
+                });
+            }
+        });
+        it('should create a new project directory and output success message', function() {
+            return _async_to_generator(function() {
+                var projectDir, _ref, waitForOutput, instance, isReady, output;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'positronic-new-test-'));
+                            projectDir = path.join(tmpRoot, 'my-new-project');
+                            return [
+                                4,
+                                px([
+                                    'project',
+                                    'new',
+                                    projectDir
+                                ])
+                            ];
+                        case 1:
+                            _ref = _state.sent(), waitForOutput = _ref.waitForOutput, instance = _ref.instance;
+                            return [
+                                4,
+                                waitForOutput(/project created successfully/i, 200)
+                            ];
+                        case 2:
+                            isReady = _state.sent();
+                            expect(isReady).toBe(true);
+                            // Validate CLI output contains the project name
+                            output = instance.lastFrame() || '';
+                            expect(output.toLowerCase()).toContain('my-new-project');
+                            // Ensure project directory and essential files exist
+                            expect(fs.existsSync(projectDir)).toBe(true);
+                            expect(fs.existsSync(path.join(projectDir, 'positronic.config.json'))).toBe(true);
+                            expect(fs.existsSync(path.join(projectDir, 'package.json'))).toBe(true);
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+    });
+});