@youcan/app 2.4.0 → 2.4.1

package/dist/cli/commands/app/dev.js

@@ -13,13 +13,16 @@ class Dev extends AppCommand {
         this.setupExitHandlers();
     }
     setupExitHandlers() {
-        const cleanupAndExit = () => {
+        const cleanupAndExit = async () => {
             try {
+                console.log('Shutting down...');
+                if (this.workers.length > 0) {
+                    await Promise.allSettled(this.workers.map(worker => worker.cleanup()));
+                }
                 if (this.controller) {
                     this.controller.abort();
                 }
                 this.workers = [];
-                console.log('Shutting down...');
                 setTimeout(() => {
                     process.exit(0);
                 }, 100);
@@ -31,7 +34,10 @@ class Dev extends AppCommand {
         process.once('SIGINT', cleanupAndExit);
         process.once('SIGTERM', cleanupAndExit);
         process.once('SIGQUIT', cleanupAndExit);
-        process.once('exit', () => {
+        process.once('exit', async () => {
+            if (this.workers.length > 0) {
+                await Promise.allSettled(this.workers.map(worker => worker.cleanup()));
+            }
             if (this.controller) {
                 this.controller.abort();
             }
@@ -46,13 +52,16 @@ class Dev extends AppCommand {
         {
             keyboardKey: 'q',
             description: 'quit',
-            handler: () => {
+            handler: async () => {
                 try {
+                    console.log('Shutting down...');
+                    if (this.workers.length > 0) {
+                        await Promise.allSettled(this.workers.map(worker => worker.cleanup()));
+                    }
                     if (this.controller) {
                         this.controller.abort();
                     }
                     this.workers = [];
-                    console.log('Shutting down...');
                     setTimeout(() => {
                         process.exit(0);
                     }, 100);
@@ -106,6 +115,10 @@ class Dev extends AppCommand {
     }
     async reloadWorkers() {
         this.controller = new AbortController();
+        if (this.workers.length > 0) {
+            await Promise.allSettled(this.workers.map(worker => worker.cleanup()));
+            this.workers = [];
+        }
         const networkConfig = this.app.network_config;
         this.app = await load();
         this.app.network_config = networkConfig;
@@ -113,6 +126,7 @@ class Dev extends AppCommand {
         await this.runWorkers(await this.prepareDevProcesses());
     }
     async runWorkers(workers) {
+        this.workers = workers;
         await Promise.all(workers.map(worker => worker.run())).catch((_) => { });
     }
     async prepareDevProcesses() {

package/dist/cli/commands/app/dev.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/commands/app/dev.test.js

@@ -0,0 +1,164 @@
+import { vi, describe, beforeEach, it, expect } from 'vitest';
+import Dev from './dev.js';
+
+vi.mock('@/util/app-loader', () => ({
+    load: vi.fn().mockResolvedValue({
+        root: '/test/app',
+        config: { id: 'test-app' },
+        webs: [],
+        extensions: [],
+    }),
+}));
+vi.mock('@youcan/cli-kit', () => ({
+    Session: {
+        authenticate: vi.fn().mockResolvedValue({}),
+    },
+    Tasks: {
+        run: vi.fn().mockResolvedValue({ workers: [] }),
+    },
+    UI: {
+        renderDevOutput: vi.fn(),
+    },
+    System: {
+        getPortOrNextOrRandom: vi.fn().mockResolvedValue(3000),
+    },
+    Services: {
+        Cloudflared: vi.fn(),
+    },
+    Filesystem: {
+        writeJsonFile: vi.fn(),
+    },
+    Path: {
+        join: vi.fn(),
+    },
+    Cli: {
+        Command: class MockCommand {
+            controller = { abort: vi.fn(), signal: new AbortController().signal };
+            output = { wait: vi.fn() };
+        },
+    },
+    Env: {},
+    Http: {},
+    Worker: {
+        Interface: class MockInterface {
+            async run() { }
+            async boot() { }
+            async cleanup() { }
+        },
+        Abstract: class MockAbstract {
+            async run() { }
+            async boot() { }
+            async cleanup() { }
+        },
+    },
+}));
+vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+const mockOnce = vi.spyOn(process, 'once').mockImplementation(() => process);
+describe('dev Command', () => {
+    let devCommand;
+    let mockWorkers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockWorkers = [
+            {
+                run: vi.fn(),
+                boot: vi.fn(),
+                cleanup: vi.fn().mockResolvedValue(undefined),
+            },
+            {
+                run: vi.fn(),
+                boot: vi.fn(),
+                cleanup: vi.fn().mockResolvedValue(undefined),
+            },
+        ];
+        devCommand = new Dev([], {});
+        devCommand.workers = mockWorkers;
+    });
+    describe('setupExitHandlers', () => {
+        it('should register signal handlers for graceful shutdown', () => {
+            devCommand.setupExitHandlers();
+            expect(mockOnce).toHaveBeenCalledWith('SIGINT', expect.any(Function));
+            expect(mockOnce).toHaveBeenCalledWith('SIGTERM', expect.any(Function));
+            expect(mockOnce).toHaveBeenCalledWith('SIGQUIT', expect.any(Function));
+            expect(mockOnce).toHaveBeenCalledWith('exit', expect.any(Function));
+        });
+    });
+    describe('cleanup functionality', () => {
+        it('should cleanup all workers when cleanupAndExit is called', async () => {
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            devCommand.setupExitHandlers();
+            const sigintCall = mockOnce.mock.calls.find(call => call[0] === 'SIGINT');
+            const cleanupAndExit = sigintCall?.[1];
+            if (cleanupAndExit) {
+                await cleanupAndExit();
+            }
+            expect(consoleSpy).toHaveBeenCalledWith('Shutting down...');
+            expect(mockWorkers[0].cleanup).toHaveBeenCalled();
+            expect(mockWorkers[1].cleanup).toHaveBeenCalled();
+            consoleSpy.mockRestore();
+        });
+        it('should handle worker cleanup errors gracefully', async () => {
+            const failingWorker = {
+                run: vi.fn(),
+                boot: vi.fn(),
+                cleanup: vi.fn().mockRejectedValue(new Error('Cleanup failed')),
+            };
+            devCommand.workers = [failingWorker];
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            devCommand.setupExitHandlers();
+            const sigintCall = mockOnce.mock.calls.find(call => call[0] === 'SIGINT');
+            const cleanupAndExit = sigintCall?.[1];
+            if (cleanupAndExit) {
+                await expect(cleanupAndExit()).resolves.toBeUndefined();
+            }
+            expect(failingWorker.cleanup).toHaveBeenCalled();
+            consoleSpy.mockRestore();
+        });
+    });
+    describe('reloadWorkers', () => {
+        it('should cleanup existing workers before reload', async () => {
+            const mockController = {
+                abort: vi.fn(),
+                signal: new AbortController().signal,
+            };
+            devCommand.controller = mockController;
+            devCommand.app = {
+                network_config: { app_port: 3000 },
+            };
+            devCommand.syncAppConfig = vi.fn().mockResolvedValue(undefined);
+            devCommand.prepareDevProcesses = vi.fn().mockResolvedValue([]);
+            devCommand.runWorkers = vi.fn().mockResolvedValue(undefined);
+            await devCommand.reloadWorkers();
+            expect(mockWorkers[0].cleanup).toHaveBeenCalled();
+            expect(mockWorkers[1].cleanup).toHaveBeenCalled();
+        });
+    });
+    describe('runWorkers', () => {
+        it('should store workers in instance variable', async () => {
+            const newWorkers = [
+                {
+                    run: vi.fn().mockResolvedValue(undefined),
+                    boot: vi.fn(),
+                    cleanup: vi.fn(),
+                },
+            ];
+            await devCommand.runWorkers(newWorkers);
+            expect(devCommand.workers).toBe(newWorkers);
+            expect(newWorkers[0].run).toHaveBeenCalled();
+        });
+    });
+    describe('hotkey handlers', () => {
+        it('should cleanup workers when q key is pressed', async () => {
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            const hotKeys = devCommand.hotKeys;
+            const quitHandler = hotKeys.find((key) => key.keyboardKey === 'q')?.handler;
+            if (quitHandler) {
+                await quitHandler();
+            }
+            expect(consoleSpy).toHaveBeenCalledWith('Shutting down...');
+            expect(mockWorkers[0].cleanup).toHaveBeenCalled();
+            expect(mockWorkers[1].cleanup).toHaveBeenCalled();
+            consoleSpy.mockRestore();
+        });
+    });
+});

package/dist/cli/services/dev/workers/app-worker.d.ts

@@ -5,7 +5,9 @@ export default class AppWorker extends Worker.Abstract {
     private command;
     private app;
     private logger;
+    private watcher?;
     constructor(command: DevCommand, app: App);
     boot(): Promise<void>;
     run(): Promise<void>;
+    cleanup(): Promise<void>;
 }

package/dist/cli/services/dev/workers/app-worker.js

@@ -5,6 +5,7 @@ class AppWorker extends Worker.Abstract {
     command;
     app;
     logger;
+    watcher;
     constructor(command, app) {
         super();
         this.command = command;
@@ -15,20 +16,27 @@ class AppWorker extends Worker.Abstract {
     async run() {
         await this.command.output.wait(500);
         this.logger.write('watching for config updates...');
-        const watcher = Filesystem.watch(Path.resolve(this.app.root, APP_CONFIG_FILENAME), {
+        this.watcher = Filesystem.watch(Path.resolve(this.app.root, APP_CONFIG_FILENAME), {
             persistent: true,
             ignoreInitial: true,
             awaitWriteFinish: {
                 stabilityThreshold: 50,
             },
         });
-        watcher.once('change', async () => {
-            await watcher.close();
+        this.watcher.once('change', async () => {
+            await this.watcher?.close();
             this.logger.write('config update detected, reloading workers...');
             this.command.controller.abort();
             this.command.reloadWorkers();
         });
     }
+    async cleanup() {
+        this.logger.write('stopping config watcher...');
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = undefined;
+        }
+    }
 }
 
 export { AppWorker as default };

package/dist/cli/services/dev/workers/app-worker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/services/dev/workers/app-worker.test.js

@@ -0,0 +1,103 @@
+import { Filesystem, Path } from '@youcan/cli-kit';
+import { vi, describe, beforeEach, it, expect } from 'vitest';
+import AppWorker from './app-worker.js';
+
+vi.mock('@youcan/cli-kit', () => ({
+    Filesystem: {
+        watch: vi.fn(),
+    },
+    Path: {
+        resolve: vi.fn(),
+    },
+    Worker: {
+        Logger: class MockLogger {
+            name;
+            color;
+            constructor(name, color) {
+                this.name = name;
+                this.color = color;
+            }
+            write = vi.fn();
+        },
+        Abstract: class MockAbstract {
+            async cleanup() { }
+        },
+    },
+}));
+describe('appWorker', () => {
+    let appWorker;
+    let mockCommand;
+    let mockApp;
+    let mockWatcher;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockWatcher = {
+            close: vi.fn(),
+            once: vi.fn(),
+        };
+        vi.mocked(Filesystem.watch).mockReturnValue(mockWatcher);
+        vi.mocked(Path.resolve).mockReturnValue('/path/to/app.config.json');
+        mockCommand = {
+            output: {
+                wait: vi.fn().mockResolvedValue(undefined),
+            },
+            controller: {
+                abort: vi.fn(),
+            },
+            reloadWorkers: vi.fn(),
+        };
+        mockApp = {
+            root: '/path/to/app',
+        };
+        appWorker = new AppWorker(mockCommand, mockApp);
+    });
+    describe('cleanup', () => {
+        it('should close the file watcher if it exists', async () => {
+            await appWorker.run();
+            expect(Filesystem.watch).toHaveBeenCalled();
+            await appWorker.cleanup();
+            expect(mockWatcher.close).toHaveBeenCalled();
+        });
+        it('should handle cleanup when no watcher exists', async () => {
+            await expect(appWorker.cleanup()).resolves.toBeUndefined();
+        });
+        it('should log cleanup message', async () => {
+            await appWorker.run();
+            await appWorker.cleanup();
+            const logger = appWorker.logger;
+            expect(logger.write).toHaveBeenCalledWith('stopping config watcher...');
+        });
+        it('should set watcher to undefined after cleanup', async () => {
+            await appWorker.run();
+            expect(appWorker.watcher).toBe(mockWatcher);
+            await appWorker.cleanup();
+            expect(appWorker.watcher).toBeUndefined();
+        });
+    });
+    describe('run', () => {
+        it('should create a file watcher for the app config', async () => {
+            await appWorker.run();
+            expect(Path.resolve).toHaveBeenCalledWith('/path/to/app', 'youcan.app.json');
+            expect(Filesystem.watch).toHaveBeenCalledWith('/path/to/app.config.json', {
+                persistent: true,
+                ignoreInitial: true,
+                awaitWriteFinish: {
+                    stabilityThreshold: 50,
+                },
+            });
+        });
+        it('should set up change handler that reloads workers', async () => {
+            await appWorker.run();
+            expect(mockWatcher.once).toHaveBeenCalledWith('change', expect.any(Function));
+            const changeHandler = mockWatcher.once.mock.calls[0][1];
+            await changeHandler();
+            expect(mockWatcher.close).toHaveBeenCalled();
+            expect(mockCommand.controller.abort).toHaveBeenCalled();
+            expect(mockCommand.reloadWorkers).toHaveBeenCalled();
+        });
+        it('should wait 500ms before starting to watch', async () => {
+            await appWorker.run();
+            expect(mockCommand.output.wait).toHaveBeenCalledWith(500);
+        });
+    });
+});

package/dist/cli/services/dev/workers/tunnel-worker.d.ts

@@ -11,6 +11,7 @@ export default class TunnelWorker extends Worker.Abstract {
     constructor(command: AppCommand, app: App, tunnelService: Services.Cloudflared);
     boot(): Promise<void>;
     run(): Promise<void>;
+    cleanup(): Promise<void>;
     private checkForError;
     getUrl(): string;
 }

package/dist/cli/services/dev/workers/tunnel-worker.js

@@ -18,7 +18,7 @@ class TunnelWorker extends Worker.Abstract {
             throw new Error('app network config is not set');
         }
         this.logger.write('start tunneling the app');
-        await this.tunnelService.tunnel(this.app.network_config.app_port);
+        await this.tunnelService.tunnel(this.app.network_config.app_port, 'localhost', this.command.controller.signal);
         let attempts = 0;
         while (!this.url && attempts <= 28) {
             const url = this.tunnelService.getUrl();
@@ -37,6 +37,10 @@ class TunnelWorker extends Worker.Abstract {
     async run() {
         setInterval(() => this.checkForError, 500);
     }
+    async cleanup() {
+        this.logger.write('stopping tunnel...');
+        // The abort signal passed to cloudflared will handle process termination
+    }
     checkForError() {
         const error = this.tunnelService.getError();
         if (error) {

package/dist/cli/services/dev/workers/web-worker.d.ts

@@ -6,7 +6,9 @@ export default class WebWorker extends Worker.Abstract {
     private readonly web;
     private readonly env;
     private logger;
+    private processPort?;
     constructor(command: Cli.Command, app: App, web: Web, env: Record<string, string>);
     boot(): Promise<void>;
     run(): Promise<void>;
+    cleanup(): Promise<void>;
 }

package/dist/cli/services/dev/workers/web-worker.js

@@ -6,6 +6,7 @@ class WebWorker extends Worker.Abstract {
     web;
     env;
     logger;
+    processPort;
     constructor(command, app, web, env) {
         super();
         this.command = command;
@@ -13,6 +14,7 @@ class WebWorker extends Worker.Abstract {
         this.web = web;
         this.env = env;
         this.logger = new Worker.Logger(this.web.config.name || 'web', 'blue');
+        this.processPort = this.env.PORT ? Number.parseInt(this.env.PORT, 10) : undefined;
     }
     async boot() {
     }
@@ -25,6 +27,20 @@ class WebWorker extends Worker.Abstract {
             env: this.env,
         });
     }
+    async cleanup() {
+        this.logger.write('stopping web server...');
+        if (this.processPort) {
+            try {
+                if (!await System.isPortAvailable(this.processPort)) {
+                    await System.killPortProcess(this.processPort);
+                    this.logger.write(`killed process on port ${this.processPort}`);
+                }
+            }
+            catch (error) {
+                // Ignore errors when killing port process
+            }
+        }
+    }
 }
 
 export { WebWorker as default };

package/dist/cli/services/dev/workers/web-worker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/services/dev/workers/web-worker.test.js

@@ -0,0 +1,101 @@
+import { System } from '@youcan/cli-kit';
+import { vi, describe, beforeEach, it, expect } from 'vitest';
+import WebWorker from './web-worker.js';
+
+vi.mock('@youcan/cli-kit', () => ({
+    System: {
+        exec: vi.fn(),
+        isPortAvailable: vi.fn(),
+        killPortProcess: vi.fn(),
+    },
+    Worker: {
+        Logger: class MockLogger {
+            name;
+            color;
+            constructor(name, color) {
+                this.name = name;
+                this.color = color;
+            }
+            write = vi.fn();
+        },
+        Abstract: class MockAbstract {
+            async cleanup() { }
+        },
+    },
+}));
+describe('webWorker', () => {
+    let webWorker;
+    let mockCommand;
+    let mockApp;
+    let mockWeb;
+    let mockEnv;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockCommand = {
+            controller: {
+                signal: new AbortController().signal,
+            },
+        };
+        mockApp = {};
+        mockWeb = {
+            config: {
+                name: 'test-web',
+                commands: {
+                    dev: 'npm start',
+                },
+            },
+        };
+        mockEnv = {
+            PORT: '3001',
+            NODE_ENV: 'development',
+        };
+        webWorker = new WebWorker(mockCommand, mockApp, mockWeb, mockEnv);
+    });
+    describe('cleanup', () => {
+        it('should kill process on the assigned port when port is not available', async () => {
+            vi.mocked(System.isPortAvailable).mockResolvedValue(false);
+            vi.mocked(System.killPortProcess).mockResolvedValue();
+            await webWorker.cleanup();
+            expect(System.isPortAvailable).toHaveBeenCalledWith(3001);
+            expect(System.killPortProcess).toHaveBeenCalledWith(3001);
+        });
+        it('should not kill process when port is already available', async () => {
+            vi.mocked(System.isPortAvailable).mockResolvedValue(true);
+            await webWorker.cleanup();
+            expect(System.isPortAvailable).toHaveBeenCalledWith(3001);
+            expect(System.killPortProcess).not.toHaveBeenCalled();
+        });
+        it('should handle missing PORT environment variable gracefully', async () => {
+            const webWorkerWithoutPort = new WebWorker(mockCommand, mockApp, mockWeb, { NODE_ENV: 'development' });
+            await expect(webWorkerWithoutPort.cleanup()).resolves.toBeUndefined();
+            expect(System.isPortAvailable).not.toHaveBeenCalled();
+            expect(System.killPortProcess).not.toHaveBeenCalled();
+        });
+        it('should handle killPortProcess errors gracefully', async () => {
+            vi.mocked(System.isPortAvailable).mockResolvedValue(false);
+            vi.mocked(System.killPortProcess).mockRejectedValue(new Error('Process not found'));
+            await expect(webWorker.cleanup()).resolves.toBeUndefined();
+            expect(System.killPortProcess).toHaveBeenCalledWith(3001);
+        });
+        it('should log cleanup messages', async () => {
+            vi.mocked(System.isPortAvailable).mockResolvedValue(false);
+            vi.mocked(System.killPortProcess).mockResolvedValue();
+            await webWorker.cleanup();
+            const logger = webWorker.logger;
+            expect(logger.write).toHaveBeenCalledWith('stopping web server...');
+            expect(logger.write).toHaveBeenCalledWith('killed process on port 3001');
+        });
+    });
+    describe('run', () => {
+        it('should execute the web command with correct parameters', async () => {
+            vi.mocked(System.exec).mockResolvedValue();
+            await webWorker.run();
+            expect(System.exec).toHaveBeenCalledWith('npm', ['start'], {
+                stdout: expect.any(Object),
+                signal: mockCommand.controller.signal,
+                stderr: expect.any(Object),
+                env: mockEnv,
+            });
+        });
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@youcan/app",
   "type": "module",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "OCLIF plugin for building apps",
   "author": "YouCan <contact@youcan.shop> (https://youcan.shop)",
   "license": "MIT",
@@ -17,7 +17,7 @@
   "dependencies": {
     "@oclif/core": "^2.15.0",
     "dayjs": "^1.11.10",
-    "@youcan/cli-kit": "2.4.0"
+    "@youcan/cli-kit": "2.4.1"
   },
   "devDependencies": {
     "@oclif/plugin-legacy": "^1.3.0",
@@ -35,6 +35,8 @@
   "scripts": {
     "build": "shx rm -rf dist && tsc --noEmit && rollup --config rollup.config.js",
     "dev": "shx rm -rf dist && rollup --config rollup.config.js --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "release": "pnpm publish --access public",
     "type-check": "tsc --noEmit"
   }