@youcan/cli-kit 2.1.4 → 2.3.0

package/dist/node/git.d.ts

@@ -1,10 +1,10 @@
-export declare function binaryExists(): Promise<boolean>;
-export interface CloneOptions {
-    url: string;
-    destination: string;
-    progressUpdater?: (statusString: string) => void;
-    shallow?: boolean;
-    latestTag?: boolean;
-}
-export declare function assertGitExists(): Promise<void>;
-export declare function clone(cloneOptions: CloneOptions): Promise<void>;
+export declare function binaryExists(): Promise<boolean>;
+export interface CloneOptions {
+    url: string;
+    destination: string;
+    progressUpdater?: (statusString: string) => void;
+    shallow?: boolean;
+    latestTag?: boolean;
+}
+export declare function assertGitExists(): Promise<void>;
+export declare function clone(cloneOptions: CloneOptions): Promise<void>;

package/dist/node/git.js

@@ -1,52 +1,52 @@
 import git from 'simple-git';
 import { exec } from './system.js';
 
-async function binaryExists() {
-    try {
-        await exec('git', ['--version']);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function assertGitExists() {
-    if (!(await binaryExists())) {
-        throw new Error('Git is required for the setup to continue.');
-    }
-}
-async function clone(cloneOptions) {
-    await assertGitExists();
-    const { url, destination, shallow, latestTag } = cloneOptions;
-    const [repository, branch] = url.split('#');
-    const options = { '--recurse-submodules': null };
-    // ignore latest tag if branch is provided
-    if (branch) {
-        options['--branch'] = branch;
-    }
-    if (shallow && latestTag) {
-        throw new Error('Cannot get a shallow clone of the latest branch.');
-    }
-    if (shallow) {
-        options['--depth'] = 1;
-    }
-    const simpleGitOptions = {
-        config: ['core.askpass=true'],
-    };
-    await git(simpleGitOptions)
-        .clone(repository, destination, options);
-    if (latestTag) {
-        const localRepo = git(destination);
-        const latestTag = await getLocalLatestTag(localRepo, url);
-        await localRepo.checkout(latestTag);
-    }
-}
-async function getLocalLatestTag(repository, url) {
-    const latest = (await repository.tags()).latest;
-    if (!latest) {
-        throw new Error(`Couldn't infer the latest tag from ${url}`);
-    }
-    return latest;
+async function binaryExists() {
+    try {
+        await exec('git', ['--version']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function assertGitExists() {
+    if (!(await binaryExists())) {
+        throw new Error('Git is required for the setup to continue.');
+    }
+}
+async function clone(cloneOptions) {
+    await assertGitExists();
+    const { url, destination, shallow, latestTag } = cloneOptions;
+    const [repository, branch] = url.split('#');
+    const options = { '--recurse-submodules': null };
+    // ignore latest tag if branch is provided
+    if (branch) {
+        options['--branch'] = branch;
+    }
+    if (shallow && latestTag) {
+        throw new Error('Cannot get a shallow clone of the latest branch.');
+    }
+    if (shallow) {
+        options['--depth'] = 1;
+    }
+    const simpleGitOptions = {
+        config: ['core.askpass=true'],
+    };
+    await git(simpleGitOptions)
+        .clone(repository, destination, options);
+    if (latestTag) {
+        const localRepo = git(destination);
+        const latestTag = await getLocalLatestTag(localRepo, url);
+        await localRepo.checkout(latestTag);
+    }
+}
+async function getLocalLatestTag(repository, url) {
+    const latest = (await repository.tags()).latest;
+    if (!latest) {
+        throw new Error(`Couldn't infer the latest tag from ${url}`);
+    }
+    return latest;
 }
 
 export { assertGitExists, binaryExists, clone };

package/dist/node/github.d.ts

@@ -1,6 +1,6 @@
-export interface RepositoryReference {
-    baseUrl: string;
-    branch?: string;
-    path?: string;
-}
-export declare function parseRepositoryReference(reference: string): RepositoryReference;
+export interface RepositoryReference {
+    baseUrl: string;
+    branch?: string;
+    path?: string;
+}
+export declare function parseRepositoryReference(reference: string): RepositoryReference;

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

@@ -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';
@@ -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,26 @@
-/// <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';
+import type { ExecaError } from 'execa';
+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 | 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;