@youcan/cli-kit 2.2.0 → 2.3.1

package/dist/index.d.ts

@@ -14,5 +14,6 @@ export * as Session from './node/session';
 export * as Callback from './node/callback';
 export * as Filesystem from './node/filesystem';
 export * as UI from './ui';
+export * as Services from './services';
 export * as String from './common/string';
 export { default as Color } from 'kleur';

package/dist/index.js

@@ -30,6 +30,8 @@ import * as filesystem from './node/filesystem.js';
 export { filesystem as Filesystem };
 import * as index from './ui/index.js';
 export { index as UI };
+import * as index$1 from './services/index.js';
+export { index$1 as Services };
 import * as string from './common/string.js';
 export { string as String };
 export { default as Color } from 'kleur';

package/dist/internal/node/ui.js

@@ -18,6 +18,7 @@ class Loader {
         return this;
     }
     flush() {
+        process.stdout.write('\x1B[?25h');
         if (this.timer) {
             clearInterval(this.timer);
             this.timer = null;

package/dist/node/cli.d.ts

@@ -18,4 +18,8 @@ export declare abstract class Command extends BaseCommand {
     clear(): void;
     exit(code?: number): never;
 }
+export declare class CommandError extends Error {
+    readonly suggestions?: string[] | undefined;
+    constructor(message: string, suggestions?: string[] | undefined);
+}
 export {};

package/dist/node/cli.js

@@ -1,5 +1,23 @@
 import { Flags, Command as Command$1, ux } from '@oclif/core';
 import prompts from 'prompts';
+import 'simple-git';
+import 'find-process';
+import 'tcp-port-used';
+import 'execa';
+import 'env-paths';
+import 'node-fetch';
+import 'ramda';
+import 'change-case';
+import 'formdata-node';
+import 'formdata-node/file-from-path';
+import 'kleur';
+import 'conf';
+import 'dayjs';
+import './filesystem.js';
+import '../ui/components/DevOutput.js';
+import 'react';
+import 'ink';
+import { renderError } from '../ui/components/Error.js';
 import { truthy } from './context/helpers.js';
 import { isDevelopment } from './context/local.js';
 
@@ -19,17 +37,27 @@ function setupColorMode() {
         process.env.FORCE_COLOR = '0';
     }
 }
+function errorHandler(error) {
+    let suggestions = ['Run the command again'];
+    const message = error.message;
+    if (error instanceof CommandError && error.suggestions) {
+        suggestions = error.suggestions;
+    }
+    renderError({ message, suggestions });
+    process.exit(1);
+}
 async function exec(options) {
     setupEnvVars(options);
     setupColorMode();
-    const { run, settings, flush, Errors } = await import('@oclif/core');
+    const { run, settings, flush } = await import('@oclif/core');
     if (isDevelopment()) {
         settings.debug = true;
     }
     run(undefined, options.moduleUrl)
         .then(() => flush())
-        .catch(err => Errors.handle(err));
+        .catch(errorHandler);
 }
+process.on('uncaughtException', errorHandler);
 async function execCreate(cmdlet, options) {
     setupEnvVars(options);
     const initIndex = process.argv
@@ -65,5 +93,12 @@ class Command extends Command$1 {
         return process.exit(code);
     }
 }
+class CommandError extends Error {
+    suggestions;
+    constructor(message, suggestions) {
+        super(message);
+        this.suggestions = suggestions;
+    }
+}
 
-export { Command, commonFlags, exec, execCreate };
+export { Command, CommandError, commonFlags, exec, execCreate };

package/dist/node/filesystem.d.ts

@@ -4,9 +4,11 @@
 import type { Mode, OpenMode, PathLike, Stats } from 'fs';
 import type { GlobOptions } from 'glob';
 export declare function exists(path: string): Promise<boolean>;
+export declare function isExecutable(path: string): Promise<boolean>;
 export declare function isDirectory(path: string): Promise<boolean>;
 export declare function tapIntoTmp<T>(callback: (tmp: string) => T | Promise<T>): Promise<T>;
 export declare function mkdir(path: string): Promise<void>;
+export declare function rm(path: string): Promise<void>;
 interface MoveFileOptions {
     overwrite?: boolean;
 }
@@ -27,4 +29,6 @@ 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 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>;
 export {};

package/dist/node/filesystem.js

@@ -1,15 +1,18 @@
 import FilesystemPromises from 'node:fs/promises';
-import { createWriteStream } from 'node:fs';
+import { createGunzip } from 'node:zlib';
+import { pipeline } from 'node:stream/promises';
+import { createWriteStream, createReadStream } from 'node:fs';
 import { temporaryDirectoryTask } from 'tempy';
 import FsExtra from 'fs-extra';
 import archiver from 'archiver';
 import chokidar from 'chokidar';
 import { glob as glob$1 } from 'glob';
+import * as tar from 'tar';
 import './cli.js';
 import 'simple-git';
-import 'execa';
-import 'tcp-port-used';
 import 'find-process';
+import 'tcp-port-used';
+import 'execa';
 import 'env-paths';
 import { resolve } from './path.js';
 import 'node-fetch';
@@ -33,6 +36,18 @@ async function exists(path) {
         return false;
     }
 }
+async function isExecutable(path) {
+    if (!await exists(path)) {
+        return false;
+    }
+    try {
+        await FilesystemPromises.access(path, FilesystemPromises.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 async function isDirectory(path) {
     try {
         const stats = await FilesystemPromises.stat(path);
@@ -48,6 +63,9 @@ async function tapIntoTmp(callback) {
 async function mkdir(path) {
     await FilesystemPromises.mkdir(path, { recursive: true });
 }
+async function rm(path) {
+    await FilesystemPromises.rm(path, { recursive: true });
+}
 async function move(src, dest, options = {}) {
     await FsExtra.move(src, dest, options);
 }
@@ -103,5 +121,14 @@ async function stat(path) {
     return await FilesystemPromises.stat(path);
 }
 const watch = chokidar.watch;
+async function decompressGzip(file, destination, mode = 0o755) {
+    const unzip = createGunzip();
+    const readStream = createReadStream(file);
+    const writeStream = createWriteStream(destination, { mode });
+    await pipeline(readStream, unzip, writeStream);
+}
+async function extractTar(file, cwd, mode) {
+    await tar.extract({ cwd, file, mode });
+}
 
-export { archived, exists, glob, isDirectory, mkdir, move, readFile, readJsonFile, readdir, stat, tapIntoTmp, unlink, watch, writeFile, writeJsonFile };
+export { archived, decompressGzip, exists, extractTar, glob, isDirectory, isExecutable, mkdir, move, readFile, readJsonFile, readdir, rm, stat, tapIntoTmp, unlink, watch, writeFile, writeJsonFile };

package/dist/node/http.js

@@ -2,9 +2,9 @@ import fetch from 'node-fetch';
 import { is, mergeDeepLeft } from 'ramda';
 import './cli.js';
 import 'simple-git';
-import 'execa';
-import 'tcp-port-used';
 import 'find-process';
+import 'tcp-port-used';
+import 'execa';
 import { get as get$1 } from './env.js';
 import 'formdata-node';
 import 'formdata-node/file-from-path';

package/dist/node/system.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import type { Readable, Writable } from 'stream';
+import type { ExecaError } from 'execa';
 export interface ExecOptions {
     cwd?: string;
     env?: {
@@ -12,12 +13,14 @@ export interface ExecOptions {
     stdio?: 'inherit';
     input?: string;
     signal?: AbortSignal;
-    errorHandler?: (error: unknown) => Promise<void>;
+    errorHandler?: (error: unknown | ExecaError) => Promise<void>;
 }
 export declare function exec(command: string, args: string[], options?: ExecOptions): Promise<void>;
 export declare function isPortAvailable(port: number): Promise<boolean>;
+export declare function getNextAvailablePort(port: number): Promise<number>;
 export declare function getPortProcessName(port: number): Promise<string>;
 export declare function killPortProcess(port: number): Promise<void>;
 export declare function open(url: string): Promise<void>;
+export declare function sleep(seconds: number): Promise<void>;
 export type PackageManagerType = 'pnpm' | 'npm' | 'yarn';
 export declare function inferUserPackageManager(): PackageManagerType;

package/dist/node/system.js

@@ -1,6 +1,6 @@
-import { execa } from 'execa';
-import tpu from 'tcp-port-used';
 import findProcess from 'find-process';
+import tpu from 'tcp-port-used';
+import { execa } from 'execa';
 
 function buildExec(command, args, options) {
     const env = options?.env ?? process.env;
@@ -49,6 +49,12 @@ async function exec(command, args, options) {
 async function isPortAvailable(port) {
     return !await tpu.check(port);
 }
+async function getNextAvailablePort(port) {
+    if (await isPortAvailable(port)) {
+        return port;
+    }
+    return await getNextAvailablePort(port + 1);
+}
 async function getPortProcessName(port) {
     const info = await findProcess('port', port);
     return (info && info.length > 0) ? `(${info[0]?.name})` : '';
@@ -61,6 +67,11 @@ async function open(url) {
     const _open = await import('open');
     await _open.default(url);
 }
+async function sleep(seconds) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, 1000 * seconds);
+    });
+}
 function inferUserPackageManager() {
     const defaultPackageManager = 'npm';
     const packageManagersMap = {
@@ -77,4 +88,4 @@ function inferUserPackageManager() {
     return defaultPackageManager;
 }
 
-export { exec, getPortProcessName, inferUserPackageManager, isPortAvailable, killPortProcess, open };
+export { exec, getNextAvailablePort, getPortProcessName, inferUserPackageManager, isPortAvailable, killPortProcess, open, sleep };

package/dist/node/worker.js

@@ -2,9 +2,9 @@ import { Writable } from 'node:stream';
 import dayjs from 'dayjs';
 import './cli.js';
 import 'simple-git';
-import 'execa';
-import 'tcp-port-used';
 import 'find-process';
+import 'tcp-port-used';
+import 'execa';
 import 'env-paths';
 import 'node-fetch';
 import 'ramda';

package/dist/services/cloudflared.d.ts

@@ -0,0 +1,12 @@
+export declare class Cloudflared {
+    private readonly bin;
+    private readonly system;
+    private readonly output;
+    constructor();
+    tunnel(port: number, host?: string): Promise<void>;
+    private install;
+    private composeTunnelingCommand;
+    private exec;
+    getUrl(): string | null;
+    getError(): string | null;
+}

package/dist/services/cloudflared.js

@@ -0,0 +1,206 @@
+import { Writable, Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { createWriteStream } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import '../node/cli.js';
+import 'simple-git';
+import { exec } from '../node/system.js';
+import 'env-paths';
+import { join, dirname, basename, resolve } from '../node/path.js';
+import 'node-fetch';
+import 'ramda';
+import 'change-case';
+import 'formdata-node';
+import 'formdata-node/file-from-path';
+import 'kleur';
+import 'conf';
+import 'dayjs';
+import { isExecutable, tapIntoTmp, mkdir, decompressGzip, extractTar, move } from '../node/filesystem.js';
+import '../ui/components/DevOutput.js';
+import 'react';
+import 'ink';
+
+const LINUX_TARGET_NAMES = {
+    arm64: 'cloudflared-linux-arm64',
+    arm: 'cloudflared-linux-arm',
+    x64: 'cloudflared-linux-amd64',
+    ia32: 'cloudflared-linux-386',
+};
+const MACOS_TARGET_NAMES = {
+    arm64: 'cloudflared-darwin-arm64.tgz',
+    x64: 'cloudflared-darwin-amd64.tgz',
+};
+const WINDOWS_TARGET_NAMES = {
+    x64: 'cloudflared-windows-amd64.exe',
+    ia32: 'cloudflared-windows-386.exe',
+    arm64: 'cloudflared-windows-amd64.exe',
+};
+const TARGET_NAMES = {
+    linux: LINUX_TARGET_NAMES,
+    darwin: MACOS_TARGET_NAMES,
+    win32: WINDOWS_TARGET_NAMES,
+};
+function composeDownloadUrl(platform, arch) {
+    const releaseDownloadUrl = 'https://github.com/cloudflare/cloudflared/releases/download';
+    const supportedVersion = '2024.11.1';
+    const filename = TARGET_NAMES[platform][arch];
+    return `${releaseDownloadUrl}/${supportedVersion}/${filename}`;
+}
+function resolveBinaryPath(platform) {
+    const rootDir = fileURLToPath(new URL('../'.repeat(2), import.meta.url));
+    return join(rootDir, 'bin', platform === 'win32' ? 'cloudflared.exe' : 'cloudflared');
+}
+function isPlatformSupported(platform) {
+    return platform in TARGET_NAMES;
+}
+function isArchSupported(arch, platform) {
+    return arch in TARGET_NAMES[platform];
+}
+async function downloadFromRelease(url, downloadPath) {
+    const response = await fetch(url, { redirect: 'follow' });
+    if (!response.ok) {
+        throw new Error(`failed to download cloudflared: ${response.statusText}`);
+    }
+    const { body } = response;
+    const fileWriteStream = createWriteStream(downloadPath, { mode: 0o664 });
+    await pipeline(Readable.fromWeb(body), fileWriteStream);
+}
+async function installForMacOs(url, destination) {
+    await tapIntoTmp(async (tmpDir) => {
+        const parentDir = dirname(destination);
+        const binaryName = basename(destination);
+        const downloadedFile = resolve(tmpDir, `${binaryName}.tgz`);
+        const decompressedFile = resolve(tmpDir, `${binaryName}.gz`);
+        await mkdir(parentDir);
+        await mkdir(tmpDir);
+        await downloadFromRelease(url, downloadedFile);
+        await decompressGzip(downloadedFile, decompressedFile);
+        await extractTar(decompressedFile, tmpDir, 0o755);
+        await move(resolve(tmpDir, binaryName), destination, { overwrite: true });
+    });
+}
+async function installForLinux(url, destination) {
+    const parentDir = dirname(destination);
+    await mkdir(parentDir);
+    await downloadFromRelease(url, destination);
+}
+async function installForWindows(url, destination) {
+    const parentDir = dirname(destination);
+    mkdir(parentDir);
+    await downloadFromRelease(url, destination);
+}
+async function install(platform, downloadUrl, destinationPath) {
+    switch (platform) {
+        case 'darwin':
+            await installForMacOs(downloadUrl, destinationPath);
+            break;
+        case 'linux':
+            await installForLinux(downloadUrl, destinationPath);
+            break;
+        case 'win32':
+            await installForWindows(downloadUrl, destinationPath);
+            break;
+    }
+}
+class OutputStream extends Writable {
+    tunnelUrl = null;
+    tunnelError = null;
+    buffer = '';
+    static ErrorsRegex = [
+        /failed to build quick tunnel request/,
+        /failed to request quick Tunnel/,
+        /failed to read quick-tunnel response/,
+        /failed to parse quick Tunnel ID/,
+        /Couldn't start tunnel/,
+    ];
+    write(chunk, encoding, callback) {
+        if (!(chunk instanceof Buffer) && typeof chunk !== 'string') {
+            return false;
+        }
+        this.buffer += chunk.toString();
+        if (this.tunnelUrl === null) {
+            this.tunnelUrl = this.extractTunnelUrl();
+        }
+        if (callback && typeof callback === 'function') {
+            callback();
+        }
+        return true;
+    }
+    extractTunnelUrl() {
+        const regex = /https:\/\/(?!api\.trycloudflare\.com)[^\s]+\.trycloudflare\.com/;
+        return this.buffer.match(regex)?.[0] || null;
+    }
+    extractError() {
+        for (const errorRegex of OutputStream.ErrorsRegex) {
+            if (errorRegex.test(this.buffer)) {
+                return errorRegex.source;
+            }
+        }
+        return null;
+    }
+    getTunnelUrl() {
+        return this.tunnelUrl;
+    }
+    clearBuffer() {
+        this.buffer = '';
+    }
+}
+class Cloudflared {
+    bin;
+    system;
+    output = new OutputStream();
+    constructor() {
+        const platform = process.platform;
+        const arch = process.arch;
+        if (!isPlatformSupported(platform)) {
+            throw new Error(`unsupported platform: ${platform}`);
+        }
+        if (!isArchSupported(arch, platform)) {
+            throw new Error(`unsupported architecture: ${arch}`);
+        }
+        this.bin = resolveBinaryPath(platform);
+        this.system = { platform, arch };
+    }
+    async tunnel(port, host = 'localhost') {
+        await this.install();
+        const { bin, args } = this.composeTunnelingCommand(port, host);
+        this.exec(bin, args);
+    }
+    async install() {
+        if (await isExecutable(this.bin)) {
+            return;
+        }
+        const downloadUrl = composeDownloadUrl(this.system.platform, this.system.arch);
+        await install(this.system.platform, downloadUrl, this.bin);
+    }
+    composeTunnelingCommand(port, host = 'localhost') {
+        return {
+            bin: this.bin,
+            args: ['tunnel', `--url=${host}:${port}`, '--no-autoupdate'],
+        };
+    }
+    async exec(bin, args, maxRetries = 3) {
+        if (this.getUrl()) {
+            return;
+        }
+        if (maxRetries === 0) {
+            throw new Error(this.output.extractError() ?? 'cloudflared failed for unknown reason');
+        }
+        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);
+            },
+        });
+    }
+    getUrl() {
+        return this.output.getTunnelUrl();
+    }
+    getError() {
+        return this.output.extractError();
+    }
+}
+
+export { Cloudflared };

package/dist/services/index.d.ts

@@ -0,0 +1 @@
+export * from './cloudflared';

package/dist/services/index.js

@@ -0,0 +1 @@
+export { Cloudflared } from './cloudflared.js';

package/dist/ui/components/Error.d.ts

@@ -0,0 +1,6 @@
+type ErrorPropsType = {
+    message: string;
+    suggestions?: string[];
+};
+export declare const renderError: (props: ErrorPropsType) => import("ink").Instance;
+export {};

package/dist/ui/components/Error.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { render, Newline, Box, Text } from 'ink';
+
+const Error = ({ message, suggestions = [] }) => {
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Newline, null),
+        React.createElement(Box, { flexDirection: 'column', borderStyle: 'round', borderColor: 'red', paddingLeft: 1 },
+            React.createElement(Text, { color: 'redBright' }, "Error"),
+            React.createElement(Text, { color: 'white' }, message),
+            suggestions.length > 0 && (React.createElement(Box, { marginTop: 1, flexDirection: 'column' },
+                React.createElement(Text, { color: 'yellow' }, "Suggestions:"),
+                suggestions.map((suggestion, index) => (React.createElement(Text, { key: index },
+                    " - ",
+                    suggestion))))))));
+};
+const renderError = (props) => render(React.createElement(Error, { ...props }));
+
+export { renderError };

package/dist/ui/index.d.ts

@@ -1,2 +1,3 @@
 export { renderDevOutput } from './components/DevOutput';
 export { renderHotKeys } from './components/HotKeys';
+export { renderError } from './components/Error';

package/dist/ui/index.js

@@ -1,2 +1,3 @@
 export { renderDevOutput } from './components/DevOutput.js';
 export { renderHotKeys } from './components/HotKeys.js';
+export { renderError } from './components/Error.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@youcan/cli-kit",
   "type": "module",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "description": "Utilities for the YouCan CLI",
   "author": "YouCan <contact@youcan.shop> (https://youcan.shop)",
   "license": "MIT",
@@ -41,6 +41,7 @@
     "react": "^18.3.1",
     "rxjs": "^7.8.1",
     "simple-git": "^3.20.0",
+    "tar": "^7.4.3",
     "tcp-port-used": "^1.0.2",
     "tempy": "^3.1.0",
     "worker": "^0.4.0"