@youcan/cli-kit 2.3.3 → 2.4.1

package/dist/node/session.js

@@ -73,7 +73,7 @@ async function authorize(command, state = randomHex(30)) {
         code_challenge: challenge,
         code_challenge_method: 'S256',
     };
-    await command.output.anykey('Press any key to open the login page on your browser..');
+    await command.output.anykey('Press any key to open the login page on your browser');
     const url = `http://${AUTHORIZATION_URL}/admin/oauth/authorize?${new URLSearchParams(params).toString()}`;
     open(url);
     const result = await listen(command, LS_HOST, LS_PORT, url);

package/dist/node/system.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import type { ExecaError } from 'execa';
 import type { Readable, Writable } from 'node:stream';
 export interface ExecOptions {

package/dist/node/worker.d.ts

@@ -3,6 +3,7 @@ import { Writable } from 'node:stream';
 export interface Interface {
     run: () => Promise<void>;
     boot: () => Promise<void>;
+    cleanup: () => Promise<void>;
 }
 export declare class Logger extends Writable {
     private readonly type;
@@ -13,4 +14,5 @@ export declare class Logger extends Writable {
 export declare abstract class Abstract implements Interface {
     abstract run(): Promise<void>;
     abstract boot(): Promise<void>;
+    cleanup(): Promise<void>;
 }

package/dist/node/worker.js

@@ -46,6 +46,8 @@ class Logger extends Writable {
     }
 }
 class Abstract {
+    async cleanup() {
+    }
 }
 
 export { Abstract, Logger };

package/dist/services/cloudflared.d.ts

@@ -3,8 +3,8 @@ export declare class Cloudflared {
     private readonly system;
     private readonly output;
     constructor();
-    tunnel(port: number, host?: string): Promise<void>;
-    install(): Promise<void>;
+    tunnel(port: number, host?: string, signal?: AbortSignal): Promise<void>;
+    private install;
     private composeTunnelingCommand;
     private exec;
     getUrl(): string | null;

package/dist/services/cloudflared.js

@@ -163,9 +163,10 @@ class Cloudflared {
         this.bin = resolveBinaryPath(platform);
         this.system = { platform, arch };
     }
-    async tunnel(port, host = 'localhost') {
+    async tunnel(port, host = 'localhost', signal) {
+        await this.install();
         const { bin, args } = this.composeTunnelingCommand(port, host);
-        this.exec(bin, args);
+        this.exec(bin, args, 3, signal);
     }
     async install() {
         if (await isExecutable(this.bin)) {
@@ -180,7 +181,7 @@ class Cloudflared {
             args: ['tunnel', `--url=${host}:${port}`, '--no-autoupdate'],
         };
     }
-    async exec(bin, args, maxRetries = 3) {
+    async exec(bin, args, maxRetries = 3, signal) {
         if (this.getUrl()) {
             return;
         }
@@ -191,8 +192,9 @@ class Cloudflared {
         await exec(bin, args, {
             // Weird choice of cloudflared to write to stderr.
             stderr: this.output,
+            signal,
             errorHandler: async () => {
-                await this.exec(bin, args, maxRetries - 1);
+                await this.exec(bin, args, maxRetries - 1, signal);
             },
         });
     }

package/dist/services/cloudflared.test.js

@@ -0,0 +1,114 @@
+import { vi, describe, beforeEach, afterAll, it, expect } from 'vitest';
+import 'change-case';
+import '../node/cli.js';
+import 'conf';
+import 'env-paths';
+import { isExecutable } from '../node/filesystem.js';
+import 'formdata-node';
+import 'formdata-node/file-from-path';
+import 'simple-git';
+import { exec } from '../node/system.js';
+import 'node-fetch';
+import 'ramda';
+import 'kleur';
+import 'dayjs';
+import { Cloudflared } from './cloudflared.js';
+import '../ui/components/DevOutput.js';
+import 'react';
+import 'ink';
+
+vi.mock('..', () => ({
+    System: {
+        exec: vi.fn(),
+    },
+    Filesystem: {
+        isExecutable: vi.fn(),
+    },
+    Path: {
+        join: vi.fn().mockReturnValue('/mock/path/cloudflared'),
+    },
+}));
+const originalPlatform = process.platform;
+const originalArch = process.arch;
+describe('cloudflared', () => {
+    let cloudflared;
+    let mockAbortController;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        Object.defineProperty(process, 'platform', {
+            value: 'darwin',
+            configurable: true,
+        });
+        Object.defineProperty(process, 'arch', {
+            value: 'arm64',
+            configurable: true,
+        });
+        vi.mocked(isExecutable).mockResolvedValue(true);
+        mockAbortController = new AbortController();
+        cloudflared = new Cloudflared();
+    });
+    afterAll(() => {
+        Object.defineProperty(process, 'platform', {
+            value: originalPlatform,
+            configurable: true,
+        });
+        Object.defineProperty(process, 'arch', {
+            value: originalArch,
+            configurable: true,
+        });
+    });
+    describe('tunnel', () => {
+        it('should pass abort signal to System.exec', async () => {
+            vi.mocked(exec).mockResolvedValue();
+            await cloudflared.tunnel(3000, 'localhost', mockAbortController.signal);
+            expect(exec).toHaveBeenCalledWith(expect.any(String), expect.any(Array), expect.objectContaining({
+                signal: mockAbortController.signal,
+            }));
+        });
+        it('should use correct cloudflared arguments', async () => {
+            vi.mocked(exec).mockResolvedValue();
+            await cloudflared.tunnel(3001, 'localhost', mockAbortController.signal);
+            expect(exec).toHaveBeenCalledWith(expect.any(String), ['tunnel', '--url=localhost:3001', '--no-autoupdate'], expect.any(Object));
+        });
+        it('should work without abort signal', async () => {
+            vi.mocked(exec).mockResolvedValue();
+            await expect(cloudflared.tunnel(3000)).resolves.toBeUndefined();
+            expect(exec).toHaveBeenCalledWith(expect.any(String), expect.any(Array), expect.objectContaining({
+                signal: undefined,
+            }));
+        });
+        it('should use default host when not provided', async () => {
+            vi.mocked(exec).mockResolvedValue();
+            await cloudflared.tunnel(3000, undefined, mockAbortController.signal);
+            expect(exec).toHaveBeenCalledWith(expect.any(String), ['tunnel', '--url=localhost:3000', '--no-autoupdate'], expect.any(Object));
+        });
+        it('should check if cloudflared is executable before running', async () => {
+            vi.mocked(exec).mockResolvedValue();
+            await cloudflared.tunnel(3000, 'localhost', mockAbortController.signal);
+            expect(isExecutable).toHaveBeenCalledWith('/mock/path/cloudflared');
+        });
+    });
+    describe('exec retry logic with signal', () => {
+        it('should retry with the same signal on failure', async () => {
+            let callCount = 0;
+            vi.mocked(exec).mockImplementation(async (bin, args, options) => {
+                callCount++;
+                if (callCount < 2) {
+                    if (options?.errorHandler) {
+                        await options.errorHandler(new Error('Connection failed'));
+                    }
+                }
+            });
+            await cloudflared.tunnel(3000, 'localhost', mockAbortController.signal);
+            expect(exec).toHaveBeenCalledTimes(2);
+            expect(exec).toHaveBeenNthCalledWith(1, expect.any(String), expect.any(Array), expect.objectContaining({ signal: mockAbortController.signal }));
+            expect(exec).toHaveBeenNthCalledWith(2, expect.any(String), expect.any(Array), expect.objectContaining({ signal: mockAbortController.signal }));
+        });
+        it('should handle errors without crashing', async () => {
+            vi.mocked(exec).mockResolvedValue();
+            await expect(cloudflared.tunnel(3000, 'localhost', mockAbortController.signal))
+                .resolves
+                .toBeUndefined();
+        });
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@youcan/cli-kit",
   "type": "module",
-  "version": "2.3.3",
+  "version": "2.4.1",
   "description": "Utilities for the YouCan CLI",
   "author": "YouCan <contact@youcan.shop> (https://youcan.shop)",
   "license": "MIT",
@@ -60,8 +60,9 @@
   "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",
-    "postinstall": "node -e \"import('fs').then(fs => { if (fs.existsSync('./dist/scripts/install-cloudflared.js')) import('./dist/scripts/install-cloudflared.js'); });\""
+    "type-check": "tsc --noEmit"
   }
 }

package/dist/scripts/install-cloudflared.js

@@ -1,25 +0,0 @@
-import 'change-case';
-import '../node/cli.js';
-import 'conf';
-import 'env-paths';
-import '../node/filesystem.js';
-import 'formdata-node';
-import 'formdata-node/file-from-path';
-import 'simple-git';
-import 'execa';
-import 'find-process';
-import 'get-port';
-import 'tcp-port-used';
-import 'node-fetch';
-import 'ramda';
-import 'kleur';
-import 'dayjs';
-import { Cloudflared } from '../services/cloudflared.js';
-import '../ui/components/DevOutput.js';
-import 'react';
-import 'ink';
-
-const cloudflared = new Cloudflared();
-console.log('Installing Cloudflared...');
-await cloudflared.install();
-console.log('Successfully Installed Cloudflared');