@youcan/cli-kit 2.1.4 → 2.3.0

package/dist/node/system.js

@@ -1,64 +1,91 @@
-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;
-    const commandProcess = execa(command, args, {
-        env,
-        cwd: options?.cwd,
-        input: options?.input,
-        stdio: options?.stdio,
-        stdin: options?.stdin,
-        stdout: options?.stdout === 'inherit' ? 'inherit' : undefined,
-        stderr: options?.stderr === 'inherit' ? 'inherit' : undefined,
-        windowsHide: false,
-    });
-    return commandProcess;
-}
-async function exec(command, args, options) {
-    const commandProcess = buildExec(command, args, options);
-    if (options?.stderr && options.stderr !== 'inherit') {
-        commandProcess.stderr?.pipe(options.stderr, { end: false });
-    }
-    if (options?.stdout && options.stdout !== 'inherit') {
-        commandProcess.stdout?.pipe(options.stdout, { end: false });
-    }
-    let aborted = false;
-    options?.signal?.addEventListener('abort', () => {
-        const pid = commandProcess.pid;
-        if (pid) {
-            aborted = true;
-        }
-    });
-    try {
-        await commandProcess;
-    }
-    catch (err) {
-        if (aborted) {
-            return;
-        }
-        if (options?.errorHandler) {
-            await options?.errorHandler(err);
-            return;
-        }
-        throw err;
-    }
-}
-async function isPortAvailable(port) {
-    return !await tpu.check(port);
-}
-async function getPortProcessName(port) {
-    const info = await findProcess('port', port);
-    return (info && info.length > 0) ? `(${info[0]?.name})` : '';
-}
-async function killPortProcess(port) {
-    const { killPortProcess: kill } = await import('kill-port-process');
-    await kill(port);
-}
-async function open(url) {
-    const _open = await import('open');
-    await _open.default(url);
+function buildExec(command, args, options) {
+    const env = options?.env ?? process.env;
+    const commandProcess = execa(command, args, {
+        env,
+        cwd: options?.cwd,
+        input: options?.input,
+        stdio: options?.stdio,
+        stdin: options?.stdin,
+        signal: options?.signal,
+        stdout: options?.stdout === 'inherit' ? 'inherit' : undefined,
+        stderr: options?.stderr === 'inherit' ? 'inherit' : undefined,
+        windowsHide: false,
+    });
+    return commandProcess;
+}
+async function exec(command, args, options) {
+    const commandProcess = buildExec(command, args, options);
+    if (options?.stderr && options.stderr !== 'inherit') {
+        commandProcess.stderr?.pipe(options.stderr, { end: false });
+    }
+    if (options?.stdout && options.stdout !== 'inherit') {
+        commandProcess.stdout?.pipe(options.stdout, { end: false });
+    }
+    let aborted = false;
+    options?.signal?.addEventListener('abort', () => {
+        const pid = commandProcess.pid;
+        if (pid) {
+            aborted = true;
+        }
+    });
+    try {
+        await commandProcess;
+    }
+    catch (err) {
+        if (aborted) {
+            return;
+        }
+        if (options?.errorHandler) {
+            await options?.errorHandler(err);
+            return;
+        }
+        throw err;
+    }
+}
+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})` : '';
+}
+async function killPortProcess(port) {
+    const { killPortProcess: kill } = await import('kill-port-process');
+    await kill(port);
+}
+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 = {
+        '^npm/.*': 'npm',
+        '^pnpm/.*': 'pnpm',
+        '^yarn/.*': 'yarn',
+    };
+    const packageManagerUserAgent = process.env.npm_config_user_agent;
+    for (const key in packageManagersMap) {
+        if (new RegExp(key).test(packageManagerUserAgent)) {
+            return packageManagersMap[key];
+        }
+    }
+    return defaultPackageManager;
 }
 
-export { exec, getPortProcessName, isPortAvailable, killPortProcess, open };
+export { exec, getNextAvailablePort, getPortProcessName, inferUserPackageManager, isPortAvailable, killPortProcess, open, sleep };

package/dist/node/tasks.d.ts

@@ -1,7 +1,8 @@
-export interface Task<T = unknown> {
-    title: string;
-    errors?: Error[];
-    skip?: (ctx: T) => boolean;
-    task: (context: T, task: Task<T>) => Promise<void | Task<T>[]>;
-}
-export declare function run<T = unknown>(ctx: T, tasks: Task<T>[]): Promise<T>;
+export interface Task<T = unknown> {
+    title: string;
+    errors?: Error[];
+    skip?: (ctx: T) => boolean;
+    task: (context: T, task: Task<T>) => Promise<void | Task<T>[]>;
+    loadable?: false;
+}
+export declare function run<T = unknown>(ctx: T, tasks: Task<T>[]): Promise<T>;

package/dist/node/tasks.js

@@ -1,31 +1,39 @@
 import { exit } from 'node:process';
 import { Loader } from '../internal/node/ui.js';
 
-async function runTask(task, ctx) {
-    if (task.skip?.(ctx)) {
-        return;
-    }
-    return await task.task(ctx, task);
-}
-async function run(ctx, tasks) {
-    for await (const task of tasks) {
-        await Loader.exec(task.title, async (loader) => {
-            try {
-                const subtasks = await runTask(task, ctx);
-                if (Array.isArray(subtasks) && subtasks.length > 0 && subtasks.every(t => 'task' in t)) {
-                    for await (const subtask of subtasks) {
-                        await runTask(subtask, ctx);
-                    }
-                }
-                loader.stop();
-            }
-            catch (err) {
-                loader.error(String(err));
-                exit(1);
-            }
-        });
-    }
-    return ctx;
+async function runTask(task, ctx) {
+    if (task.skip?.(ctx)) {
+        return;
+    }
+    return await task.task(ctx, task);
+}
+async function run(ctx, tasks) {
+    for await (const task of tasks) {
+        const runner = async () => {
+            const subtasks = await runTask(task, ctx);
+            if (Array.isArray(subtasks) && subtasks.length > 0 && subtasks.every(t => 'task' in t)) {
+                for await (const subtask of subtasks) {
+                    await runTask(subtask, ctx);
+                }
+            }
+        };
+        if (task.loadable === false) {
+            process.stdout.write(`${task.title}\n`);
+            await runner();
+            return ctx;
+        }
+        await Loader.exec(task.title, async (loader) => {
+            try {
+                await runner();
+                loader.stop();
+            }
+            catch (err) {
+                loader.error(String(err));
+                exit(1);
+            }
+        });
+    }
+    return ctx;
 }
 
 export { run };

package/dist/node/worker.d.ts

@@ -1,19 +1,16 @@
-/// <reference types="node" />
-import { Writable } from 'stream';
-import type { Color } from '..';
-export interface Interface {
-    run(): Promise<void>;
-    boot(): Promise<void>;
-}
-export declare class Logger extends Writable {
-    private channel;
-    private type;
-    private color;
-    constructor(channel: 'stdout' | 'stderr', type: string, color: Color.Color);
-    write(chunk: unknown): boolean;
-    private pad;
-}
-export declare abstract class Abstract implements Interface {
-    abstract boot(): Promise<void>;
-    abstract run(): Promise<void>;
-}
+/// <reference types="node" />
+import { Writable } from 'stream';
+export interface Interface {
+    run(): Promise<void>;
+    boot(): Promise<void>;
+}
+export declare class Logger extends Writable {
+    private readonly type;
+    private readonly color;
+    constructor(type: string, color: 'yellow' | 'cyan' | 'magenta' | 'green' | 'blue' | 'red' | 'dim');
+    write(chunk: unknown): boolean;
+}
+export declare abstract class Abstract implements Interface {
+    abstract run(): Promise<void>;
+    abstract boot(): Promise<void>;
+}

package/dist/node/worker.js

@@ -1,36 +1,49 @@
 import { Writable } from 'node:stream';
-import { stdout, stderr } from 'node:process';
 import dayjs from 'dayjs';
+import './cli.js';
+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 './filesystem.js';
+import { renderDevOutput } from '../ui/components/DevOutput.js';
+import 'react';
+import 'ink';
 
-class Logger extends Writable {
-    channel;
-    type;
-    color;
-    constructor(channel, type, color) {
-        super();
-        this.channel = channel;
-        this.type = type;
-        this.color = color;
-    }
-    write(chunk) {
-        if (!(chunk instanceof Buffer) && typeof chunk !== 'string') {
-            return false;
-        }
-        const channel = this.channel === 'stdout' ? stdout : stderr;
-        const time = dayjs().format('HH:mm:ss:SSS');
-        const lines = chunk.toString().split('\n').map(s => s.trim()).filter(s => s !== '');
-        for (let i = 0; i < lines.length; i++) {
-            i === 0
-                ? channel.write(this.color(`${time} | ${this.pad(this.type, 10)} | ${lines[i]}\n`))
-                : channel.write(this.color(`                          | ${lines[i]}\n`));
-        }
-        return true;
-    }
-    pad(subject, length, char = ' ') {
-        return subject.padEnd(length, char);
-    }
-}
-class Abstract {
+class Logger extends Writable {
+    type;
+    color;
+    constructor(type, color) {
+        super();
+        this.type = type;
+        this.color = color;
+    }
+    write(chunk) {
+        if (!(chunk instanceof Buffer) && typeof chunk !== 'string') {
+            return false;
+        }
+        const time = dayjs().format('HH:mm:ss:SSS');
+        const lines = chunk.toString().split('\n').map(s => s.trim()).filter(s => s !== '');
+        for (const line of lines) {
+            renderDevOutput.outputSubject.emit({
+                timestamp: time,
+                color: this.color,
+                label: this.type,
+                buffer: line,
+            });
+        }
+        return true;
+    }
+}
+class Abstract {
 }
 
 export { Abstract, Logger };

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/DevOutput.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { Instance, Text } from 'ink';
+import { HotKeysPropsType } from './HotKeys';
+import { Command } from '@/node/cli';
+interface SubjectDataType {
+    timestamp: string;
+    buffer: string;
+    label: string;
+    color: Parameters<typeof Text>[0]['color'];
+}
+declare class OutputSubject {
+    private readonly subject;
+    listen(handler: (data: SubjectDataType) => void): void;
+    emit(data: SubjectDataType): void;
+    private pad;
+}
+export type DevOutputPropsType = {
+    hotKeys?: HotKeysPropsType['hotKeys'];
+    cmd: Command;
+};
+interface RenderDevOutputType {
+    (props: DevOutputPropsType): Instance;
+    outputSubject: OutputSubject;
+}
+export declare const DevOutput: ({ cmd, hotKeys }: DevOutputPropsType) => React.JSX.Element;
+declare const renderDevOutput: RenderDevOutputType;
+export { renderDevOutput };

package/dist/ui/components/DevOutput.js

@@ -0,0 +1,60 @@
+import React, { useState, useEffect } from 'react';
+import { useInput, Static, Box, Text, render } from 'ink';
+import { HotKeys } from './HotKeys.js';
+import { VerticalDivider } from './utils/symbols.js';
+import { map } from 'rxjs/operators';
+import { ReplaySubject } from 'rxjs';
+
+class OutputSubject {
+    subject = new ReplaySubject;
+    listen(handler) {
+        let lastLineKey = null;
+        this.subject.pipe(map(item => {
+            const currentLineKey = `${item.label}-${item.color}`;
+            if (currentLineKey !== lastLineKey) {
+                lastLineKey = currentLineKey;
+                return { ...item, label: this.pad(item.label, 10) };
+            }
+            return { ...item, label: this.pad('', 10) };
+        }))
+            .subscribe(handler);
+    }
+    emit(data) {
+        this.subject.next(data);
+    }
+    pad(subject, length, char = ' ') {
+        return subject.padEnd(length, char);
+    }
+}
+const outputSubject = new OutputSubject;
+const DevOutput = ({ cmd, hotKeys = [] }) => {
+    const [linesBuffers, setLinesBuffers] = useState([]);
+    useInput((input, key) => {
+        if (input === 'c' && key.ctrl)
+            cmd.exit(130);
+    });
+    useEffect(() => {
+        outputSubject.listen((data) => {
+            setLinesBuffers((previousLines) => [...previousLines, data]);
+        });
+    }, []);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Static, { items: linesBuffers }, (line, i) => (React.createElement(Box, { flexDirection: 'column', key: i },
+            React.createElement(Text, null,
+                React.createElement(Text, { dimColor: true }, line.timestamp),
+                ' ',
+                React.createElement(VerticalDivider, null),
+                ' ',
+                React.createElement(Text, { color: line.color }, line.label),
+                React.createElement(Text, null,
+                    ' ',
+                    React.createElement(VerticalDivider, null),
+                    ' ',
+                    line.buffer))))),
+        React.createElement(Box, { flexDirection: 'column', paddingTop: 1 },
+            React.createElement(HotKeys, { hotKeys: hotKeys }))));
+};
+const renderDevOutput = ((props) => render(React.createElement(DevOutput, { ...props }), { exitOnCtrlC: false }));
+renderDevOutput.outputSubject = outputSubject;
+
+export { DevOutput, renderDevOutput };