@youcan/cli-kit 2.4.0 → 2.4.3

package/dist/node/filesystem.d.ts

@@ -29,6 +29,7 @@ export declare function archived(path: string, name: string, glob?: string): Pro
 export declare function unlink(path: string): Promise<void>;
 export declare function readdir(path: string): Promise<string[]>;
 export declare function stat(path: string): Promise<Stats>;
+export declare function chmod(path: string, mode: number): Promise<void>;
 export declare const watch: typeof import("chokidar").watch;
 export declare function decompressGzip(file: string, destination: string, mode?: number): Promise<void>;
 export declare function extractTar(file: string, cwd: string, mode: number): Promise<void>;

package/dist/node/filesystem.js

@@ -121,6 +121,9 @@ async function readdir(path) {
 async function stat(path) {
     return await FilesystemPromises.stat(path);
 }
+async function chmod(path, mode) {
+    return await FilesystemPromises.chmod(path, mode);
+}
 const watch = chokidar.watch;
 async function decompressGzip(file, destination, mode = 0o755) {
     const unzip = createGunzip();
@@ -132,4 +135,4 @@ async function extractTar(file, cwd, mode) {
     await tar.extract({ cwd, file, mode });
 }
 
-export { archived, decompressGzip, exists, extractTar, glob, isDirectory, isExecutable, mkdir, move, readFile, readJsonFile, readdir, rm, stat, tapIntoTmp, unlink, watch, writeFile, writeJsonFile };
+export { archived, chmod, decompressGzip, exists, extractTar, glob, isDirectory, isExecutable, mkdir, move, readFile, readJsonFile, readdir, rm, stat, tapIntoTmp, unlink, watch, writeFile, writeJsonFile };

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

package/dist/services/cloudflared.js

@@ -8,7 +8,7 @@ import 'change-case';
 import '../node/cli.js';
 import 'conf';
 import 'env-paths';
-import { isExecutable, tapIntoTmp, mkdir, decompressGzip, extractTar, move } from '../node/filesystem.js';
+import { isExecutable, tapIntoTmp, mkdir, decompressGzip, extractTar, move, chmod } from '../node/filesystem.js';
 import 'formdata-node';
 import 'formdata-node/file-from-path';
 import 'simple-git';
@@ -85,6 +85,7 @@ async function installForLinux(url, destination) {
     const parentDir = dirname(destination);
     await mkdir(parentDir);
     await downloadFromRelease(url, destination);
+    await chmod(destination, 0o755);
 }
 async function installForWindows(url, destination) {
     const parentDir = dirname(destination);
@@ -146,6 +147,9 @@ class OutputStream extends Writable {
     clearBuffer() {
         this.buffer = '';
     }
+    getBuffer() {
+        return this.buffer;
+    }
 }
 class Cloudflared {
     bin;
@@ -163,10 +167,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)) {
@@ -174,6 +178,9 @@ class Cloudflared {
         }
         const downloadUrl = composeDownloadUrl(this.system.platform, this.system.arch);
         await install(this.system.platform, downloadUrl, this.bin);
+        if (!(await isExecutable(this.bin))) {
+            throw new Error(`Failed to install executable cloudflared binary at ${this.bin}. Check file permissions and platform compatibility.`);
+        }
     }
     composeTunnelingCommand(port, host = 'localhost') {
         return {
@@ -181,19 +188,25 @@ 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;
         }
         if (maxRetries === 0) {
-            throw new Error(this.output.extractError() ?? 'cloudflared failed for unknown reason');
+            const extractedError = this.output.extractError();
+            const errorMessage = extractedError
+                ? `cloudflared failed: ${extractedError}`
+                : `cloudflared failed for unknown reason. Binary: ${bin}, Args: ${args.join(' ')}, Buffer: ${this.output.getBuffer()}`;
+            throw new Error(errorMessage);
         }
         this.output.clearBuffer();
         await exec(bin, args, {
             // Weird choice of cloudflared to write to stderr.
             stderr: this.output,
-            errorHandler: async () => {
-                await this.exec(bin, args, maxRetries - 1);
+            signal,
+            errorHandler: async (error) => {
+                console.error(`cloudflared execution error (retries left: ${maxRetries - 1}):`, error);
+                await this.exec(bin, args, maxRetries - 1, signal);
             },
         });
     }

package/dist/services/cloudflared.test.d.ts

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

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.4.0",
+  "version": "2.4.3",
   "description": "Utilities for the YouCan CLI",
   "author": "YouCan <contact@youcan.shop> (https://youcan.shop)",
   "license": "MIT",
@@ -60,6 +60,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"
   }