@youcan/cli-kit 2.8.0 → 2.8.2

package/dist/node/worker.js

@@ -1,53 +1,37 @@
-import { Buffer } from 'node:buffer';
-import { Writable } from 'node:stream';
-import dayjs from 'dayjs';
-import 'change-case';
-import './cli.js';
-import 'conf';
-import 'env-paths';
-import './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 { renderDevOutput } from '../ui/components/DevOutput.js';
-import 'react';
-import 'ink';
-
-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 {
-    async cleanup() {
-    }
-}
-
-export { Abstract, Logger };
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { renderDevOutput } from "../ui/components/DevOutput.js";
+import "../index.js";
+import { Buffer } from "node:buffer";
+import { Writable } from "node:stream";
+import dayjs from "dayjs";
+//#region lib/node/worker.ts
+var worker_exports = /* @__PURE__ */ __exportAll({
+	Abstract: () => Abstract,
+	Logger: () => Logger
+});
+var Logger = class 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;
+	}
+};
+var Abstract = class {
+	async cleanup() {}
+};
+//#endregion
+export { Abstract, Logger, worker_exports };

package/dist/services/cloudflared.js

@@ -1,221 +1,180 @@
-import { Buffer } from 'node:buffer';
-import { createWriteStream } from 'node:fs';
-import process from 'node:process';
-import { Writable, Readable } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
-import { fileURLToPath } from 'node:url';
-import 'change-case';
-import '../node/cli.js';
-import 'conf';
-import 'env-paths';
-import { isExecutable, mkdir, chmod, tapIntoTmp, decompressGzip, extractTar, move } 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 { join, dirname, basename, resolve } from '../node/path.js';
-import 'kleur';
-import 'dayjs';
-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',
-};
+import { chmod, decompressGzip, extractTar, isExecutable, mkdir, move, tapIntoTmp } from "../node/filesystem.js";
+import { exec } from "../node/system.js";
+import { basename, dirname, join, resolve } from "../node/path.js";
+import "../index.js";
+import process from "node:process";
+import { createWriteStream } from "node:fs";
+import { pipeline } from "node:stream/promises";
+import { Buffer } from "node:buffer";
+import { Readable, Writable } from "node:stream";
+import { fileURLToPath } from "node:url";
+//#region lib/services/cloudflared.ts
 const TARGET_NAMES = {
-    linux: LINUX_TARGET_NAMES,
-    darwin: MACOS_TARGET_NAMES,
-    win32: WINDOWS_TARGET_NAMES,
+	linux: {
+		arm64: "cloudflared-linux-arm64",
+		arm: "cloudflared-linux-arm",
+		x64: "cloudflared-linux-amd64",
+		ia32: "cloudflared-linux-386"
+	},
+	darwin: {
+		arm64: "cloudflared-darwin-arm64.tgz",
+		x64: "cloudflared-darwin-amd64.tgz"
+	},
+	win32: {
+		x64: "cloudflared-windows-amd64.exe",
+		ia32: "cloudflared-windows-386.exe",
+		arm64: "cloudflared-windows-amd64.exe"
+	}
 };
 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}`;
+	return `https://github.com/cloudflare/cloudflared/releases/download/2024.11.1/${TARGET_NAMES[platform][arch]}`;
 }
 function resolveBinaryPath(platform) {
-    const rootDir = fileURLToPath(new URL('../'.repeat(2), import.meta.url));
-    return join(rootDir, 'bin', platform === 'win32' ? 'cloudflared.exe' : 'cloudflared');
+	return join(fileURLToPath(new URL("../".repeat(2), import.meta.url)), "bin", platform === "win32" ? "cloudflared.exe" : "cloudflared");
 }
 function isPlatformSupported(platform) {
-    return platform in TARGET_NAMES;
+	return platform in TARGET_NAMES;
 }
 function isArchSupported(arch, platform) {
-    return arch in TARGET_NAMES[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);
+	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: 436 });
+	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 });
-    });
+	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, 493);
+		await move(resolve(tmpDir, binaryName), destination, { overwrite: true });
+	});
 }
 async function installForLinux(url, destination) {
-    const parentDir = dirname(destination);
-    await mkdir(parentDir);
-    await downloadFromRelease(url, destination);
-    await chmod(destination, 0o755);
+	await mkdir(dirname(destination));
+	await downloadFromRelease(url, destination);
+	await chmod(destination, 493);
 }
 async function installForWindows(url, destination) {
-    const parentDir = dirname(destination);
-    mkdir(parentDir);
-    await downloadFromRelease(url, destination);
+	mkdir(dirname(destination));
+	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 = '';
-    }
-    getBuffer() {
-        return this.buffer;
-    }
+	switch (platform) {
+		case "darwin":
+			await installForMacOs(downloadUrl, destinationPath);
+			break;
+		case "linux":
+			await installForLinux(downloadUrl, destinationPath);
+			break;
+		case "win32":
+			await installForWindows(downloadUrl, destinationPath);
+			break;
+	}
 }
-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', signal) {
-        await this.install();
-        const { bin, args } = this.composeTunnelingCommand(port, host);
-        this.exec(bin, args, 3, signal);
-    }
-    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);
-        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 {
-            bin: this.bin,
-            args: ['tunnel', `--url=${host}:${port}`, '--no-autoupdate'],
-        };
-    }
-    async exec(bin, args, maxRetries = 3, signal) {
-        if (this.getUrl()) {
-            return;
-        }
-        if (maxRetries === 0) {
-            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,
-            signal,
-            errorHandler: async (error) => {
-                console.error(`cloudflared execution error (retries left: ${maxRetries - 1}):`, error);
-                await this.exec(bin, args, maxRetries - 1, signal);
-            },
-        });
-    }
-    getUrl() {
-        return this.output.getTunnelUrl();
-    }
-    getError() {
-        return this.output.extractError();
-    }
-}
-
+var OutputStream = 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() {
+		return this.buffer.match(/https:\/\/(?!api\.trycloudflare\.com)\S+\.trycloudflare\.com/)?.[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 = "";
+	}
+	getBuffer() {
+		return this.buffer;
+	}
+};
+var Cloudflared = class {
+	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", signal) {
+		await this.install();
+		const { bin, args } = this.composeTunnelingCommand(port, host);
+		this.exec(bin, args, 3, signal);
+	}
+	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);
+		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 {
+			bin: this.bin,
+			args: [
+				"tunnel",
+				`--url=${host}:${port}`,
+				"--no-autoupdate"
+			]
+		};
+	}
+	async exec(bin, args, maxRetries = 3, signal) {
+		if (this.getUrl()) return;
+		if (maxRetries === 0) {
+			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, {
+			stderr: this.output,
+			signal,
+			errorHandler: async (error) => {
+				console.error(`cloudflared execution error (retries left: ${maxRetries - 1}):`, error);
+				await this.exec(bin, args, maxRetries - 1, signal);
+			}
+		});
+	}
+	getUrl() {
+		return this.output.getTunnelUrl();
+	}
+	getError() {
+		return this.output.extractError();
+	}
+};
+//#endregion
 export { Cloudflared };