@youcan/cli-kit 2.1.3 → 2.2.0

package/dist/node/github.js

@@ -1,11 +1,11 @@
-function parseRepositoryReference(reference) {
-    const url = new URL(reference);
-    const [, user, repo, ...repoPath] = url.pathname.split('/');
-    return {
-        baseUrl: `${url.origin}/${user}/${repo}`,
-        branch: url.hash ? url.hash.slice(1) : undefined,
-        path: repoPath.length > 0 ? repoPath.join('/') : undefined,
-    };
+function parseRepositoryReference(reference) {
+    const url = new URL(reference);
+    const [, user, repo, ...repoPath] = url.pathname.split('/');
+    return {
+        baseUrl: `${url.origin}/${user}/${repo}`,
+        branch: url.hash ? url.hash.slice(1) : undefined,
+        path: repoPath.length > 0 ? repoPath.join('/') : undefined,
+    };
 }
 
 export { parseRepositoryReference };

package/dist/node/http.d.ts

@@ -1,4 +1,4 @@
-import type { RequestInit } from 'node-fetch';
-export declare function scheme(): 'http' | 'https';
-export declare function get<T>(endpoint: string, options?: RequestInit): Promise<T>;
-export declare function post<T>(endpoint: string, options?: RequestInit): Promise<T>;
+import type { RequestInit } from 'node-fetch';
+export declare function scheme(): 'http' | 'https';
+export declare function get<T>(endpoint: string, options?: RequestInit): Promise<T>;
+export declare function post<T>(endpoint: string, options?: RequestInit): Promise<T>;

package/dist/node/http.js

@@ -13,40 +13,43 @@ import 'conf';
 import 'dayjs';
 import { get as get$2 } from './session.js';
 import './filesystem.js';
+import '../ui/components/DevOutput.js';
+import 'react';
+import 'ink';
 import { isJson } from '../common/string.js';
 
-function scheme() {
-    return get$1('HOST_ENV') === 'dev' ? 'http' : 'https';
-}
-async function agent() {
-    const { Agent } = await import(scheme());
-    return new Agent({ keepAlive: true, keepAliveMsecs: 5 * 60 * 1000 });
-}
-async function defaults() {
-    const session$1 = await get$2();
-    return {
-        agent: await agent(),
-        headers: {
-            Accept: 'application/json',
-            Authorization: session$1 ? `Bearer ${session$1.access_token}` : undefined,
-        },
-    };
-}
-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();
-}
-async function get(endpoint, options = {}) {
-    return request(`${scheme()}://${endpoint}`, { ...options, method: 'GET' });
-}
-async function post(endpoint, options = {}) {
-    return request(`${scheme()}://${endpoint}`, { ...options, method: 'POST' });
+function scheme() {
+    return get$1('HOST_ENV') === 'dev' ? 'http' : 'https';
+}
+async function agent() {
+    const { Agent } = await import(scheme());
+    return new Agent({ keepAlive: true, keepAliveMsecs: 5 * 60 * 1000 });
+}
+async function defaults() {
+    const session$1 = await get$2();
+    return {
+        agent: await agent(),
+        headers: {
+            Accept: 'application/json',
+            Authorization: session$1 ? `Bearer ${session$1.access_token}` : undefined,
+        },
+    };
+}
+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();
+}
+async function get(endpoint, options = {}) {
+    return request(`${scheme()}://${endpoint}`, { ...options, method: 'GET' });
+}
+async function post(endpoint, options = {}) {
+    return request(`${scheme()}://${endpoint}`, { ...options, method: 'POST' });
 }
 
 export { get, post, scheme };

package/dist/node/path.d.ts

@@ -1,5 +1,5 @@
-export declare function resolve(...paths: string[]): string;
-export declare function cwd(): string;
-export declare function join(...paths: string[]): string;
-export declare function dirname(filepath: string): string;
-export declare function basename(filepath: string): string;
+export declare function resolve(...paths: string[]): string;
+export declare function cwd(): string;
+export declare function join(...paths: string[]): string;
+export declare function dirname(filepath: string): string;
+export declare function basename(filepath: string): string;

package/dist/node/path.js

@@ -1,19 +1,19 @@
 import path from 'node:path';
 
-function resolve(...paths) {
-    return path.resolve(...paths);
-}
-function cwd() {
-    return path.normalize(process.env.INIT_CWD ? process.env.INIT_CWD : process.cwd());
-}
-function join(...paths) {
-    return path.join(...paths);
-}
-function dirname(filepath) {
-    return path.dirname(filepath);
-}
-function basename(filepath) {
-    return path.basename(filepath);
+function resolve(...paths) {
+    return path.resolve(...paths);
+}
+function cwd() {
+    return path.normalize(process.env.INIT_CWD ? process.env.INIT_CWD : process.cwd());
+}
+function join(...paths) {
+    return path.join(...paths);
+}
+function dirname(filepath) {
+    return path.dirname(filepath);
+}
+function basename(filepath) {
+    return path.basename(filepath);
 }
 
 export { basename, cwd, dirname, join, resolve };

package/dist/node/session.d.ts

@@ -1,8 +1,8 @@
-import { type Cli } from '..';
-export interface StoreSession {
-    id: string;
-    slug: string;
-    access_token: string;
-}
-export declare function get(): Promise<StoreSession | null>;
-export declare function authenticate(command: Cli.Command): Promise<StoreSession>;
+import { type Cli } from '..';
+export interface StoreSession {
+    id: string;
+    slug: string;
+    access_token: string;
+}
+export declare function get(): Promise<StoreSession | null>;
+export declare function authenticate(command: Cli.Command): Promise<StoreSession>;

package/dist/node/session.js

@@ -1,94 +1,108 @@
 import './cli.js';
 import 'simple-git';
 import { isPortAvailable, getPortProcessName, killPortProcess, open } from './system.js';
-import { apiHostname, oauthClientId, oauthClientSecret, sellerAreaHostname } from './env.js';
+import { apiHostname, oauthClientId, sellerAreaHostname } from './env.js';
 import { get as get$1, post } from './http.js';
 import 'formdata-node';
 import 'formdata-node/file-from-path';
 import 'kleur';
 import { manager } from './config.js';
-import { randomHex } from './crypto.js';
+import { randomHex, sha256, base64URLEncode } from './crypto.js';
 import 'dayjs';
 import { listen } from './callback.js';
 import './filesystem.js';
+import '../ui/components/DevOutput.js';
+import 'react';
+import 'ink';
 import 'change-case';
 
-const LS_PORT = 3000;
-const LS_HOST = 'localhost';
-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;
-    }
-}
-async function exchange(code) {
-    const params = {
-        code,
-        client_id: oauthClientId(),
-        grant_type: 'authorization_code',
-        client_secret: oauthClientSecret(),
-        redirect_uri: `http://${LS_HOST}:${LS_PORT}/`,
-    };
-    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;
-}
-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 params = {
-        state,
-        response_type: 'code',
-        scope: '*',
-        client_id: oauthClientId(),
-        redirect_uri: `http://${LS_HOST}:${LS_PORT}/`,
-    };
-    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 result.code;
-}
-async function get() {
-    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 accessToken = await exchange(await authorize(command));
-    const store = await get$1(`${apiHostname()}/me`, { headers: { Authorization: `Bearer ${accessToken}` } });
-    const session = {
-        slug: store.slug,
-        id: store.id,
-        access_token: accessToken,
-    };
-    manager({ projectName: 'youcan-cli' })
-        .set('store_session', session);
-    return session;
+const LS_PORT = 3000;
+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)];
+}
+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;
+    }
+}
+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;
+}
+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 };
+}
+async function get() {
+    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}` } });
+    const session = {
+        slug: store.slug,
+        id: store.id,
+        access_token: accessToken,
+    };
+    manager({ projectName: 'youcan-cli' })
+        .set('store_session', session);
+    return session;
 }
 
 export { authenticate, get };

package/dist/node/system.d.ts

@@ -1,21 +1,23 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import type { Readable, Writable } from 'stream';
-export interface ExecOptions {
-    cwd?: string;
-    env?: {
-        [key: string]: string | undefined;
-    };
-    stdin?: Readable | 'inherit';
-    stdout?: Writable | 'inherit';
-    stderr?: Writable | 'inherit';
-    stdio?: 'inherit';
-    input?: string;
-    signal?: AbortSignal;
-    errorHandler?: (error: unknown) => 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 getPortProcessName(port: number): Promise<string>;
-export declare function killPortProcess(port: number): Promise<void>;
-export declare function open(url: string): Promise<void>;
+/// <reference types="node" />
+/// <reference types="node" />
+import type { Readable, Writable } from 'stream';
+export interface ExecOptions {
+    cwd?: string;
+    env?: {
+        [key: string]: string | undefined;
+    };
+    stdin?: Readable | 'inherit';
+    stdout?: Writable | 'inherit';
+    stderr?: Writable | 'inherit';
+    stdio?: 'inherit';
+    input?: string;
+    signal?: AbortSignal;
+    errorHandler?: (error: unknown) => 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 getPortProcessName(port: number): Promise<string>;
+export declare function killPortProcess(port: number): Promise<void>;
+export declare function open(url: string): Promise<void>;
+export type PackageManagerType = 'pnpm' | 'npm' | 'yarn';
+export declare function inferUserPackageManager(): PackageManagerType;

package/dist/node/system.js

@@ -2,63 +2,79 @@ import { execa } from 'execa';
 import tpu from 'tcp-port-used';
 import findProcess from 'find-process';
 
-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 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 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, getPortProcessName, inferUserPackageManager, isPortAvailable, killPortProcess, open };

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 };