@coze/cli 0.0.2

package/dist/cli.mjs

@@ -0,0 +1,957 @@
+import * as __WEBPACK_EXTERNAL_MODULE_commander__ from "commander";
+import * as __WEBPACK_EXTERNAL_MODULE_openid_client__ from "openid-client";
+import * as __WEBPACK_EXTERNAL_MODULE_picocolors__ from "picocolors";
+import * as __WEBPACK_EXTERNAL_MODULE__npmcli_config_lib_definitions_index_js__ from "@npmcli/config/lib/definitions/index.js";
+import * as __WEBPACK_EXTERNAL_MODULE__npmcli_config__ from "@npmcli/config";
+import * as __WEBPACK_EXTERNAL_MODULE_node_path__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs__ from "node:fs";
+import * as __WEBPACK_EXTERNAL_MODULE_semver__ from "semver";
+import * as __WEBPACK_EXTERNAL_MODULE_lodash__ from "lodash";
+import * as __WEBPACK_EXTERNAL_MODULE_cross_spawn__ from "cross-spawn";
+import * as __WEBPACK_EXTERNAL_MODULE__inquirer_prompts__ from "@inquirer/prompts";
+import * as __WEBPACK_EXTERNAL_MODULE_node_module__ from "node:module";
+import * as __WEBPACK_EXTERNAL_MODULE__rsbuild_core__ from "@rsbuild/core";
+import * as __WEBPACK_EXTERNAL_MODULE__rsbuild_plugin_react__ from "@rsbuild/plugin-react";
+import * as __WEBPACK_EXTERNAL_MODULE__rsbuild_plugin_less__ from "@rsbuild/plugin-less";
+import * as __WEBPACK_EXTERNAL_MODULE_prettier__ from "prettier";
+import * as __WEBPACK_EXTERNAL_MODULE__rslib_core__ from "@rslib/core";
+import * as __WEBPACK_EXTERNAL_MODULE_form_data__ from "form-data";
+import * as __WEBPACK_EXTERNAL_MODULE_axios__ from "axios";
+import * as __WEBPACK_EXTERNAL_MODULE_express__ from "express";
+import * as __WEBPACK_EXTERNAL_MODULE_chokidar__ from "chokidar";
+const logger = {
+    info (...messages) {
+        console.log(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].blue('[INFO]'), ...messages);
+    },
+    success (...messages) {
+        console.log(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].green('[SUCCESS]'), ...messages);
+    },
+    warning (...messages) {
+        console.log(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].yellow('[WARNING]'), ...messages);
+    },
+    error (...messages) {
+        console.error(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].red('[ERROR]'), ...messages);
+    },
+    debug (...messages) {
+        if (process.env.DEBUG) console.log(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].magenta('[DEBUG]'), ...messages);
+    }
+};
+var constants_Region = /*#__PURE__*/ function(Region) {
+    Region["CN"] = "cn";
+    Region["CN_BOE"] = "boe";
+    Region["I18N"] = "i18n";
+    Region["LOCAL"] = "local";
+    return Region;
+}({});
+const REGISTRY_HOST = {
+    ["cn"]: 'npm-hub.coze.cn',
+    ["i18n"]: 'npm-hub.coze.com',
+    ["boe"]: 'npm-hub-boe.bytedance.net',
+    ["local"]: 'localhost:3000'
+};
+const CLIENT_ID_MAP = {
+    ["cn"]: '13474932957575400683007237571476.app.coze',
+    ["boe"]: '70653688608994412341629476687797.app.coze',
+    ["local"]: '70653688608994412341629476687797.app.coze'
+};
+const ISSUER_MAP = {
+    ["cn"]: 'https://api.coze.cn',
+    ["boe"]: 'https://api-bot-boe.bytedance.net',
+    ["local"]: 'https://api-bot-boe.bytedance.net'
+};
+/* eslint-disable security/detect-object-injection -- ignore */ class OauthClient {
+    constructor(region = constants_Region.CN_BOE){
+        const cozeHubIssuer = new __WEBPACK_EXTERNAL_MODULE_openid_client__.Issuer({
+            issuer: ISSUER_MAP[region],
+            device_authorization_endpoint: `${ISSUER_MAP[region]}/api/permission/oauth2/device/code`,
+            token_endpoint: `${ISSUER_MAP[region]}/api/permission/oauth2/token`,
+            revocation_endpoint: `${ISSUER_MAP[region]}/api/permission/oauth2/revoke`,
+            scope: 'createMessage'
+        });
+        this.client = new cozeHubIssuer.Client({
+            client_id: CLIENT_ID_MAP[region],
+            token_endpoint_auth_method: 'none'
+        });
+    }
+    async activate(npmConfig) {
+        const { refreshToken } = await npmConfig.loadConfig();
+        if (refreshToken) try {
+            const tokenSet = await this.client.refresh(refreshToken);
+            await npmConfig.storeToken(tokenSet);
+        } catch (e) {
+            logger.error('refresh failed: ', e);
+            await this.auth(npmConfig);
+        }
+        else await this.auth(npmConfig);
+    }
+    async deactivate(npmConfig) {
+        const { refreshToken } = await npmConfig.loadConfig();
+        await this.client.revoke(refreshToken);
+        await npmConfig.clearToken();
+    }
+    async auth(npmConfig) {
+        const handle = await this.client.deviceAuthorization({
+            duration_seconds: 86399
+        });
+        const completeUrl = `${handle.verification_uri}?user_code=${handle.user_code}`;
+        const open = await import("open").then((mod)=>mod.default);
+        await open(completeUrl);
+        let tokenSet = null;
+        while(!tokenSet)try {
+            tokenSet = await handle.poll();
+            logger.success('authenticated');
+            await npmConfig.storeToken(tokenSet);
+        } catch (error) {
+            logger.error('poll failed:', error);
+            throw error;
+        }
+    }
+}
+const { shorthands, definitions, flatten } = __WEBPACK_EXTERNAL_MODULE__npmcli_config_lib_definitions_index_js__["default"];
+const CONFIG_TYPE = 'user';
+const REFRESH_TOKEN_KEY = 'refresh_token';
+const DEFAULT_PACKAGE_SCOPE = 'coze';
+const DEFAULT_BUSINESS_SOURCE = 'coze';
+class NpmConfig {
+    constructor({ projectDir, scope, region, source } = {}){
+        this.config = {
+            scope: scope ?? DEFAULT_PACKAGE_SCOPE,
+            authToken: '',
+            refreshToken: '',
+            registryUrl: '',
+            region,
+            source: source ?? DEFAULT_BUSINESS_SOURCE
+        };
+        const dir = projectDir ?? process.cwd();
+        this.proxy = new __WEBPACK_EXTERNAL_MODULE__npmcli_config__["default"]({
+            npmPath: dir,
+            definitions,
+            shorthands,
+            flatten,
+            cwd: dir
+        });
+    }
+    get registryScope() {
+        return `@${this.config.scope}:registry`;
+    }
+    get registryUrl() {
+        const registryHost = REGISTRY_HOST[this.region];
+        return this.region === constants_Region.LOCAL ? `http://${registryHost}/` : `https://${registryHost}/`;
+    }
+    get registryAuthUrl() {
+        const registryHost = REGISTRY_HOST[this.region];
+        return `//${registryHost}/:_authToken`;
+    }
+    get region() {
+        // has specified region
+        if (this.config.region) return this.config.region;
+        const registry = this.proxy.get(this.registryScope);
+        if (!registry) return constants_Region.CN_BOE;
+        const registryHost = new URL(registry).host;
+        for (const [region, host] of Object.entries(REGISTRY_HOST))if (registryHost === host) return region;
+        return constants_Region.CN_BOE;
+    }
+    async loadConfig() {
+        if (this.proxy.loaded) return this.config;
+        await this.proxy.load();
+        const token = this.proxy.get(this.registryAuthUrl, CONFIG_TYPE) ?? '';
+        Object.assign(this.config, {
+            region: this.region,
+            registryUrl: this.proxy.get(this.registryScope) || this.registryUrl,
+            authToken: token,
+            refreshToken: this.proxy.get(`${this.config.scope}_${REFRESH_TOKEN_KEY}`, CONFIG_TYPE) || ''
+        });
+        return this.config;
+    }
+    async storeToken(tokenSet) {
+        // clear other region info
+        for (const [region] of Object.entries(REGISTRY_HOST))if (region !== this.region) this.proxy.delete(this.registryScope, CONFIG_TYPE);
+        this.proxy.set(this.registryScope, this.registryUrl, CONFIG_TYPE);
+        this.proxy.set(this.registryAuthUrl, `${this.config.source}:${tokenSet.access_token || ''}`, CONFIG_TYPE);
+        this.proxy.set(`${this.config.source}_${REFRESH_TOKEN_KEY}`, tokenSet.refresh_token || '', CONFIG_TYPE);
+        await this.proxy.save(CONFIG_TYPE);
+        Object.assign(this.config, {
+            authToken: tokenSet.access_token,
+            refreshToken: tokenSet.refresh_token
+        });
+        logger.success(`token saved for registry: ${this.registryUrl}`);
+    }
+    async clearToken() {
+        this.proxy.delete(this.registryScope, CONFIG_TYPE);
+        this.proxy.delete(this.registryAuthUrl, CONFIG_TYPE);
+        this.proxy.delete(`${this.config.scope}_${REFRESH_TOKEN_KEY}`, CONFIG_TYPE);
+        await this.proxy.save(CONFIG_TYPE);
+        Object.assign(this.config, {
+            authToken: '',
+            refreshToken: ''
+        });
+        logger.success(`token cleared for registry: ${this.registryUrl}`);
+    }
+    getProxy() {
+        return this.proxy;
+    }
+}
+/* eslint-disable @typescript-eslint/no-explicit-any -- ignore */ /* eslint-disable security/detect-non-literal-fs-filename -- ignore */ function resolvePackageJson(projectDir) {
+    const pkgJsonFilePath = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(projectDir, 'package.json');
+    if (!__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].existsSync(pkgJsonFilePath)) throw new Error(`package.json not found in ${projectDir}`);
+    const content = __WEBPACK_EXTERNAL_MODULE_node_fs__["default"].readFileSync(pkgJsonFilePath, 'utf-8');
+    return JSON.parse(content);
+}
+function resolvePackageDir(dir = '') {
+    if (__WEBPACK_EXTERNAL_MODULE_node_path__["default"].isAbsolute(dir)) return dir;
+    return __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(process.cwd(), dir);
+}
+/**
+ * @coze/a-b -> __coze__a_b
+ * @coze-ui/a-b -> __coze_ui__a_b
+ * a-b -> a_b
+ */ function pkgName2RemoteName(pkgName) {
+    const hasScope = pkgName.startsWith('@');
+    const parts = pkgName.split('/');
+    return `${hasScope ? `__${parts[0].slice(1)}__` : parts[0]}${parts.slice(1).join('_')}`.replace(/-/g, '_');
+}
+// @module-federation/rsbuild-plugin only support cjs
+const config_require = (0, __WEBPACK_EXTERNAL_MODULE_node_module__.createRequire)(import.meta.url);
+const pluginModuleFederation = config_require('@module-federation/rsbuild-plugin').pluginModuleFederation;
+const { isEmpty, merge } = __WEBPACK_EXTERNAL_MODULE_lodash__["default"];
+const CONFIG_FILE_NAME = 'ui.config';
+const CONFIG_FILE_EXTNAME = [
+    '.js',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts'
+];
+const CDN_MAP = {
+    boe: '//lf0-fast-deliver-inner.bytedance.net/obj/eden-internal/ibo-lgvj/ljhwZthlaukjlkulzlp/',
+    cn: '//lf3-static.bytednsdoc.com/obj/eden-cn/ibo-lgvj/ljhwZthlaukjlkulzlp/'
+};
+async function loadConfig({ cwd = process.cwd(), path }) {
+    const configFilePath = resolveConfigPath(cwd, path);
+    const { content } = await (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.loadConfig)({
+        cwd: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(configFilePath),
+        path: configFilePath
+    });
+    content._privateMeta = {
+        configFilePath
+    };
+    return content;
+}
+function getShareRslibConfig(uiConfig, libConfig) {
+    const projectDir = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(uiConfig._privateMeta.configFilePath);
+    const pkgJson = JSON.parse(__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].readFileSync(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(projectDir, 'package.json'), 'utf-8'));
+    const umdName = pkgName2RemoteName(pkgJson.name);
+    const entries = resolveExports(uiConfig);
+    const tsconfigPath = resolveTsconfigPath(projectDir);
+    const libs = [];
+    const formats = [
+        'cjs',
+        'esm',
+        'umd',
+        'mf'
+    ];
+    Object.entries(entries).forEach(([dist, src])=>{
+        for (const format of formats){
+            // mf should use exposes instead of multiple entries
+            if ('mf' === format && '.' !== dist) continue;
+            const config = {
+                dts: {
+                    bundle: false
+                },
+                format,
+                output: {
+                    distPath: {
+                        root: __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join('dist', format, dist)
+                    }
+                },
+                source: {
+                    tsconfigPath,
+                    entry: {
+                        index: src
+                    }
+                },
+                shims: {
+                    cjs: {
+                        'import.meta.url': true
+                    },
+                    esm: {
+                        __filename: true,
+                        __dirname: true,
+                        require: true
+                    }
+                },
+                // each entry should have unique name
+                umdName: __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(umdName, dist).replace(/\//g, '_')
+            };
+            if ('mf' === format) {
+                // default use boe
+                const cdn = CDN_MAP[process.env.REGION ?? ''] ?? CDN_MAP.boe;
+                const singleton = [
+                    'react',
+                    'react-dom'
+                ];
+                let shared = uiConfig.shared ?? {};
+                if (isEmpty(shared) && null !== uiConfig.shared) for (const type of [
+                    'dependencies',
+                    'peerDependencies'
+                ])Object.entries(pkgJson[type]).forEach(([name])=>{
+                    shared[name] = {
+                        singleton: singleton.includes(name)
+                    };
+                });
+                merge(config, {
+                    output: {
+                        assetPrefix: `${cdn}${__WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(`${pkgJson.name}@${pkgJson.version}`, 'dist/mf', dist)}`
+                    },
+                    plugins: [
+                        pluginModuleFederation({
+                            name: umdName,
+                            exposes: entries,
+                            shared
+                        })
+                    ]
+                });
+            } else if ('umd' === format) merge(config, {
+                output: {
+                    minify: true,
+                    injectStyles: true
+                }
+            });
+            libs.push(merge(config, libConfig));
+        }
+    });
+    return merge({
+        lib: libs,
+        plugins: [
+            (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_plugin_react__.pluginReact)(),
+            (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_plugin_less__.pluginLess)()
+        ]
+    }, uiConfig.rslib ?? {}, {
+        _privateMeta: uiConfig._privateMeta
+    });
+}
+function getShareRsbuildConfig(uiConfig) {
+    const projectDir = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(uiConfig._privateMeta.configFilePath);
+    const previewDir = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(projectDir, 'preview');
+    const entries = resolvePreviewEntries(previewDir);
+    if (isEmpty(entries)) throw new Error('preview folder is empty, maybe you should add index.page.tsx');
+    // virtual modules
+    const virtualMod = {};
+    const virtualDir = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(projectDir, 'node_modules', '.cache', 'coze');
+    if (!__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].existsSync(virtualDir)) __WEBPACK_EXTERNAL_MODULE_node_fs__["default"].mkdirSync(virtualDir, {
+        recursive: true
+    });
+    const prettierConfig = {
+        parser: 'babel',
+        singleQuote: true,
+        trailingComma: 'all'
+    };
+    Object.entries(entries).forEach(([name, absPath])=>{
+        const virtualPath = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(virtualDir, `${name}.tsx`);
+        const virtualContent = __WEBPACK_EXTERNAL_MODULE_prettier__["default"].format(`
+    import Mod from "${absPath}";
+    import { createRoot } from 'react-dom/client';
+
+    const root = createRoot(document.getElementById('root'));
+    root.render(<Mod />);
+    `, prettierConfig);
+        __WEBPACK_EXTERNAL_MODULE_node_fs__["default"].writeFileSync(virtualPath, virtualContent);
+        virtualMod[name] = virtualPath;
+    });
+    return merge({
+        source: {
+            entry: virtualMod
+        },
+        output: {
+            distPath: {
+                root: __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(virtualDir, 'dist')
+            }
+        },
+        server: {
+            port: 6008,
+            proxy: {
+                '/dist': {
+                    target: 'http://localhost:6007'
+                }
+            }
+        },
+        plugins: [
+            (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_plugin_react__.pluginReact)(),
+            (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_plugin_less__.pluginLess)()
+        ]
+    }, uiConfig.preview);
+}
+/**
+ * xx.page.{ts,tsx}
+ */ const rPageEntry = /\.page\.(js|ts|tsx|mjs|mts|cjs|cts)$/;
+function resolvePreviewEntries(previewDir) {
+    const entries = {};
+    __WEBPACK_EXTERNAL_MODULE_node_fs__["default"].readdirSync(previewDir).forEach((file)=>{
+        const filePath = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(previewDir, file);
+        const fileStat = __WEBPACK_EXTERNAL_MODULE_node_fs__["default"].statSync(filePath);
+        if (fileStat.isDirectory()) Object.assign(entries, resolvePreviewEntries(filePath));
+        else if (/\.page\.(js|ts|tsx|mjs|mts|cjs|cts)$/.test(file)) {
+            const relative = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].relative(previewDir, filePath);
+            let dirname = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].dirname(relative);
+            dirname = '.' === dirname ? '' : dirname;
+            const basename = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].basename(filePath).replace(rPageEntry, '');
+            const route = dirname.split('/').concat(basename).filter(Boolean).join('_');
+            entries[route] = filePath;
+        }
+    });
+    return entries;
+}
+function resolveConfigPath(root, customConfig) {
+    if (customConfig) {
+        const customConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].isAbsolute(customConfig) ? customConfig : __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(root, customConfig);
+        if (__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].existsSync(customConfigPath)) {
+            if (__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].statSync(customConfigPath).isFile()) return customConfigPath;
+            root = customConfigPath;
+        } else throw new Error(`${CONFIG_FILE_NAME} not found in ${customConfigPath}`);
+    }
+    const configFilePath = CONFIG_FILE_EXTNAME.map((extname)=>`${__WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(root, CONFIG_FILE_NAME)}${extname}`).find((p)=>__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].existsSync(p));
+    if (configFilePath) return configFilePath;
+    throw new Error(`${CONFIG_FILE_NAME} not found in ${root}`);
+}
+function resolveTsconfigPath(root) {
+    // Preferred tsconfig.build.json
+    if (__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].existsSync(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(root, 'tsconfig.build.json'))) return 'tsconfig.build.json';
+    return 'tsconfig.json';
+}
+function resolveMainEntry(projectDir) {
+    const mainEntry = CONFIG_FILE_EXTNAME.map((extname)=>`index${extname}`).find((e)=>__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].existsSync(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(projectDir, `src/${e}`)));
+    return mainEntry;
+}
+/**
+ * The `exports` field in `package.json` must adhere to the following format：
+ *
+ * ```
+ * exports: {
+ *   ".": {
+ *     ...
+ *     "src": "./src/index.tsx"
+ *   },
+ *   "./button": {
+ *     ...
+ *     "src": "./src/button/index.tsx"
+ *   }
+ * }
+ * ```
+ */ function resolveExports(uiConfig) {
+    const projectDir = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(uiConfig._privateMeta.configFilePath);
+    const srcEntry = resolveMainEntry(projectDir);
+    if (!srcEntry) throw new Error('entry not found, maybe you forget the "src/index.ts"?');
+    const pkgJson = JSON.parse(__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].readFileSync(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(projectDir, 'package.json'), 'utf-8'));
+    let exposes = {};
+    Object.entries(pkgJson.exports ?? {}).forEach(([key, config])=>{
+        if (!config.src) {
+            logger.warning([
+                `exports.${key} does't have "src", the builder will ignore this export.`,
+                `you should add "src" field, such as:\n`,
+                'exports: {\n',
+                `  "${key}": {\n`,
+                '    "src": "./src/index.tsx"\n',
+                '  }\n',
+                '}'
+            ].join(''));
+            return;
+        }
+        // mfplugin doesn't support "./"
+        const k = './' === key ? '.' : key;
+        exposes[k] = config.src;
+    });
+    // use default export
+    if (isEmpty(exposes)) exposes['.'] = `./src/${srcEntry}`;
+    return exposes;
+}
+/* eslint-disable security/detect-non-literal-fs-filename -- ignore */ const buildAction = async (options = {})=>{
+    const uiConfig = await loadConfig({
+        path: options.dir
+    });
+    const projectDir = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(uiConfig._privateMeta.configFilePath);
+    // esm/cjs/umd/mf
+    const prevCwd = process.cwd();
+    try {
+        process.chdir(projectDir);
+        const rslibConfig = getShareRslibConfig(uiConfig, options.libConfig);
+        await (0, __WEBPACK_EXTERNAL_MODULE__rslib_core__.build)(rslibConfig);
+    } catch (e) {} finally{
+        process.chdir(prevCwd);
+    }
+};
+const buildSpec = {
+    name: 'build',
+    description: 'build component',
+    action: buildAction,
+    options: [
+        new __WEBPACK_EXTERNAL_MODULE_commander__.Option('-d, --dir <componentDir>', 'the path of component')
+    ]
+};
+/* eslint-disable @typescript-eslint/no-explicit-any -- ignore */ /* eslint-disable security/detect-non-literal-fs-filename -- ignore */ /* eslint-disable no-magic-numbers -- ignore */ /* eslint-disable @typescript-eslint/no-magic-numbers  -- ignore*/ const { isEmpty: ui_isEmpty } = __WEBPACK_EXTERNAL_MODULE_lodash__["default"];
+async function publishUIAction(options) {
+    const prevCwd = process.cwd();
+    let pkgJson = {};
+    let projectDir = '';
+    // ctrl+c
+    process.on('SIGINT', ()=>{
+        ui_reset(projectDir, pkgJson);
+        process.chdir(prevCwd);
+    });
+    try {
+        projectDir = resolvePackageDir(options.dir);
+        process.chdir(projectDir);
+        pkgJson = resolvePackageJson(projectDir);
+        await check();
+        await version(projectDir);
+        await buildAction();
+        await test();
+        await publish();
+    } catch (error) {
+        ui_reset(projectDir, pkgJson);
+        logger.error('Failed to publish component:', error);
+    } finally{
+        process.chdir(prevCwd);
+    }
+}
+async function check() {
+    const registry = process.env.REGISTRY;
+    if (!registry || !Object.values(REGISTRY_HOST).includes(new URL(registry).host)) throw new Error(`NPM registry is not expected. ${registry}`);
+    const { stdout } = __WEBPACK_EXTERNAL_MODULE_cross_spawn__["default"].sync('git', [
+        'status',
+        '--porcelain'
+    ], {
+        encoding: 'utf-8'
+    });
+    if (stdout) {
+        const anwser = await (0, __WEBPACK_EXTERNAL_MODULE__inquirer_prompts__.confirm)({
+            message: 'Git workspace is dirty, are you sure to continue?',
+            default: false
+        });
+        if (!anwser) throw new Error('dirty workspace');
+    }
+}
+async function version(projectDir) {
+    const pkgJson = resolvePackageJson(projectDir);
+    const anwser = await (0, __WEBPACK_EXTERNAL_MODULE__inquirer_prompts__.confirm)({
+        message: 'Whether to increase the package version?',
+        default: false
+    });
+    if (!anwser) return;
+    const type = await (0, __WEBPACK_EXTERNAL_MODULE__inquirer_prompts__.select)({
+        message: 'Choose publish type:',
+        choices: [
+            {
+                name: 'alpha',
+                value: 'alpha'
+            },
+            {
+                name: 'beta',
+                value: 'beta'
+            },
+            {
+                name: 'rc',
+                value: 'rc'
+            },
+            {
+                name: 'patch',
+                value: 'patch'
+            },
+            {
+                name: 'minor',
+                value: 'minor'
+            },
+            {
+                name: 'major',
+                value: 'major'
+            }
+        ],
+        default: 'alpha'
+    });
+    let nextVersion = pkgJson.version;
+    nextVersion = [
+        'alpha',
+        'beta',
+        'rc'
+    ].includes(type) ? __WEBPACK_EXTERNAL_MODULE_semver__["default"].inc(nextVersion, 'prerelease', type) : __WEBPACK_EXTERNAL_MODULE_semver__["default"].inc(nextVersion, type);
+    nextVersion = await (0, __WEBPACK_EXTERNAL_MODULE__inquirer_prompts__.input)({
+        message: 'Are you sure to publish:',
+        default: nextVersion,
+        validate: (val)=>{
+            if (!val || !__WEBPACK_EXTERNAL_MODULE_semver__["default"].valid(val)) return 'version is not valid';
+            return true;
+        }
+    });
+    pkgJson.version = nextVersion;
+    __WEBPACK_EXTERNAL_MODULE_node_fs__["default"].writeFileSync(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(projectDir, 'package.json'), JSON.stringify(pkgJson, void 0, 2));
+}
+async function test() {
+    await __WEBPACK_EXTERNAL_MODULE_cross_spawn__["default"].sync('npm', [
+        'run',
+        'test'
+    ], {
+        stdio: 'inherit'
+    });
+    await __WEBPACK_EXTERNAL_MODULE_cross_spawn__["default"].sync('npm', [
+        'run',
+        'test:cov'
+    ], {
+        stdio: 'inherit'
+    });
+}
+async function publish() {
+    const registryKey = process.env.SCOPE ? `@${process.env.SCOPE}:registry` : 'registry';
+    await (0, __WEBPACK_EXTERNAL_MODULE_cross_spawn__["default"])('npm', [
+        'publish',
+        `--${registryKey}=${process.env.REGISTRY}`
+    ], {
+        stdio: 'inherit'
+    });
+}
+function ui_reset(projectDir, pkgJson) {
+    if (ui_isEmpty(projectDir) || ui_isEmpty(pkgJson)) return;
+    __WEBPACK_EXTERNAL_MODULE_node_fs__["default"].writeFileSync(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(projectDir, 'package.json'), JSON.stringify(pkgJson, void 0, 2));
+}
+/* eslint-disable @typescript-eslint/no-explicit-any -- ignore */ /* eslint-disable security/detect-non-literal-fs-filename -- ignore */ /* eslint-disable @typescript-eslint/no-non-null-assertion -- ignore */ async function publishOceanAction(options = {}) {
+    const prevCwd = process.cwd();
+    // ctrl+c
+    process.on('SIGINT', ()=>{
+        process.chdir(prevCwd);
+    });
+    try {
+        const config = await loadUIConfig(options.dir);
+        const projectDir = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(config.uiConfig._privateMeta.configFilePath);
+        const pkgJson = resolvePackageJson(projectDir);
+        process.chdir(projectDir);
+        const deployment = await chooseDeployment();
+        await ocean_test(pkgJson);
+        const files = await build(pkgJson, projectDir);
+        await ocean_publish(files, config, deployment);
+    } catch (error) {
+        logger.error('Failed to publish component:', error);
+    } finally{
+        process.chdir(prevCwd);
+    }
+}
+async function loadUIConfig(dir) {
+    const uiConfig = await loadConfig({
+        path: dir
+    });
+    const npm = new NpmConfig();
+    const npmConfig = await npm.loadConfig();
+    if (!npmConfig.region) throw new Error('failed to parse region, maybe you should login first');
+    return {
+        uiConfig,
+        npmConfig
+    };
+}
+async function chooseDeployment() {
+    return await (0, __WEBPACK_EXTERNAL_MODULE__inquirer_prompts__.select)({
+        message: 'Choose deployment type:',
+        choices: [
+            {
+                name: 'canary',
+                value: 1
+            },
+            {
+                name: 'online',
+                value: 2
+            }
+        ],
+        default: 1
+    });
+}
+async function ocean_test(pkgJson) {
+    if (pkgJson.scripts?.test) await __WEBPACK_EXTERNAL_MODULE_cross_spawn__["default"].sync('npm', [
+        'run',
+        'test'
+    ], {
+        stdio: 'inherit'
+    });
+}
+async function build(pkgJson, projectDir) {
+    if (!pkgJson.scripts?.build) throw new Error('package.json should have build script');
+    const result = await __WEBPACK_EXTERNAL_MODULE_cross_spawn__["default"].sync('npm', [
+        'run',
+        'build'
+    ], {
+        stdio: 'inherit'
+    });
+    if (result.status) throw new Error('build failed');
+    // validate output
+    const outputDir = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(projectDir, 'applet_output', 'coze');
+    const outputFiles = {
+        zip: [],
+        manifest: ''
+    };
+    __WEBPACK_EXTERNAL_MODULE_node_fs__["default"].readdirSync(outputDir).forEach((file)=>{
+        if ('.zip' === __WEBPACK_EXTERNAL_MODULE_node_path__["default"].extname(file)) outputFiles.zip.push(file);
+        else if ('manifest.json' === file) outputFiles.manifest = file;
+    });
+    if (outputFiles.manifest) {
+        if (outputFiles.zip.length) {
+            if (outputFiles.zip.length > 1) throw new Error(`multiple zip found in ${outputDir}`);
+        } else throw new Error(`zip not found in ${outputDir}`);
+    } else throw new Error(`manifest.json not found in ${outputDir}`);
+    return {
+        zip: __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(outputDir, outputFiles.zip[0]),
+        manifest: __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(outputDir, outputFiles.manifest)
+    };
+}
+async function ocean_publish(files, config, deployType) {
+    const { registryUrl } = config.npmConfig;
+    const data = new __WEBPACK_EXTERNAL_MODULE_form_data__["default"]();
+    data.append('manifest', __WEBPACK_EXTERNAL_MODULE_node_fs__["default"].createReadStream(files.manifest));
+    data.append('pkg', __WEBPACK_EXTERNAL_MODULE_node_fs__["default"].createReadStream(files.zip));
+    data.append('projectId', config.uiConfig.projectId);
+    data.append('deployType', deployType);
+    const res = await __WEBPACK_EXTERNAL_MODULE_axios__["default"].request({
+        method: 'post',
+        url: `${registryUrl}${registryUrl.endsWith('/') ? '' : '/'}api/ocean/publish`,
+        headers: {
+            Authorization: `Bearer ${config.npmConfig.authToken}`,
+            ...data.getHeaders()
+        },
+        data
+    });
+    if (res.data.code) logger.error(`publish failed: ${res.data.msg}`);
+    else logger.success(`publish success, deployId: ${res.data.deployId}`);
+}
+async function publishAction(options = {}) {
+    if ('ocean' === options.type) await publishOceanAction(options);
+    else await publishUIAction(options);
+}
+const publishSpec = {
+    name: 'publish',
+    description: 'publish component',
+    action: publishAction,
+    options: [
+        new __WEBPACK_EXTERNAL_MODULE_commander__.Option('-t, --type <name>', 'the component type').choices([
+            'ocean'
+        ]),
+        new __WEBPACK_EXTERNAL_MODULE_commander__.Option('-d, --dir <componentDir>', 'the path of component')
+    ],
+    auth: true
+};
+/* eslint-disable no-magic-numbers -- ignore */ /* eslint-disable @typescript-eslint/no-magic-numbers -- ignore */ /* eslint-disable security/detect-non-literal-fs-filename -- ignore */ /* eslint-disable @typescript-eslint/no-non-null-assertion -- ignore */ const { isEqual, debounce } = __WEBPACK_EXTERNAL_MODULE_lodash__["default"];
+const previewAction = async (options = {})=>{
+    const uiConfig = await loadConfig({
+        path: options.dir
+    });
+    const projectDir = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(uiConfig._privateMeta.configFilePath);
+    const previewDir = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(projectDir, 'preview');
+    if (!__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].existsSync(previewDir)) throw new Error(`${previewDir} does not exist`);
+    // build for preview
+    await buildAction({
+        dir: options.dir,
+        libConfig: {
+            output: {
+                assetPrefix: '/dist/mf'
+            }
+        }
+    });
+    const prevCwd = process.cwd();
+    // ctrl+c
+    process.on('SIGINT', ()=>{
+        process.chdir(prevCwd);
+        process.exit(1);
+    });
+    const serveDist = ()=>{
+        const app = (0, __WEBPACK_EXTERNAL_MODULE_express__["default"])();
+        app.use('/dist', __WEBPACK_EXTERNAL_MODULE_express__["default"].static(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(projectDir, 'dist')));
+        app.listen(6007);
+    };
+    let devServer = null;
+    const startDevServer = async ()=>{
+        try {
+            process.chdir(projectDir);
+            const rsbuildConfig = getShareRsbuildConfig(uiConfig);
+            const rsbuild = await (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.createRsbuild)({
+                rsbuildConfig
+            });
+            devServer = await rsbuild.startDevServer();
+        } catch (e) {
+            logger.error('failed', e);
+            process.chdir(prevCwd);
+        }
+    };
+    let prevEntries = resolvePreviewEntries(previewDir);
+    const reload = debounce(async ()=>{
+        const nextEntries = resolvePreviewEntries(previewDir);
+        if (!isEqual(prevEntries, nextEntries) && devServer) {
+            await devServer.server.close();
+            devServer = null;
+            prevEntries = nextEntries;
+            await startDevServer();
+        }
+    }, 300);
+    serveDist();
+    startDevServer();
+    const watcher = __WEBPACK_EXTERNAL_MODULE_chokidar__["default"].watch(previewDir, {
+        ignoreInitial: true
+    });
+    watcher.on('add', reload).on('unlink', reload);
+};
+const previewSpec = {
+    name: 'preview',
+    description: 'preview component',
+    action: previewAction,
+    options: [
+        new __WEBPACK_EXTERNAL_MODULE_commander__.Option('-d, --dir <componentDir>', 'the path of component')
+    ]
+};
+/* eslint-disable security/detect-non-literal-fs-filename -- ignore */ const createAction = async (options = {})=>{
+    if ('ocean' === options.type) {
+        const nameOrPath = await (0, __WEBPACK_EXTERNAL_MODULE__inquirer_prompts__.input)({
+            message: 'Project name or path:',
+            validate: (val)=>{
+                if (!val) return 'please input name or path';
+                return true;
+            }
+        });
+        const projectDir = resolvePackageDir(nameOrPath);
+        let { projectId } = options;
+        if (!projectId) projectId = await (0, __WEBPACK_EXTERNAL_MODULE__inquirer_prompts__.input)({
+            message: 'ProjectId of the ocean component:',
+            validate: (val)=>{
+                if (!val) return 'please input projectId';
+                return true;
+            }
+        });
+        // copy template
+        __WEBPACK_EXTERNAL_MODULE_cross_spawn__["default"].sync('npx', [
+            '@byted/create',
+            projectDir,
+            '--template',
+            '@ai-app/agent-scaffolding-coze-create@latest'
+        ], {
+            stdio: 'inherit'
+        });
+        // generate ui.config
+        const configFile = 'ui.config.ts';
+        const prettierConfig = {
+            parser: 'babel',
+            singleQuote: true,
+            trailingComma: 'all'
+        };
+        const configFilePath = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(projectDir, configFile);
+        const content = __WEBPACK_EXTERNAL_MODULE_prettier__["default"].format(`
+    export default {
+      projectId: '${projectId}'
+    };
+    `, prettierConfig);
+        __WEBPACK_EXTERNAL_MODULE_node_fs__["default"].writeFileSync(configFilePath, content);
+    } else await (0, __WEBPACK_EXTERNAL_MODULE_cross_spawn__["default"])('npm', [
+        'create',
+        '@coze-dev/ui@latest'
+    ], {
+        stdio: 'inherit'
+    });
+};
+const createSpec = {
+    name: 'create',
+    description: 'create componennt',
+    action: createAction,
+    auth: true,
+    options: [
+        new __WEBPACK_EXTERNAL_MODULE_commander__.Option('-t, --type <name>', 'the component type').choices([
+            'ocean'
+        ]),
+        new __WEBPACK_EXTERNAL_MODULE_commander__.Option('--projectId <projectId>', 'the projectId of the ocean component')
+    ]
+};
+const uiSpec = {
+    name: 'ui',
+    description: 'subcommand for ui development',
+    subCommands: [
+        createSpec,
+        buildSpec,
+        previewSpec,
+        publishSpec
+    ]
+};
+async function logoutAction({ region, scope, source }) {
+    const npmConfig = new NpmConfig({
+        region,
+        scope,
+        source
+    });
+    const authClient = new OauthClient(region);
+    await authClient.deactivate(npmConfig);
+}
+const logoutSpec = {
+    name: 'logout',
+    description: 'log out of the hub',
+    action: logoutAction,
+    options: [
+        new __WEBPACK_EXTERNAL_MODULE_commander__.Option('-r, --region <name>', 'the region of hub').choices(Object.values(constants_Region)),
+        new __WEBPACK_EXTERNAL_MODULE_commander__.Option('-s, --scope <name>', 'the scope of package'),
+        new __WEBPACK_EXTERNAL_MODULE_commander__.Option('-b, --source <name>', 'the business source')
+    ]
+};
+async function loginAction({ region, scope, source }) {
+    const npmConfig = new NpmConfig({
+        scope,
+        region,
+        source
+    });
+    const authClient = new OauthClient(region);
+    await authClient.activate(npmConfig);
+}
+const loginSpec = {
+    name: 'login',
+    description: 'log in to the hub',
+    action: loginAction,
+    options: [
+        new __WEBPACK_EXTERNAL_MODULE_commander__.Option('-r, --region <name>', 'the region of hub').choices(Object.values(constants_Region)),
+        new __WEBPACK_EXTERNAL_MODULE_commander__.Option('-s, --scope <name>', 'the scope of package'),
+        new __WEBPACK_EXTERNAL_MODULE_commander__.Option('-b, --source <name>', 'the business source')
+    ]
+};
+/* eslint-disable @typescript-eslint/no-explicit-any -- ignore */ function addCommand({ program, spec, runAuth }) {
+    const command = program.command(spec.name);
+    command.description(spec.description);
+    (spec.arguments ?? []).forEach((argument)=>{
+        command.addArgument(argument);
+    });
+    (spec.options ?? []).forEach((option)=>{
+        command.addOption(option);
+    });
+    if (spec.action) command.action(async (...args)=>{
+        if (spec.auth && runAuth) await runAuth();
+        await spec.action?.(...args);
+    });
+    (spec.subCommands ?? []).forEach((subCommand)=>{
+        addCommand({
+            program: command,
+            spec: subCommand,
+            runAuth
+        });
+    });
+}
+const cli_program = new __WEBPACK_EXTERNAL_MODULE_commander__.Command();
+cli_program.name('coze').version("0.0.1-alpha.11").description('A command-line tool for component development');
+[
+    loginSpec,
+    logoutSpec,
+    uiSpec
+].forEach((spec)=>{
+    const runAuth = async ()=>{
+        // refresh token
+        const npmConfig = new NpmConfig();
+        const { region, registryUrl, scope } = await npmConfig.loadConfig();
+        const oauthClient = new OauthClient(region);
+        await oauthClient.activate(npmConfig);
+        // add env
+        process.env.REGION = region;
+        process.env.REGISTRY = registryUrl;
+        process.env.SCOPE = scope;
+    };
+    addCommand({
+        spec,
+        program: cli_program,
+        runAuth
+    });
+});
+cli_program.parse(process.argv);