@youcan/cli-kit 2.8.0 → 2.8.2

package/dist/node/http.js

@@ -1,57 +1,51 @@
-import https from 'node:https';
-import process from 'node:process';
-import { isJson } from '../common/string.js';
-import fetch from 'node-fetch';
-import { is, mergeDeepLeft } from 'ramda';
-import './cli.js';
-import 'conf';
-import { get as get$2 } from './env.js';
-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 { get as get$1 } from './session.js';
-import 'kleur';
-import 'dayjs';
-import '../ui/components/DevOutput.js';
-import 'react';
-import 'ink';
-
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { isJson } from "../common/string.js";
+import { get as get$1 } from "./env.js";
+import { get as get$2 } from "./session.js";
+import "../index.js";
+import process from "node:process";
+import https from "node:https";
+import fetch from "node-fetch";
+import { is, mergeDeepLeft } from "ramda";
+//#region lib/node/http.ts
+var http_exports = /* @__PURE__ */ __exportAll({
+	get: () => get,
+	post: () => post
+});
 async function agent() {
-    if (get$2('HOST_ENV') === 'dev') {
-        process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
-    }
-    return new https.Agent({ keepAlive: true, keepAliveMsecs: 5 * 60 * 1000 });
+	if (get$1("HOST_ENV") === "dev") process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+	return new https.Agent({
+		keepAlive: true,
+		keepAliveMsecs: 300 * 1e3
+	});
 }
 async function defaults() {
-    const session$1 = await get$1();
-    return {
-        agent: await agent(),
-        headers: {
-            Accept: 'application/json',
-            Authorization: session$1 ? `Bearer ${session$1.access_token}` : undefined,
-        },
-    };
+	const session = await get$2();
+	return {
+		agent: await agent(),
+		headers: {
+			Accept: "application/json",
+			Authorization: session ? `Bearer ${session.access_token}` : void 0
+		}
+	};
 }
 async function request(endpoint, options = {}) {
-    if (is(String)(options.body) && isJson(options.body)) {
-        options = mergeDeepLeft(options, { headers: { 'Content-Type': 'application/json' } });
-    }
-    const response = await fetch(endpoint, mergeDeepLeft(options, await defaults()));
-    if (!response.ok) {
-        throw new Error(await response.text(), { cause: response });
-    }
-    return response.json();
+	if (is(String)(options.body) && isJson(options.body)) options = mergeDeepLeft(options, { headers: { "Content-Type": "application/json" } });
+	const response = await fetch(endpoint, mergeDeepLeft(options, await defaults()));
+	if (!response.ok) throw new Error(await response.text(), { cause: response });
+	return response.json();
 }
 async function get(endpoint, options = {}) {
-    return request(`https://${endpoint}`, { ...options, method: 'GET' });
+	return request(`https://${endpoint}`, {
+		...options,
+		method: "GET"
+	});
 }
 async function post(endpoint, options = {}) {
-    return request(`https://${endpoint}`, { ...options, method: 'POST' });
+	return request(`https://${endpoint}`, {
+		...options,
+		method: "POST"
+	});
 }
-
-export { get, post };
+//#endregion
+export { get, http_exports, post };

package/dist/node/path.js

@@ -1,20 +1,28 @@
-import path from 'node:path';
-import process from 'node:process';
-
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import process from "node:process";
+import path from "node:path";
+//#region lib/node/path.ts
+var path_exports = /* @__PURE__ */ __exportAll({
+	basename: () => basename,
+	cwd: () => cwd,
+	dirname: () => dirname,
+	join: () => join,
+	resolve: () => resolve
+});
 function resolve(...paths) {
-    return path.resolve(...paths);
+	return path.resolve(...paths);
 }
 function cwd() {
-    return path.normalize(process.env.INIT_CWD ? process.env.INIT_CWD : process.cwd());
+	return path.normalize(process.env.INIT_CWD ? process.env.INIT_CWD : process.cwd());
 }
 function join(...paths) {
-    return path.join(...paths);
+	return path.join(...paths);
 }
 function dirname(filepath) {
-    return path.dirname(filepath);
+	return path.dirname(filepath);
 }
 function basename(filepath) {
-    return path.basename(filepath);
+	return path.basename(filepath);
 }
-
-export { basename, cwd, dirname, join, resolve };
+//#endregion
+export { basename, cwd, dirname, join, path_exports, resolve };

package/dist/node/session.js

@@ -1,111 +1,92 @@
-import 'change-case';
-import { listen } from './callback.js';
-import './cli.js';
-import { manager } from './config.js';
-import { randomHex, sha256, base64URLEncode } from './crypto.js';
-import { apiHostname, sellerAreaHostname, oauthClientId } from './env.js';
-import './filesystem.js';
-import 'formdata-node';
-import 'formdata-node/file-from-path';
-import 'simple-git';
-import { isPortAvailable, getPortProcessName, killPortProcess, open } from './system.js';
-import { get as get$1, post } from './http.js';
-import 'kleur';
-import 'dayjs';
-import '../ui/components/DevOutput.js';
-import 'react';
-import 'ink';
-
-const LS_PORT = 3000;
-const LS_HOST = 'localhost';
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { listen } from "./callback.js";
+import { manager } from "./config.js";
+import { base64URLEncode, randomHex, sha256 } from "./crypto.js";
+import { apiHostname, oauthClientId, sellerAreaHostname } from "./env.js";
+import { getPortProcessName, isPortAvailable, killPortProcess, open } from "./system.js";
+import { get as get$1, post } from "./http.js";
+import "../index.js";
+//#region lib/node/session.ts
+var session_exports = /* @__PURE__ */ __exportAll({
+	authenticate: () => authenticate,
+	get: () => get
+});
+const LS_PORT = 3e3;
+const LS_HOST = "localhost";
 function generatePkcePair(length) {
-    const verifier = randomHex(length);
-    const encoder = new TextEncoder();
-    const data = encoder.encode(verifier);
-    const hash = sha256(data);
-    return [verifier, base64URLEncode(hash)];
+	const verifier = randomHex(length);
+	return [verifier, base64URLEncode(sha256(new TextEncoder().encode(verifier)))];
 }
 async function isSessionValid(session) {
-    try {
-        const store = await get$1(`${apiHostname()}/me`, { headers: { Authorization: `Bearer ${session.access_token}` } });
-        return store.status === 1;
-    }
-    catch (err) {
-        return false;
-    }
+	try {
+		return (await get$1(`${apiHostname()}/me`, { headers: { Authorization: `Bearer ${session.access_token}` } })).status === 1;
+	} catch (err) {
+		return false;
+	}
 }
 async function exchange(code, verifier) {
-    const params = {
-        code,
-        client_id: oauthClientId(),
-        grant_type: 'authorization_code',
-        redirect_uri: `http://${LS_HOST}:${LS_PORT}/`,
-        code_verifier: verifier,
-    };
-    const result = await post(`${apiHostname()}/oauth/token`, {
-        body: new URLSearchParams(Object.entries(params)),
-        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-    });
-    return result.access_token;
+	const params = {
+		code,
+		client_id: oauthClientId(),
+		grant_type: "authorization_code",
+		redirect_uri: `http://${LS_HOST}:${LS_PORT}/`,
+		code_verifier: verifier
+	};
+	return (await post(`${apiHostname()}/oauth/token`, {
+		body: new URLSearchParams(Object.entries(params)),
+		headers: { "Content-Type": "application/x-www-form-urlencoded" }
+	})).access_token;
 }
 async function authorize(command, state = randomHex(30)) {
-    const AUTHORIZATION_URL = sellerAreaHostname();
-    if (!await isPortAvailable(LS_PORT)) {
-        command.output.warn(`Port ${LS_PORT} is unavailable, but it is required for authentication.`);
-        const { confirmed } = await command.prompt({
-            type: 'confirm',
-            name: 'confirmed',
-            initial: true,
-            message: `Would you like to terminate ${await getPortProcessName(LS_PORT)}?`,
-        });
-        if (!confirmed) {
-            throw new Error('Exiting..');
-        }
-        await killPortProcess(LS_PORT);
-    }
-    const [verifier, challenge] = await generatePkcePair(64);
-    const params = {
-        state,
-        response_type: 'code',
-        scope: '*',
-        client_id: oauthClientId(),
-        redirect_uri: `http://${LS_HOST}:${LS_PORT}/`,
-        code_challenge: challenge,
-        code_challenge_method: 'S256',
-    };
-    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);
-    if (result.state !== state) {
-        throw new Error('Authorization state mismatch..');
-    }
-    return { code: result.code, verifier };
+	const AUTHORIZATION_URL = sellerAreaHostname();
+	if (!await isPortAvailable(LS_PORT)) {
+		command.output.warn(`Port ${LS_PORT} is unavailable, but it is required for authentication.`);
+		const { confirmed } = await command.prompt({
+			type: "confirm",
+			name: "confirmed",
+			initial: true,
+			message: `Would you like to terminate ${await getPortProcessName(LS_PORT)}?`
+		});
+		if (!confirmed) throw new Error("Exiting..");
+		await killPortProcess(LS_PORT);
+	}
+	const [verifier, challenge] = await generatePkcePair(64);
+	const params = {
+		state,
+		response_type: "code",
+		scope: "*",
+		client_id: oauthClientId(),
+		redirect_uri: `http://${LS_HOST}:${LS_PORT}/`,
+		code_challenge: challenge,
+		code_challenge_method: "S256"
+	};
+	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);
+	if (result.state !== state) throw new Error("Authorization state mismatch..");
+	return {
+		code: result.code,
+		verifier
+	};
 }
 async function get() {
-    return manager({ projectName: 'youcan-cli' })
-        .get('store_session') ?? null;
+	return manager({ projectName: "youcan-cli" }).get("store_session") ?? null;
 }
 async function authenticate(command) {
-    const existingSession = manager({ projectName: 'youcan-cli' })
-        .get('store_session');
-    if (existingSession && await isSessionValid(existingSession)) {
-        return existingSession;
-    }
-    const { code, verifier } = await authorize(command);
-    const accessToken = await exchange(code, verifier);
-    const store = await get$1(`${apiHostname()}/me`, { headers: { Authorization: `Bearer ${accessToken}` } });
-    if (!store.is_dev) {
-        throw new Error('The CLI can only be used with dev stores, you create one through YouCan Partners.');
-    }
-    const session = {
-        slug: store.slug,
-        id: store.id,
-        access_token: accessToken,
-    };
-    manager({ projectName: 'youcan-cli' })
-        .set('store_session', session);
-    return session;
+	const existingSession = manager({ projectName: "youcan-cli" }).get("store_session");
+	if (existingSession && await isSessionValid(existingSession)) return existingSession;
+	const { code, verifier } = await authorize(command);
+	const accessToken = await exchange(code, verifier);
+	const store = await get$1(`${apiHostname()}/me`, { headers: { Authorization: `Bearer ${accessToken}` } });
+	if (!store.is_dev) throw new Error("The CLI can only be used with dev stores, you create one through YouCan Partners.");
+	const session = {
+		slug: store.slug,
+		id: store.id,
+		access_token: accessToken
+	};
+	manager({ projectName: "youcan-cli" }).set("store_session", session);
+	return session;
 }
-
-export { authenticate, get };
+//#endregion
+export { authenticate, get, session_exports };

package/dist/node/system.js

@@ -1,121 +1,105 @@
-import process from 'node:process';
-import { execa } from 'execa';
-import findProcess from 'find-process';
-import getPort, { portNumbers } from 'get-port';
-import tpu from 'tcp-port-used';
-
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import process from "node:process";
+import { execa } from "execa";
+import findProcess from "find-process";
+import getPort, { portNumbers } from "get-port";
+import tpu from "tcp-port-used";
+//#region lib/node/system.ts
+var system_exports = /* @__PURE__ */ __exportAll({
+	exec: () => exec,
+	getPortOrNextOrRandom: () => getPortOrNextOrRandom,
+	getPortProcessName: () => getPortProcessName,
+	inferUserPackageManager: () => inferUserPackageManager,
+	isPortAvailable: () => isPortAvailable,
+	killPortProcess: () => killPortProcess,
+	open: () => open,
+	sleep: () => sleep
+});
 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;
+	return execa(command, args, {
+		env: options?.env ?? process.env,
+		cwd: options?.cwd,
+		input: options?.input,
+		stdio: options?.stdio,
+		stdin: options?.stdin,
+		signal: options?.signal,
+		stdout: options?.stdout === "inherit" ? "inherit" : void 0,
+		stderr: options?.stderr === "inherit" ? "inherit" : void 0,
+		windowsHide: false
+	});
 }
 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;
-    process.once('SIGINT', () => {
-        if (commandProcess.pid) {
-            try {
-                commandProcess.kill('SIGTERM');
-            }
-            catch (err) {
-            }
-        }
-    });
-    process.once('SIGTERM', () => {
-        if (commandProcess.pid) {
-            try {
-                commandProcess.kill('SIGTERM');
-            }
-            catch (err) {
-            }
-        }
-    });
-    options?.signal?.addEventListener('abort', () => {
-        const pid = commandProcess.pid;
-        if (pid) {
-            aborted = true;
-            try {
-                const killProcess = () => {
-                    try {
-                        commandProcess.kill('SIGKILL');
-                    }
-                    catch (err) {
-                    }
-                };
-                commandProcess.kill('SIGTERM');
-                setTimeout(killProcess, 500);
-            }
-            catch (err) {
-            }
-        }
-    });
-    try {
-        await commandProcess;
-    }
-    catch (err) {
-        if (aborted) {
-            return;
-        }
-        if (options?.errorHandler) {
-            await options?.errorHandler(err);
-            return;
-        }
-        throw err;
-    }
+	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;
+	process.once("SIGINT", () => {
+		if (commandProcess.pid) try {
+			commandProcess.kill("SIGTERM");
+		} catch (err) {}
+	});
+	process.once("SIGTERM", () => {
+		if (commandProcess.pid) try {
+			commandProcess.kill("SIGTERM");
+		} catch (err) {}
+	});
+	options?.signal?.addEventListener("abort", () => {
+		if (commandProcess.pid) {
+			aborted = true;
+			try {
+				const killProcess = () => {
+					try {
+						commandProcess.kill("SIGKILL");
+					} catch (err) {}
+				};
+				commandProcess.kill("SIGTERM");
+				setTimeout(killProcess, 500);
+			} catch (err) {}
+		}
+	});
+	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);
+	return !await tpu.check(port);
 }
 async function getPortOrNextOrRandom(port) {
-    return await getPort({ port: portNumbers(port, port + 1000) });
+	return await getPort({ port: portNumbers(port, port + 1e3) });
 }
 async function getPortProcessName(port) {
-    const info = await findProcess('port', port);
-    return (info && info.length > 0) ? `(${info[0]?.name})` : '';
+	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);
+	const { killPortProcess: kill } = await import("kill-port-process");
+	await kill(port);
 }
 async function open(url) {
-    const _open = await import('open');
-    await _open.default(url);
+	await (await import("open")).default(url);
 }
 async function sleep(seconds) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, 1000 * seconds);
-    });
+	return new Promise((resolve) => {
+		setTimeout(resolve, 1e3 * 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;
+	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, getPortOrNextOrRandom, getPortProcessName, inferUserPackageManager, isPortAvailable, killPortProcess, open, sleep };
+//#endregion
+export { exec, getPortOrNextOrRandom, getPortProcessName, inferUserPackageManager, isPortAvailable, killPortProcess, open, sleep, system_exports };

package/dist/node/tasks.js

@@ -1,39 +1,34 @@
-import process, { exit } from 'node:process';
-import { Loader } from '../internal/node/ui.js';
-
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { Loader } from "../internal/node/ui.js";
+import process, { exit } from "node:process";
+//#region lib/node/tasks.ts
+var tasks_exports = /* @__PURE__ */ __exportAll({ run: () => run });
 async function runTask(task, ctx) {
-    if (task.skip?.(ctx)) {
-        return;
-    }
-    return await task.task(ctx, task);
+	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;
+	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 };
+//#endregion
+export { run, tasks_exports };