@kdcloudjs/cli 0.0.1

package/README.MD

@@ -0,0 +1,22 @@
+# kd
+# 起步
+#### 安装
+```
+npm install -g @kdcloudjs/cli
+# OR
+yarn global add @kdcloudjs/cli
+```
+#### 初始化项目：
+```
+kd project init demo
+```
+
+#### 创建组件
+```
+kd project create kwcdemo  --type kwc
+```
+
+#### 创建页面元数据
+```
+kd project create kwcdemo  --type page
+```

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@kdcloudjs/cli",
+  "version": "0.0.1",
+  "description": "Kingdee CLI",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "cli",
+    "kd"
+  ],
+  "bin": {
+    "kd": "./src/index.js"
+  },
+  "author": "rubing_yan@kingdee.com",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.12.2",
+    "chalk": "4.1.2",
+    "commander": "12.1.0",
+    "download-git-repo": "^3.0.2",
+    "form-data": "^4.0.4",
+    "ora": "5.4.1",
+    "prompts": "2.4.2",
+    "update-notifier": "^7.3.1"
+  },
+  "type": "commonjs"
+}

package/src/actions/env/auth/index.js

@@ -0,0 +1,33 @@
+
+
+
+const { loadDefaultEnv, getEnvByName } = require('../config')
+const webAuth = require('./web')
+const openapiAuth = require('./openapi')
+const { error } = require('../../../utils/log')
+
+module.exports = async function doAuth(options ={}) {
+  let { type, env } = options
+
+  if (env === undefined) {
+    env = loadDefaultEnv()?.name
+    if (!env) {
+      error('❌ No environment specified and default environment is invalid, cannot authenticate') // 待产品提供
+      return
+    }
+  }
+
+  const envInfo = getEnvByName(env)
+
+  try {
+      if (type === 'web') {
+        return webAuth({ env: envInfo })
+      }
+
+      if (type === 'openapi') {
+        return openapiAuth({ env: envInfo })
+      }
+  } catch (e) {
+      error(`❌ Authentication failed: ${e.message}`)
+  }
+}

package/src/actions/env/auth/openapi.js

@@ -0,0 +1,83 @@
+const { loadEnv, saveEnv } = require('../config')
+const { getAllDataCenters, getAccessToken, getIsv } = require('../../../api')
+const { safePrompts } = require('../../../utils/prompts')
+const { encrypt } = require('../../../utils/crypto')
+const { isValidUrl } = require('../../../utils/validator')
+const { error } = require('../../../utils/log')
+module.exports = async function authOpenAPI(options = {}) {
+    const { env } = options
+
+    try {
+        const { url, name }= env || {}
+        if (!isValidUrl(url)) {
+            console.error('Invalid URL format:', url)
+            return
+        }
+
+        // 获取数据中心
+        let dataCenter
+        const dataCenters = await getAllDataCenters(url) || []
+        if (dataCenters.length === 0) return
+
+        const datacenterPrompt = {
+            type: 'select',
+            name: 'datacenterId',
+            message: 'Please select a data center',
+            choices: [...dataCenters]
+        }
+        const dcRes = await safePrompts(datacenterPrompt)
+        dataCenter = dataCenters.find(dc => dc.value === dcRes.datacenterId) || {}
+
+        // 获取client信息
+        const clientRes = await safePrompts([
+            {
+            type: 'text',
+            name: 'client_id',
+            message: '*Please enter OpenAPI third-party app client_id',
+            validate: v => !!v || 'OpenAPI third-party app client_id cannot be empty'
+            },
+            {
+            type: 'text',
+            name: 'client_secret',
+            message: '*Please enter OpenAPI third-party app client_secret',
+            validate: v => !!v || 'OpenAPI third-party app client_secret cannot be empty'
+            },
+            {
+            type: 'text',
+            name: 'username',
+            message: '*Please enter OpenAPI third-party app username',
+            validate: v => !!v || 'OpenAPI third-party app username cannot be empty'
+            }
+        ])
+
+        // 获取token
+        const getAccessTokenParams = {
+            client_id: clientRes.client_id,
+            client_secret: clientRes.client_secret,
+            username: clientRes.username,
+            accountId: dataCenter?.accountId
+        }
+        const tokenData = await getAccessToken(url, getAccessTokenParams) || {}
+        let token = tokenData.access_token || ''
+        if (!token) {
+            error('Failed to obtain access_token. Please check your credentials and reauthentication.')
+            return
+        } 
+
+        // 获取isv
+        const { isv } = await getIsv(url, token) || {}
+        if (!isv) return
+
+        // 环境信息更新存储
+        const envs = loadEnv()
+        getAccessTokenParams.client_secret = encrypt(getAccessTokenParams.client_secret)
+        envs[name] = Object.assign({}, env, getAccessTokenParams, {
+            access_token: encrypt(token),
+            isv
+        })
+
+        saveEnv(envs)
+    } catch (error) {
+        console.error('auth error:', error)
+    }
+}

package/src/actions/env/auth/web.js

@@ -0,0 +1,3 @@
+module.exports = async function authWeb(options) {
+    console.log('Web authentication initiated with options:', options)
+}

package/src/actions/env/config.js

@@ -0,0 +1,102 @@
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+const { warn } = require('../../utils/log')
+
+const KD_DIR = path.join(os.homedir(), '.kd')
+const CONFIG_FILE = path.join(KD_DIR, 'config.json')
+
+/**
+ * 确保 ~/.kd 目录存在
+ */
+function ensureKdDir() {
+  if (!fs.existsSync(KD_DIR)) {
+    fs.mkdirSync(KD_DIR, { recursive: true })
+  }
+}
+
+/**
+ * 读取完整配置（容错）
+ */
+function loadConfig() {
+  try {
+    if (!fs.existsSync(CONFIG_FILE)) {
+      return {}
+    }
+
+    const content = fs.readFileSync(CONFIG_FILE, 'utf-8').trim()
+    if (!content) {
+      return {}
+    }
+
+    return JSON.parse(content)
+  } catch (e) {
+    warn('⚠️ ~/.kd/config.json parse failed, using empty config')
+    return {}
+  }
+}
+
+/**
+ * 写入完整配置（原子性写入）
+ */
+function saveConfig(config) {
+ try {
+    ensureKdDir()
+
+    const tmpFile = `${CONFIG_FILE}.tmp`
+
+    fs.writeFileSync(
+      tmpFile,
+      JSON.stringify(config, null, 2),
+      'utf-8'
+    )
+
+    fs.renameSync(tmpFile, CONFIG_FILE)
+  } catch (e) {
+    warn('⚠️ Failed to save ~/.kd/config.json')
+    return {}
+  }
+}
+
+/**
+ * 读取 env 配置
+ */
+function loadEnv() {
+  const config = loadConfig()
+  return config.env || {}
+}
+
+/**
+ * 读取 env 默认配置
+ */
+function loadDefaultEnv() {
+  const envs = loadEnv()
+  const envsList = Object.values(envs) || []
+  return envsList.find(env => env.default) || {}
+}
+
+/**
+ * 根据环境名获取环境配置
+ */
+function getEnvByName(name) {
+  const envs = loadEnv() || {}
+  return envs[name] || {}
+}
+
+/**
+ * 保存 env 配置（不破坏其他字段）
+ */
+function saveEnv(env) {
+  const config = loadConfig()
+  config.env = env
+  saveConfig(config)
+}
+
+module.exports = {
+  loadConfig,
+  saveConfig,
+  loadEnv,
+  saveEnv,
+  loadDefaultEnv,
+  getEnvByName
+}

package/src/actions/env/create.js

@@ -0,0 +1,36 @@
+const { loadEnv, saveEnv } = require('./config')
+const { info, error } = require('../../utils/log')
+
+module.exports = function createEnv(name, options) {
+  const url = options?.url
+  if (!url) {
+    error('--url is required')
+    return
+  }
+
+  // url 校验
+  const urlPattern = /^https?:\/\/.+/
+  if (!urlPattern.test(url)) {
+    error(`Invalid URL: ${url}`)
+    return
+  }
+
+  const envs = loadEnv()
+
+  if (envs[name]) {
+    error(`Environment ${name} already exists`)
+    return
+  }
+
+  const isFirst = Object.keys(envs).length === 0
+
+  envs[name] = {
+    name,
+    url,
+    default: isFirst
+  }
+
+  saveEnv(envs)
+
+  info(`✅ Environment ${name} created successfully${isFirst ? ' (set as default)' : ''}`)
+}

package/src/actions/env/info.js

@@ -0,0 +1,28 @@
+const { loadEnv } = require('./config')
+const { info, error } = require('../../utils/log')
+const printTable = require('../../utils/printTable')
+
+module.exports = function envInfo() {
+  const envs = loadEnv()
+  const envsList = Object.values(envs)
+  if (!envsList?.length) {
+    error('No environments configured')
+    return
+  }
+
+  const current = envsList.find(e => e.default)
+
+  if (!current) {
+    error('No default environment configured')
+    return
+  }
+
+  info('Current Environment:')
+  const headers = ['Name', 'URL', 'Default']
+  const rows = [current].map(env => [
+    env.name,
+    env.url || '',
+    env.default ? '★' : ''
+  ])
+  printTable(headers, rows)
+}

package/src/actions/env/list.js

@@ -0,0 +1,21 @@
+const { loadEnv } = require('./config')
+const { warn } = require('../../utils/log')
+const printTable = require('../../utils/printTable')
+
+module.exports = function listEnv() {
+  const envs = loadEnv()
+  const names = Object.keys(envs)
+
+  if (names.length === 0) {
+    warn('No environment configuration found')
+    return
+  }
+
+  const headers = ['Name', 'URL', 'Default']
+  const rows = names.map(name => [
+    name,
+    envs[name].url || '',
+    envs[name].default ? '★' : ''
+  ])
+  printTable(headers, rows)
+}

package/src/actions/env/remote.js

@@ -0,0 +1,59 @@
+const { exec } = require('child_process')
+const { getEnvByName, loadDefaultEnv } = require('./config')
+const { error, info } = require('../../utils/log')
+
+module.exports = async function remote(envName, options) {
+  const { formId } = options
+
+  if (!formId) {
+    error('Error: --form-id (-f) is required')
+    return
+  }
+
+  let env
+  if (envName) {
+    env = getEnvByName(envName)
+    if (!env) {
+      error(`Error: Environment "${envName}" not found`)
+      return
+    }
+  } else {
+    env = loadDefaultEnv()
+    if (!env || !env.name) {
+      error('Error: No environment specified and no default environment found')
+      return
+    }
+    info(`Using default environment: ${env.name}`)
+  }
+
+  if (!env.url) {
+    error(`Error: Environment "${env.name}" has no URL configured`)
+    return
+  }
+
+  try {
+    const targetUrl = new URL(env.url)
+    targetUrl.searchParams.append('formId', formId)
+    targetUrl.searchParams.append('kdkwc_cdn', 'http://localhost:3333')
+    
+    const finalUrl = targetUrl.toString()
+    info(`Opening: ${finalUrl}`)
+
+    let cmd
+    if (process.platform === 'win32') {
+      cmd = `start "" "${finalUrl}"`
+    } else if (process.platform === 'darwin') {
+      cmd = `open "${finalUrl}"`
+    } else {
+      cmd = `xdg-open "${finalUrl}"`
+    }
+
+    exec(cmd, (err) => {
+      if (err) {
+        error(`Failed to open browser: ${err.message}`)
+      }
+    })
+  } catch (e) {
+    error(`Invalid Environment URL: ${env.url}`)
+  }
+}

package/src/actions/env/remove.js

@@ -0,0 +1,23 @@
+const { loadEnv, saveEnv } = require('./config')
+const { info, error } = require('../../utils/log')
+
+module.exports = function removeEnv(name) {
+  const envs = loadEnv()
+
+  if (!envs[name]) {
+    error(`Environment ${name} does not exist`)
+    return
+  }
+
+  const wasDefault = envs[name].default
+  delete envs[name]
+
+  let first
+  if (wasDefault) {
+    first = Object.values(envs)[0]
+    if (first) first.default = true
+  }
+
+  saveEnv(envs)
+  info(`✅ Environment ${name} deleted${first ? `, default environment switched to ${first?.name || 'none'}` : ''}`)
+}

package/src/actions/env/resolveEnv.js

@@ -0,0 +1,27 @@
+const { loadDefaultEnv, getEnvByName } = require('./config')
+const { error } = require('../../utils/log')
+
+/**
+ * 根据环境名解析环境
+ * - 未传：使用默认环境
+ * - 已传：使用指定环境
+ */
+module.exports = function resolveEnv(envName) {
+  let name = envName
+
+  if (name === undefined) {
+    name = loadDefaultEnv()?.name
+    if (!name) {
+      error('❌ No environment specified and no default environment exists')
+      return
+    }
+  }
+
+  const env = getEnvByName(name)
+  if (!env?.name) {
+    error(`❌ Environment ${name} does not exist`)
+    return
+  }
+
+  return { envName: name, env }
+}

package/src/actions/env/setDefault.js

@@ -0,0 +1,20 @@
+const { loadEnv, saveEnv } = require('./config')
+const { info, error } = require('../../utils/log')
+
+module.exports = function setDefault(name) {
+  const envs = loadEnv()
+
+  if (!envs[name]) {
+    error(`Environment ${name} does not exist`)
+    return
+  }
+
+  Object.values(envs).forEach(env => {
+    env.default = false
+  })
+
+  envs[name].default = true
+  saveEnv(envs)
+
+  info(`✅ ${name} has been set as the default environment`)
+}

package/src/actions/project/constants.js

@@ -0,0 +1,33 @@
+module.exports = {
+  PROJECT_TYPES: {
+    KWC: 'kwc',
+    PAGE: 'page'
+  },
+
+  TEMPLATES: {
+    lwc_js: 'direct:https://github.com/kingdee/cli-template.git#kwc-project',
+    react_ts: 'direct:https://github.com/kingdee/cli-template.git#kwc-project-react',
+    react_js: 'direct:https://github.com/kingdee/cli-template.git#kwc-project-react-js',
+    vue_ts: 'direct:https://github.com/kingdee/cli-template.git#kwc-project-vue',
+    vue_js: 'direct:https://github.com/kingdee/cli-template.git#kwc-project-vue-js'
+  },
+
+  INNER_TEMPLATES: {
+    lwc_js: 'direct:http://gitlab.kingdee.com/bos-cli-template/kd-custom-control-template.git#kwc-project',
+    react_ts: 'direct:http://gitlab.kingdee.com/bos-cli-template/kd-custom-control-template.git#kwc-project-react',
+    react_js: 'direct:http://gitlab.kingdee.com/bos-cli-template/kd-custom-control-template.git#kwc-project-react-js',
+    vue_ts: 'direct:http://gitlab.kingdee.com/bos-cli-template/kd-custom-control-template.git#kwc-project-vue',
+    vue_js: 'direct:http://gitlab.kingdee.com/bos-cli-template/kd-custom-control-template.git#kwc-project-vue-js'
+  },
+
+  FRAMEWORKS: {
+    React: 'react',
+    Vue: 'vue',
+    LWC: 'lwc'
+  },
+
+  LANGUAGES: {
+    TypeScript: 'ts',
+    JavaScript: 'js'
+  }
+}

package/src/actions/project/create/createMetaXml.js

@@ -0,0 +1,26 @@
+module.exports = function createMetaXml({ name, moduleId, framework }) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<KingdeeComponentBundle
+    xmlns="http://dev.kingdee.com/2025/10/metadata"
+>
+    <version></version>
+    <name>${name}</name>
+    <masterLabel>${name}</masterLabel>
+    <isv></isv>
+    <moduleid>${moduleId}</moduleid>
+    <framework>${framework}</framework>
+    <targets>
+        <target>BaseFormModel</target>
+        <target>BillFormModel</target>
+        <target>DynamicFormModel</target>
+        <target>MobileBillFormModel</target>
+        <target>MobileFormModel</target>
+        <target>KWCFormModel</target>
+    </targets>
+    <targetConfigs>
+        <targetConfig>
+          <targets>BaseFormModel,BillFormModel,DynamicFormModel,MobileBillFormModel,MobileFormModel,KWCFormModel</targets>
+        </targetConfig>
+    </targetConfigs>
+</KingdeeComponentBundle>`
+}

package/src/actions/project/create/index.js

@@ -0,0 +1,24 @@
+const { PROJECT_TYPES } = require('../constants')
+const validate = require('./validate')
+const createKwc = require('./kwc')
+const createPage = require('./page')
+const { error } = require('../../../utils/log')
+const { getConfig } = require('../../../utils/projectConfig')
+
+module.exports = async function create({ name, type }) {
+  const cwd = process.cwd()
+  const config = getConfig(cwd) || {}
+  validate({ name, type, ...config })
+
+  try {
+      if (type === PROJECT_TYPES.KWC) {
+        return createKwc(name, cwd, config)
+      }
+
+      if (type === PROJECT_TYPES.PAGE) {
+        return createPage(name, cwd)
+      }
+  } catch (e) {
+    error(`❌ Failed to create: ${e.message}`)
+  }
+}

package/src/actions/project/create/kwc.js

@@ -0,0 +1,25 @@
+const fs = require('fs')
+const path = require('path')
+const { info } = require('../../../utils/log')
+const writeKwcFiles = require('./writeKwcFiles')
+
+module.exports = function createKwc(name, cwd, config) {
+  const kwcRoot = path.join(cwd, 'app', 'kwc')
+  const dir = path.join(kwcRoot, name)
+
+  if (!fs.existsSync(kwcRoot)) {
+    throw new Error('Directory app/kwc not found')
+  }
+  if (fs.existsSync(dir)) {
+    throw new Error(`Component ${name} already exists`)
+  }
+
+  console.time('🕒 KWC component creation time')
+  fs.mkdirSync(dir, { recursive: true })
+
+  writeKwcFiles({ dir, name, ...config })
+
+  info(`✅ KWC Component ${name} created successfully`)
+  console.timeEnd('🕒 KWC component creation time')
+}
+

package/src/actions/project/create/page.js

@@ -0,0 +1,42 @@
+const fs = require('fs')
+const path = require('path')
+const { info } = require('../../../utils/log')
+
+module.exports = function createPage(name, cwd) {
+  const pagesDir = path.join(cwd, 'app/pages')
+
+  if (!fs.existsSync(pagesDir)) {
+    throw new Error('Directory app/pages not found')
+  }
+
+  const file = path.join(pagesDir, `${name}.page-meta.kwp`)
+  if (fs.existsSync(file)) {
+    throw new Error(`Page ${name} already exists`)
+  }
+
+  console.time(`🕒 Page ${name} creation time`)
+  fs.writeFileSync(file, createPageXml(name))
+
+  info(`✅ Page ${name} created successfully`)
+  console.timeEnd(`🕒 Page ${name} creation time`)
+}
+
+function createPageXml(name) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+
+<Page>
+    <name>${name}</name>
+    <masterLabel>${name}</masterLabel>
+    <template>oneregion</template>
+    <app></app>
+    <isv></isv>
+    <version>1</version>
+    <regions>
+        <region>
+            <name>region1</name>
+            <controls>
+            </controls>
+        </region>
+    </regions>
+</Page>`
+}