@youcan/cli-kit 1.1.0-beta.0 → 1.1.0-beta.2

package/dist/common/string.d.ts

@@ -1 +1,2 @@
 export declare function hyphenate(value: string): string;
+export declare function isJson(subject: string): boolean;

package/dist/common/string.js

@@ -2,6 +2,15 @@ import { paramCase } from 'change-case';
 
 function hyphenate(value) {
     return paramCase(value);
+}
+function isJson(subject) {
+    try {
+        JSON.parse(subject);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
 }
 
-export { hyphenate };
+export { hyphenate, isJson };

package/dist/index.d.ts

@@ -1,8 +1,16 @@
 export * as Cli from './node/cli';
 export * as Git from './node/git';
+export * as Env from './node/env';
 export * as Path from './node/path';
+export * as Http from './node/http';
+export * as Form from './node/form';
 export * as Tasks from './node/tasks';
 export * as Github from './node/github';
 export * as System from './node/system';
+export * as Config from './node/config';
+export * as Crypto from './node/crypto';
+export * as Session from './node/session';
+export * as Callback from './node/callback';
 export * as Filesystem from './node/filesystem';
 export * as String from './common/string';
+export { default as Color } from 'kleur';

package/dist/index.js

@@ -2,15 +2,30 @@ import * as cli from './node/cli.js';
 export { cli as Cli };
 import * as git from './node/git.js';
 export { git as Git };
+import * as env from './node/env.js';
+export { env as Env };
 import * as path from './node/path.js';
 export { path as Path };
+import * as http from './node/http.js';
+export { http as Http };
+import * as form from './node/form.js';
+export { form as Form };
 import * as tasks from './node/tasks.js';
 export { tasks as Tasks };
 import * as github from './node/github.js';
 export { github as Github };
 import * as system from './node/system.js';
 export { system as System };
+import * as config from './node/config.js';
+export { config as Config };
+import * as crypto from './node/crypto.js';
+export { crypto as Crypto };
+import * as session from './node/session.js';
+export { session as Session };
+import * as callback from './node/callback.js';
+export { callback as Callback };
 import * as filesystem from './node/filesystem.js';
 export { filesystem as Filesystem };
 import * as string from './common/string.js';
 export { string as String };
+export { default as Color } from 'kleur';

package/dist/internal/node/constants.d.ts

@@ -1,4 +1,5 @@
 export declare function cachedir(): string;
-export declare const envvars: {
-    env: string;
+export declare const ENV_VARS: {
+    ENV: string;
+    HOST_ENV: string;
 };

package/dist/internal/node/constants.js

@@ -7,8 +7,9 @@ function cachedir() {
     }
     return envpaths(identifier).cache;
 }
-const envvars = {
-    env: 'YC_CLI_ENV',
+const ENV_VARS = {
+    ENV: 'YC_CLI_ENV',
+    HOST_ENV: 'YC_CLI_HOST_ENV',
 };
 
-export { cachedir, envvars };
+export { ENV_VARS, cachedir };

package/dist/node/callback.d.ts

@@ -0,0 +1,5 @@
+import type { Cli } from '..';
+export declare function listen(command: Cli.Command, host: string, port: number, url: string): Promise<{
+    code: string;
+    state: string;
+}>;

package/dist/node/callback.js

@@ -0,0 +1,58 @@
+import { createServer } from 'node:http';
+
+class CallbackListener {
+    port;
+    host;
+    server;
+    constructor(options) {
+        this.port = options.port;
+        this.host = options.host;
+        this.server = this.create(options.callback);
+    }
+    start() {
+        this.server.listen({ port: this.port, host: this.host }, () => { });
+    }
+    stop() {
+        this.server.close();
+    }
+    create(callback) {
+        const server = async (request, response) => {
+            const respond = async (contents, error, state, code) => {
+                response.write(contents);
+                response.end();
+                return callback(this, error, state, code);
+            };
+            const query = new URL(request.url, `http://${request.headers.host}`).searchParams;
+            if (!query.has('code')) {
+                return respond('missing code in authorization callback');
+            }
+            if (!query.has('state')) {
+                return respond('missing state in authorization callback');
+            }
+            return respond('Successfully authenticated, you can now close this window.', undefined, query.get('code'), query.get('state'));
+        };
+        return createServer(server);
+    }
+}
+async function listen(command, host, port, url) {
+    return await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            command.output.info('Auto-open timed out, click below to open the login page:');
+            command.output.url('Log in to YouCan Partners', url);
+        }, 10_000);
+        const callback = (listener, error, code, state) => {
+            clearTimeout(timeout);
+            setTimeout(() => {
+                listener.stop();
+                if (error) {
+                    return reject(error);
+                }
+                return resolve({ code: code, state: state });
+            }, 500);
+        };
+        const listener = new CallbackListener({ host, port, callback });
+        listener.start();
+    });
+}
+
+export { listen };

package/dist/node/config.d.ts

@@ -0,0 +1,20 @@
+declare class Manager<T extends {
+    [key: string]: any;
+}> {
+    private readonly store;
+    constructor(options: {
+        projectName?: string;
+        cwd?: string;
+    });
+    get<TKey extends keyof T>(key: TKey): T[TKey];
+    set<TKey extends keyof T>(key: TKey, value?: T[TKey]): void;
+    delete<TKey extends keyof T>(key: TKey): void;
+    clear(): void;
+}
+export declare function manager(options: {
+    projectName?: string;
+    cwd?: string;
+}): Manager<{
+    [key: string]: any;
+}>;
+export {};

package/dist/node/config.js

@@ -0,0 +1,27 @@
+import Conf from 'conf';
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+/** @ts-expect-error */
+class Manager {
+    store;
+    constructor(options) {
+        this.store = new Conf(options);
+    }
+    get(key) {
+        return this.store.get(key);
+    }
+    set(key, value) {
+        this.store.set(key, value);
+    }
+    delete(key) {
+        this.store.delete(key);
+    }
+    clear() {
+        this.store.clear();
+    }
+}
+function manager(options) {
+    return new Manager(options);
+}
+
+export { manager };

package/dist/node/context/local.js

@@ -1,7 +1,7 @@
-import { envvars } from '../../internal/node/constants.js';
+import { ENV_VARS } from '../../internal/node/constants.js';
 
 function isDevelopment(env = process.env) {
-    return env[envvars.env] === 'development';
+    return env[ENV_VARS.ENV] === 'development';
 }
 
 export { isDevelopment };

package/dist/node/crypto.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+export declare function randomHex(size: number): string;
+export declare function base64URLEncode(str: Buffer): string;
+export declare function sha256(str: string): Buffer;
+export declare function sha1(str: Buffer | string): string;
+export declare function hashString(str: string): string;
+export declare function fileHash(buff: Buffer): string;
+export declare function randomBytes(size: number): Buffer;
+export declare function randomUUID(): string;

package/dist/node/crypto.js

@@ -0,0 +1,28 @@
+import crypto from 'node:crypto';
+
+function randomHex(size) {
+    return crypto.randomBytes(size).toString('hex');
+}
+function base64URLEncode(str) {
+    return str.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/[=]/g, '');
+}
+function sha256(str) {
+    return crypto.createHash('sha256').update(str).digest();
+}
+function sha1(str) {
+    return crypto.createHash('sha1').update(str).digest('hex');
+}
+function hashString(str) {
+    return crypto.createHash('sha1').update(str).digest('hex');
+}
+function fileHash(buff) {
+    return crypto.createHash('md5').update(buff).digest('hex');
+}
+function randomBytes(size) {
+    return crypto.randomBytes(size);
+}
+function randomUUID() {
+    return crypto.randomUUID();
+}
+
+export { base64URLEncode, fileHash, hashString, randomBytes, randomHex, randomUUID, sha1, sha256 };

package/dist/node/env.d.ts

@@ -0,0 +1,6 @@
+import { ENV_VARS } from '@/internal/node/constants';
+export declare function get(key: keyof typeof ENV_VARS): string;
+export declare function oauthClientId(): string;
+export declare function oauthClientSecret(): string;
+export declare function sellerAreaHostname(): string;
+export declare function apiHostname(): string;

package/dist/node/env.js

@@ -0,0 +1,51 @@
+import { ENV_VARS } from '../internal/node/constants.js';
+
+function get(key) {
+    return process.env[ENV_VARS[key]];
+}
+function oauthClientId() {
+    switch (get('HOST_ENV')) {
+        case 'dev':
+            return '3';
+        case 'test':
+            return '8';
+        case 'prod':
+        default:
+            return '8';
+    }
+}
+function oauthClientSecret() {
+    switch (get('HOST_ENV')) {
+        case 'dev':
+            return 'kvvtjXFCeuvvNX2nwD30SAfh7DMbVXm16E0MPCTu';
+        case 'test':
+            return '8';
+        case 'prod':
+        default:
+            return 'lvUw2mQ7nXp4WqZ9CZlURMgRGAra3KuOrYhFlU7X';
+    }
+}
+function sellerAreaHostname() {
+    switch (get('HOST_ENV')) {
+        case 'dev':
+            return 'seller-area.dotshop.com';
+        case 'test':
+            return 'seller-area.testyoucan.shop';
+        case 'prod':
+        default:
+            return 'seller-area.youcan.shop';
+    }
+}
+function apiHostname() {
+    switch (get('HOST_ENV')) {
+        case 'dev':
+            return 'api.dotshop.com';
+        case 'test':
+            return 'api.testyoucan.shop';
+        case 'prod':
+        default:
+            return 'api.youcan.shop';
+    }
+}
+
+export { apiHostname, get, oauthClientId, oauthClientSecret, sellerAreaHostname };

package/dist/node/filesystem.d.ts

@@ -1,3 +1,8 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { Mode, OpenMode, PathLike } from 'fs';
+import type { Options as GlobOptions, Pattern } from 'fast-glob';
+import chokidar from 'chokidar';
 export declare function exists(path: string): Promise<boolean>;
 export declare function tapIntoTmp<T>(callback: (tmp: string) => T | Promise<T>): Promise<T>;
 export declare function mkdir(path: string): Promise<void>;
@@ -5,4 +10,19 @@ interface MoveFileOptions {
     overwrite?: boolean;
 }
 export declare function move(src: string, dest: string, options?: MoveFileOptions): Promise<void>;
+export declare function readFile(path: PathLike, options?: {
+    encoding?: BufferEncoding;
+    flag?: OpenMode;
+}): Promise<Buffer | string>;
+export declare function writeFile(path: PathLike, data: string, options?: {
+    encoding: BufferEncoding;
+    flag: Mode;
+}): Promise<void>;
+export declare function readJsonFile<T = Record<string, unknown>>(path: PathLike): Promise<T>;
+export declare function writeJsonFile(path: PathLike, data: Record<string, unknown>): Promise<void>;
+export declare function glob(pattern: Pattern | Pattern[], options?: GlobOptions): Promise<string[]>;
+export declare function archived(path: string, name: string): Promise<string>;
+export declare function unlink(path: string): Promise<void>;
+export declare function readdir(path: string): Promise<string[]>;
+export declare const watch: typeof chokidar.watch;
 export {};

package/dist/node/filesystem.js

@@ -1,6 +1,23 @@
 import FilesystemPromises from 'node:fs/promises';
+import { createWriteStream } from 'node:fs';
 import { temporaryDirectoryTask } from 'tempy';
 import FsExtra from 'fs-extra';
+import archiver from 'archiver';
+import chokidar from 'chokidar';
+import './cli.js';
+import 'simple-git';
+import 'execa';
+import 'tcp-port-used';
+import 'find-process';
+import 'env-paths';
+import { resolve } from './path.js';
+import 'node-fetch';
+import 'ramda';
+import 'change-case';
+import 'formdata-node';
+import 'formdata-node/file-from-path';
+import 'kleur';
+import 'conf';
 
 async function exists(path) {
     try {
@@ -19,6 +36,53 @@ async function mkdir(path) {
 }
 async function move(src, dest, options = {}) {
     await FsExtra.move(src, dest, options);
-}
+}
+async function readFile(path, options = { encoding: 'utf-8', flag: 'r' }) {
+    return await FilesystemPromises.readFile(path, options);
+}
+async function writeFile(path, data, options = { encoding: 'utf-8', flag: 'w' }) {
+    return await FilesystemPromises.writeFile(path, data, options);
+}
+async function readJsonFile(path) {
+    const file = await readFile(path);
+    return JSON.parse(file instanceof Buffer ? file.toString() : file);
+}
+async function writeJsonFile(path, data) {
+    return writeFile(path, JSON.stringify(data, null, 4));
+}
+async function glob(pattern, options) {
+    const { default: _glob } = await import('fast-glob');
+    let _options = options;
+    if (options?.dot == null) {
+        _options = { ...options, dot: true };
+    }
+    return _glob(pattern, _options);
+}
+async function archived(path$1, name) {
+    return new Promise((resolve$1, reject) => {
+        try {
+            const archivePath = resolve(path$1, `${name}.zip`);
+            const output = createWriteStream(archivePath);
+            const _archiver = archiver('zip', { zlib: { level: 9 } });
+            output.on('close', () => resolve$1(archivePath));
+            _archiver.on('error', () => (err) => reject(err));
+            _archiver.pipe(output);
+            _archiver.directory(resolve(path$1, name), false);
+            _archiver.finalize();
+        }
+        catch (err) {
+            reject(err);
+        }
+    });
+}
+async function unlink(path) {
+    if (await exists(path)) {
+        await FilesystemPromises.unlink(path);
+    }
+}
+async function readdir(path) {
+    return await FilesystemPromises.readdir(path);
+}
+const watch = chokidar.watch;
 
-export { exists, mkdir, move, tapIntoTmp };
+export { archived, exists, glob, mkdir, move, readFile, readJsonFile, readdir, tapIntoTmp, unlink, watch, writeFile, writeJsonFile };

package/dist/node/form.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { FormData } from 'formdata-node';
+import type { FormDataEntryValue } from 'formdata-node';
+import { fileFromPath } from 'formdata-node/file-from-path';
+export type FormDataResolvable = Array<FormDataResolvable> | {
+    [key: string]: FormDataResolvable;
+} | FormDataEntryValue | undefined | boolean | number | Blob | Date | null;
+export declare const file: typeof fileFromPath;
+export declare function convert(source: Record<string, FormDataResolvable>, form?: FormData, parentKey?: string | null): FormData;

package/dist/node/form.js

@@ -0,0 +1,45 @@
+import { FormData, File } from 'formdata-node';
+import { fileFromPath } from 'formdata-node/file-from-path';
+
+const file = fileFromPath;
+function convert(source, form = new FormData(), parentKey = null) {
+    source = source || {};
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            append(form, toKey(parentKey, key), source[key]);
+        }
+    }
+    return form;
+}
+function append(form, key, value) {
+    if (Array.isArray(value)) {
+        return Array.from(value.keys()).forEach(index => append(form, toKey(key, index.toString()), value[index]));
+    }
+    else if (value instanceof Date) {
+        return form.append(key, value.toISOString());
+    }
+    else if (value instanceof File) {
+        return form.append(key, value, value.name);
+    }
+    else if (value instanceof Blob) {
+        return form.append(key, value);
+    }
+    else if (typeof value === 'boolean') {
+        return form.append(key, value ? '1' : '0');
+    }
+    else if (typeof value === 'string') {
+        return form.append(key, value);
+    }
+    else if (typeof value === 'number') {
+        return form.append(key, `${value}`);
+    }
+    else if (value === null || value === undefined) {
+        return form.append(key, '');
+    }
+    convert(value, form, key);
+}
+function toKey(parent, key) {
+    return parent ? `${parent}[${key}]` : key;
+}
+
+export { convert, file };

package/dist/node/http.d.ts

@@ -0,0 +1,3 @@
+import type { RequestInit } from 'node-fetch';
+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

@@ -0,0 +1,51 @@
+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 { get as get$1 } from './env.js';
+import 'formdata-node';
+import 'formdata-node/file-from-path';
+import 'kleur';
+import 'conf';
+import { get as get$2 } from './session.js';
+import './filesystem.js';
+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' });
+}
+
+export { get, post };

package/dist/node/path.d.ts

@@ -1,3 +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;

package/dist/node/path.js

@@ -8,6 +8,12 @@ function cwd() {
 }
 function join(...paths) {
     return path.join(...paths);
+}
+function dirname(filepath) {
+    return path.dirname(filepath);
+}
+function basename(filepath) {
+    return path.basename(filepath);
 }
 
-export { cwd, join, resolve };
+export { basename, cwd, dirname, join, resolve };

package/dist/node/session.d.ts

@@ -0,0 +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>;

package/dist/node/session.js

@@ -0,0 +1,105 @@
+import './cli.js';
+import 'simple-git';
+import { isPortAvailable, getPortProcessName, killPortProcess, open } from './system.js';
+import { apiHostname, oauthClientId, oauthClientSecret, 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 { listen } from './callback.js';
+import './filesystem.js';
+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.is_active;
+    }
+    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_url: `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 { stores } = await get$1(`${apiHostname()}/stores`, { headers: { Authorization: `Bearer ${accessToken}` } });
+    const active = stores.filter(s => s.is_active);
+    if (!active.length) {
+        throw new Error('No active stores found');
+    }
+    const { selected } = await command.prompt({
+        type: 'select',
+        name: 'selected',
+        message: 'Select a store to log into',
+        choices: active.map(s => ({ title: s.slug, value: s.store_id })),
+    });
+    const store = stores.find(s => s.store_id === selected);
+    const { token: storeAccessToken } = await post(`${apiHostname()}/switch-store/${store.store_id}`, { headers: { Authorization: `Bearer ${accessToken}` } });
+    const session = {
+        slug: store.slug,
+        id: store.store_id,
+        access_token: storeAccessToken,
+    };
+    manager({ projectName: 'youcan-cli' })
+        .set('store_session', session);
+    return session;
+}
+
+export { authenticate, get };

package/dist/node/system.d.ts

@@ -15,3 +15,7 @@ export interface ExecOptions {
     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>;

package/dist/node/system.js

@@ -1,4 +1,6 @@
 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;
@@ -42,6 +44,21 @@ async function exec(command, args, options) {
         }
         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);
 }
 
-export { exec };
+export { exec, getPortProcessName, isPortAvailable, killPortProcess, open };

package/dist/node/tasks.d.ts

@@ -4,4 +4,4 @@ export interface Task<T = unknown> {
     skip?: (ctx: T) => boolean;
     task: (context: T, task: Task<T>) => Promise<void | Task<T>[]>;
 }
-export declare function run<T = unknown>(tasks: Task[]): Promise<void>;
+export declare function run<T = unknown>(ctx: T, tasks: Task<T>[]): Promise<T>;

package/dist/node/tasks.js

@@ -1,3 +1,4 @@
+import { exit } from 'node:process';
 import { Loader } from '../internal/node/ui.js';
 
 async function runTask(task, ctx) {
@@ -6,25 +7,25 @@ async function runTask(task, ctx) {
     }
     return await task.task(ctx, task);
 }
-async function run(tasks) {
-    const context = {};
-    for (const task of tasks) {
+async function run(ctx, tasks) {
+    for await (const task of tasks) {
         await Loader.exec(task.title, async (loader) => {
             try {
-                const subtasks = await runTask(task, context);
+                const subtasks = await runTask(task, ctx);
                 if (Array.isArray(subtasks) && subtasks.length > 0 && subtasks.every(t => 'task' in t)) {
-                    for (const subtask of subtasks) {
-                        await runTask(subtask, context);
+                    for await (const subtask of subtasks) {
+                        await runTask(subtask, ctx);
                     }
                 }
                 loader.stop();
             }
             catch (err) {
                 loader.error(String(err));
-                throw err;
+                exit(1);
             }
         });
     }
+    return ctx;
 }
 
 export { run };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@youcan/cli-kit",
   "type": "module",
-  "version": "1.1.0-beta.0",
+  "version": "1.1.0-beta.2",
   "description": "Utilities for the YouCan CLI",
   "author": "YouCan <contact@youcan.shop> (https://youcan.shop)",
   "license": "MIT",
@@ -20,24 +20,39 @@
   ],
   "dependencies": {
     "@oclif/core": "^2.15.0",
+    "archiver": "^5.3.2",
     "change-case": "^4.1.2",
+    "chokidar": "^3.5.3",
+    "conf": "^11.0.2",
     "env-paths": "^3.0.0",
     "execa": "^6.1.0",
+    "fast-glob": "^3.3.1",
+    "find-process": "^1.4.7",
+    "formdata-node": "^5.0.1",
     "fs-extra": "^11.1.1",
+    "kill-port-process": "^3.2.0",
     "kleur": "^4.1.5",
+    "node-fetch": "^3.3.2",
+    "open": "^9.1.0",
     "prompts": "^2.4.2",
+    "ramda": "^0.28.0",
     "simple-git": "^3.20.0",
-    "tempy": "^3.1.0"
+    "tcp-port-used": "^1.0.2",
+    "tempy": "^3.1.0",
+    "worker": "^0.4.0"
   },
   "devDependencies": {
+    "@types/archiver": "^5.3.3",
     "@types/fs-extra": "^11.0.2",
     "@types/node": "^18.18.0",
     "@types/prompts": "^2.4.5",
+    "@types/ramda": "^0.28.25",
+    "@types/tcp-port-used": "^1.0.2",
     "shx": "^0.3.4"
   },
   "scripts": {
     "build": "shx rm -rf dist && tsc --noEmit && rollup --config rollup.config.js",
-    "dev": "rollup --config rollup.config.js --watch",
+    "dev": "shx rm -rf dist && rollup --config rollup.config.js --watch",
     "release": "pnpm publish --access public",
     "type-check": "tsc --noEmit"
   }