sys-shim 0.0.1-7 → 0.0.1-9

package/package.json

@@ -2,7 +2,7 @@
   "name": "sys-shim",
   "private": false,
   "type": "module",
-  "version": "0.0.1-7",
+  "version": "0.0.1-9",
   "main": "./script/npm-pkg/node/main.min.cjs",
   "module": "./script/npm-pkg/node/main.min.mjs",
   "browser": {
@@ -10,9 +10,14 @@
     "./script/npm-pkg/node/main.min.mjs": "./script/npm-pkg/browser/main.esm.min.js"
   },
   "bin": {
-    "sys-shim": "./script/bin/sys-shim.cjs"
+    "sys-shim": "./script/npm-pkg/bin/index.mjs"
   },
   "files": [
+    "./src/proxy-deep.js",
+    "./src/util.js",
+    "./template",
+    "./script/npm-pkg/bin",
+    "./script/npm-pkg/lib",
     "./script/npm-pkg/shim",
     "./script/npm-pkg/test",
     "./script/npm-pkg/node/main.min.cjs",
@@ -21,6 +26,7 @@
     "./script/npm-pkg/browser/main.esm.min.js"
   ],
   "scripts": {
+    "sys-shim": "node ./script/npm-pkg/bin/index.mjs",
     "lint": "eslint ./ --format unix",
     "lint-fix": "eslint ./ --fix --format unix",
     "dev": "run-p vite run.shim",
@@ -49,9 +55,15 @@
     "proxy-deep": "^3.1.1",
     "rollup": "^4.17.2",
     "rpc-websockets": "^7.6.0",
-    "shx": "^0.3.4",
     "sys-shim": "link:",
     "vite": "^5.0.0",
     "vue": "^3.3.8"
+  },
+  "dependencies": {
+    "shx": "^0.3.4",
+    "download": "^8.0.0",
+    "filenamify": "^6.0.0",
+    "minimist": "^1.2.8",
+    "shelljs": "^0.8.5"
   }
 }

package/readme.md

@@ -42,9 +42,9 @@ new Sys('ws://127.0.0.1:10005?token=tokentokentoken').then(main => {
 })
 ```
 
-### 方式三：使用脚手架模板开发(开发中)
+### 方式三：使用脚手架模板开发
 
-- 命令行
+- [命令行](https://wll8.github.io/sys-shim-doc/docs/cli/sys-shim.html)
 - 服务
 - 界面
 

package/script/npm-pkg/bin/index.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+import cp from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import process from 'node:process'
+import minimist from 'minimist'
+import {fn as pack} from './pack.mjs'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const cwd = `${__dirname}/../shim/win`
+const argv = minimist(process.argv.slice(2))
+const argv0 = argv._[0]
+
+new Promise(async () => {
+  if(argv0 === `pack`) {
+    await pack(argv)
+  } else {
+    cp.execSync(`${cwd}/main.exe`, {
+      cwd,
+      stdio: `inherit`,
+    })
+  }
+})

package/script/npm-pkg/bin/pack.mjs

@@ -0,0 +1,155 @@
+import cp from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import url from 'node:url'
+import os from 'node:os'
+import filenamify from 'filenamify'
+import download from 'download'
+import shelljs from 'shelljs'
+import {
+  simpleTemplate,
+} from '../../../src/util.js'
+import process from 'node:process'
+
+const __filename = url.fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const pkgDir = path.join(__dirname, `../../../`)
+
+function determinePathType(filePath) {
+  if((/^(http:\/\/|https:\/\/).+/i).test(filePath)) {
+    return `url`
+  } else if (path.isAbsolute(filePath)) {
+    return `abs`
+  } else if (filePath.startsWith(`./`) || filePath.startsWith(`../`)) {
+    return `relative`
+  } else {
+    return `sys`
+  }
+}
+
+
+/**
+ * 获取默认配置
+ */
+async function parseArgv(argv) {
+  const cfg = {
+    input: ``,
+    icon: ``,
+    out: ``,
+    unzip: ``,
+    password: ``,
+    ...argv,
+  }
+  if(determinePathType(argv.input) === `url`) {
+    cfg.icon = cfg.icon || await getIcon(`${cfg.input}/favicon.ico`)
+    cfg.out = cfg.out || filenamify(cfg.input)
+  } else {
+    cfg.icon = cfg.icon || await getIcon(`${cfg.input}/favicon.ico`)
+    cfg.out = cfg.out || path.parse(cfg.input).name
+  }
+  cfg.unzip = argv.unzip || `sys-shim-app/${cfg.out}`
+  return cfg
+}
+
+/**
+ * 如果不存在 icon 则返回默认 icon
+ */
+async function getIcon(iconPath) {
+  if(fs.existsSync(iconPath)) {
+    return iconPath
+  } else {
+    let icon
+    try {
+      const res = new url.URL(iconPath)
+      icon = `${res.protocol}//${res.host}/favicon.ico`
+      const tempIcon = `${os.tmpdir()}/${filenamify(icon)}`
+      fs.writeFileSync(tempIcon, await download(icon))
+      return tempIcon
+    } catch (error) {
+      console.warn(`从 ${icon} 获取图标错误：`)
+      console.warn(String(error))
+      console.warn(`将使用默认图标`)
+      return `${pkgDir}/script/npm-pkg/shim/win/favicon.ico`
+    }
+  }
+}
+
+function zip(cfg) {
+  const zipBin = `${pkgDir}/script/npm-pkg/lib/WinRAR.exe`
+  const icon = cfg.icon
+  const out = cfg.out
+  const input = cfg.input
+  const unzip = cfg.unzip
+
+  /**
+   * Path 解压后运行
+   * Silent 解压对话框 1 隐藏 2 显示
+   * Overwrite 解压覆盖询问 0 询问 1 覆盖 2 跳过
+   * Update 更新 U 解压不存在的或较新的 F 只更新目标位置已存在的
+   * Shortcut 创建快捷方式
+   *  D 桌面创建
+   *  P 在开始菜单/程序中创建
+   *  T 在启动菜单中创建
+   */
+  const comment = (() => {
+    const file = `${os.tmpdir()}/comment.txt`
+    const text = `
+      Path=${path.normalize(unzip)}
+      Setup=main
+      Silent=1
+      Overwrite=1
+      Update=U
+      Shortcut=D, main, , "sys-shim app", "${cfg.out}", favicon.ico
+    `.split(`\n`).map(item => item.trim()).join(`\n`).trim()
+    fs.writeFileSync(file, text)
+    return file
+  })()
+
+  /**
+   * a 添加压缩
+   * -r 递归
+   * -ep1 从名称中排除主文件夹
+   * -inul 关闭错误信息
+   * -y 假设全部的询问回应皆为“是”
+   * -sfx 创建自解压文件 默认为 Default.SFX 模块，修改示例 -sfxWinCon.SFX
+   * -iicon 指定自解压图标
+   * -iimg 指定自解压图片
+   * -m 设置压缩等级，-m0 为存储，-m5 为最优，默认 -m3 标准
+   * -p 使用密码，例如 -pMyPassWord
+   * -hp 使用密码，并加密文件名
+   * -z 从文件中读取注释
+   * -ibck 在后台运行 WinRAR
+   * -idv 显示详细输出
+   */
+  const outV = `${out}-${Date.now()}`
+  const cmd = `${zipBin} a -r -ep1 -y -ibck -sfx -iicon"${icon}" -z"${comment}" "${outV}" ${input}/*`
+  cp.execSync(cmd, {stdio: `inherit`})
+}
+
+function genFile(cfg) {
+  const newCfg = {
+    input: `${os.tmpdir()}/pack.temp`,
+    icon: `${os.tmpdir()}/pack.temp/favicon.ico`,
+  }
+  shelljs.rm(`-fr`, newCfg.input)
+  shelljs.cp(`-fr`, `${pkgDir}/template/pack`, newCfg.input)
+  shelljs.cp(`-f`, `${pkgDir}/script/npm-pkg/shim/win/main.exe`, newCfg.input)
+  shelljs.cp(`-f`, `${pkgDir}/script/npm-pkg/shim/win/favicon.ico`, newCfg.input)
+  shelljs.cp(`-f`, cfg.icon, `${newCfg.input}/favicon.ico`)
+  const newStr = simpleTemplate(fs.readFileSync(`${newCfg.input}/package.json`, `utf8`), {
+    page: determinePathType(cfg.input) === `url` ? cfg.input : `page.html`,
+  })
+  fs.writeFileSync(`${newCfg.input}/package.json`, newStr)
+  return newCfg
+}
+
+
+export async function fn(argv) {
+  const cfg = await parseArgv(argv)
+  const {input, icon} = genFile(cfg)
+  cfg.input = input
+  cfg.icon = icon
+  console.log(cfg)
+  await zip(cfg)
+
+}

package/src/proxy-deep.js

@@ -0,0 +1,104 @@
+'use strict'
+
+function parsePath(text) {
+  return text.split(`.`)
+}
+
+function push(arr, el) {
+  const newArr = arr.slice()
+  newArr.push(el)
+  return newArr
+}
+
+// names of the traps that can be registered with ES6's Proxy object
+const trapNames = [
+  `apply`,
+  `construct`,
+  `defineProperty`,
+  `deleteProperty`,
+  `enumerate`,
+  `get`,
+  `getOwnPropertyDescriptor`,
+  `getPrototypeOf`,
+  `has`,
+  `isExtensible`,
+  `ownKeys`,
+  `preventExtensions`,
+  `set`,
+  `setPrototypeOf`,
+]
+
+// a list of paramer indexes that indicate that the a recieves a key at that parameter
+// this information will be used to update the path accordingly
+const keys = {
+  get: 1,
+  set: 1,
+  deleteProperty: 1,
+  has: 1,
+  defineProperty: 1,
+  getOwnPropertyDescriptor: 1,
+}
+
+export function DeepProxy(rootTarget, traps, options) {
+
+  let path = []
+  let _userData = {}
+
+  if (options !== undefined && typeof options.path !== `undefined`) {
+    path = parsePath(options.path)
+  }
+  if (options !== undefined && typeof options.userData !== `undefined`) {
+    _userData = options.userData
+  }
+
+  function createProxy(target, path, userData = {}) {
+
+    // avoid creating a new object between two traps
+    const context = { rootTarget, path }
+    Object.assign(context, _userData, userData)
+
+    const realTraps = {}
+
+    for (const trapName of trapNames) {
+      const keyParamIdx = keys[trapName]
+        , trap = traps[trapName]
+
+      if (typeof trap !== `undefined`) {
+
+        if (typeof keyParamIdx !== `undefined`) {
+
+          realTraps[trapName] = function () {
+
+            const key = arguments[keyParamIdx]
+
+            // update context for this trap
+            context.nest = function (nestedTarget, { userData = {} } = {}) {
+              if (nestedTarget === undefined)
+                nestedTarget = rootTarget
+              return createProxy(nestedTarget, push(path, key), userData)
+            }
+            return trap.apply(context, arguments)
+          }
+        } else {
+
+          realTraps[trapName] = function () {
+
+            // update context for this trap
+            context.nest = function (nestedTarget, { userData = {} } = {}) {
+              if (nestedTarget === undefined)
+                nestedTarget = {}
+              return createProxy(nestedTarget, path, userData)
+            }
+
+            return trap.apply(context, arguments)
+          }
+        }
+      }
+    }
+
+    return new Proxy(target, realTraps)
+  }
+
+  return createProxy(rootTarget, path)
+
+}

package/src/util.js

@@ -0,0 +1,386 @@
+import { DeepProxy } from './proxy-deep.js'
+const KEYS_MAP = new Map()
+export function get([key]) {
+  return KEYS_MAP.get(key) || key
+}
+
+/**
+ * 获取 `/**` 中 `*` 号的数量
+ * @param {*} inputStr
+ * @returns
+ */
+export function getCodeLine(inputStr) {
+  // 使用正则表达式匹配以 `/` 开头，后面跟着连续的 `*` 号的模式，使用贪婪匹配
+  const pattern = /\/\*{1,}/g
+  const matches = inputStr.match(pattern)
+
+  // 如果没有匹配到任何 '/**'，返回0或者其他默认值
+  if (!matches) {
+    return 0
+  }
+
+  // 初始化最大 '**' 数量和对应的 '/**' 字符串
+  let maxAsterisks = 0
+  let maxAsterisksMatch = ``
+
+  // 遍历所有匹配结果，找出包含最多 '*' 号的那一个
+  for (const match of matches) {
+    const asterisksCount = match.length - 1 // 减去前面的 '/'
+    if (asterisksCount > maxAsterisks) {
+      maxAsterisks = asterisksCount
+      maxAsterisksMatch = match
+    }
+  }
+
+  // 返回最多的 '*' 号数量
+  return maxAsterisks
+}
+
+export function deepProxy({
+  keys = [`then`, `catch`],
+  cb = (records) => {
+    return new Promise(async (res, rej) => {
+      // 模拟异步操作
+      setTimeout(() => {
+        res(records)
+      }, Math.random() * 1000)
+    })
+  },
+} = {}) {
+  keys.forEach(key => {
+    let _val = Symbol(key)
+    KEYS_MAP.set(key, _val)
+    KEYS_MAP.set(_val, key)
+  })
+  function getRecords(context = {}) {
+    return context.records || []
+  }
+  // 代理处理程序
+  const handler = {
+    get(target, key, receiver) {
+      let records = getRecords(this)
+      if (keys.includes(key)) {
+        let promise = cb(records)
+        records.hackRun = true // 已运行过
+        return promise[key].bind(promise)
+      } else {
+        records.push({ type: `get`, key: get([key]) })
+        let newTarget = function () { }
+        return this.nest(newTarget, { userData: { records } })
+      }
+    },
+    apply(target, thisArg, args) {
+      let records = getRecords(this)
+      setTimeout(() => {
+        let recordsEnd = getRecords(this)
+        !recordsEnd.hackRun && cb(recordsEnd)
+      }, 0)
+      const key = records[records.length - 1].key
+      records[records.length - 1] = { type: `apply`, key, arg: args }
+      let newTarget = function () { }
+      return this.nest(newTarget, { userData: { records } })
+    },
+    construct(target, args) {
+      let records = getRecords(this)
+      records.push({ type: `construct`, arg: args })
+      let newTarget = function () { }
+      return this.nest(newTarget, { userData: { records } })
+    },
+    defineProperty(target, key, args) {
+      let records = getRecords(this)
+      records.push({ type: `defineProperty`, key, arg: args })
+      let newTarget = function () { }
+      return this.nest(newTarget, { userData: { records } })
+    },
+    deleteProperty(target, key) {
+      let records = getRecords(this)
+      records.push({ type: `deleteProperty`, key })
+      let newTarget = function () { }
+      return this.nest(newTarget, { userData: { records } })
+
+    },
+    set(target, key, value) {
+      let records = getRecords(this)
+      records.push({ type: `set`, key, arg: value })
+      let newTarget = function () { }
+      return this.nest(newTarget, { userData: { records } })
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      let records = getRecords(this)
+      records.push({ type: `getOwnPropertyDescriptor`, key: prop })
+      let newTarget = function () { }
+      return { configurable: true, enumerable: true, value: this.nest(newTarget) }
+    },
+    getPrototypeOf(target) {
+      let records = getRecords(this)
+      records.push({ type: `getPrototypeOf` })
+      let newTarget = function () { }
+      return this.nest(newTarget, { userData: { records } })
+    },
+    has(target, prop) {
+      let records = getRecords(this)
+      records.push({ type: `has`, key: prop })
+      return true
+    },
+    isExtensible(target) {
+      let records = getRecords(this)
+      records.push({ type: `isExtensible` })
+      return true
+    },
+    setPrototypeOf(target, prototype) {
+      let records = getRecords(this)
+      records.push({ type: `setPrototypeOf`, arg: prototype })
+      return true
+    },
+    ownKeys(target) {
+      let records = getRecords(this)
+      records.push({ type: `ownKeys` })
+      return Reflect.ownKeys(target)
+    },
+    preventExtensions(target) {
+      let records = getRecords(this)
+      records.push({ type: `preventExtensions` })
+      Object.preventExtensions(target)
+      return true
+    },
+  }
+
+  // 返回初始对象的代理
+  return new DeepProxy({}, handler)
+}
+
+export function binaryArrayToBuffer(binaryArray) {
+  let buffer = new ArrayBuffer(binaryArray.length)
+  let view = new Uint8Array(buffer)
+  for (let i = 0; i < binaryArray.length; i++) {
+    view[i] = binaryArray[i]
+  }
+  return buffer
+}
+
+/**
+ * 删除左边空格
+ * @param {*} str
+ * @returns
+ */
+export function removeLeft(str) {
+  const lines = str.split(`\n`)
+  // 获取应该删除的空白符数量
+  const minSpaceNum = lines.filter(item => item.trim())
+    .map(item => item.match(/(^\s+)?/)[0].length)
+    .sort((a, b) => a - b)[0]
+  // 删除空白符
+  const newStr = lines
+    .map(item => item.slice(minSpaceNum))
+    .join(`\n`)
+  return newStr
+}
+
+/**
+ * 简单的模板功能
+ * @param {*} template
+ * @param {*} data
+ * @returns
+ */
+export function simpleTemplate(template, data) {
+  return template.replace(/#\{(\w+)\}/g, (match, key, pos) => {
+    const lineStr = getLineContainingChar(template, pos)
+    const spaceNum = getMinSpaceNum(lineStr)
+    const val = data[key] || ``
+    const newVal = addSpace(val, {num: spaceNum})
+    return newVal
+  })
+}
+
+/**
+ * 返回字符所在位置的整行文本
+ * @param {*} text
+ * @param {*} charPosition
+ * @returns
+ */
+export function getLineContainingChar(text, charPosition) {
+  // 将多行文本分割成行数组
+  const lines = text.split(`\n`)
+
+  // 遍历行数组，找到包含给定字符位置的行
+  for (let i = 0; i < lines.length; i++) {
+      // 计算当前行的字符位置
+      const lineLength = lines[i].length
+      if (charPosition < lineLength) {
+          // 如果字符位置在当前行内，返回该行
+          return lines[i]
+      } else {
+          // 否则，减去当前行的长度，继续检查下一行
+          charPosition -= lineLength + 1 // +1 是为了减去换行符
+      }
+  }
+
+  // 如果没有找到包含给定字符位置的行，返回null或适当的错误信息
+  return null
+}
+
+/**
+ * 获取最小空白符数量
+ * @param {*} str
+ * @returns
+ */
+export function getMinSpaceNum(str) {
+  const lines = str.split(`\n`)
+  const minSpaceNum = lines.filter(item => item.trim())
+    .map(item => item.match(/(^\s+)?/)[0].length)
+    .sort((a, b) => a - b)[0]
+  return minSpaceNum
+}
+
+/**
+ * 添加空白符
+ * @param {*} str
+ * @param {*} opt
+ * @returns
+ */
+export function addSpace(str, opt = {}) {
+  opt = {
+    num: 0, // 字符符数量
+    space: ` `,
+    skip: 0, // 要跳过设置的索引
+    ...opt,
+  }
+  const lines = str.split(`\n`)
+  const newStr = lines
+    .map((item, index) => index <= opt.skip ? item : opt.space.repeat(opt.num) + item)
+    .join(`\n`)
+  return newStr
+}
+
+/**
+ * 获取 uuid
+ * @returns
+ */
+export function getUuid () {
+  if (typeof crypto === `object`) {
+    if (typeof crypto.randomUUID === `function`) {
+      return crypto.randomUUID()
+    }
+    if (typeof crypto.getRandomValues === `function` && typeof Uint8Array === `function`) {
+      const callback = (c) => {
+        const num = Number(c)
+        return (num ^ (crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (num / 4)))).toString(16)
+      }
+      return ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, callback)
+    }
+  }
+  let timestamp = new Date().getTime()
+  let perforNow = (typeof performance !== `undefined` && performance.now && performance.now() * 1000) || 0
+  return `xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx`.replace(/[xy]/g, (c) => {
+    let random = Math.random() * 16
+    if (timestamp > 0) {
+      random = (timestamp + random) % 16 | 0
+      timestamp = Math.floor(timestamp / 16)
+    } else {
+      random = (perforNow + random) % 16 | 0
+      perforNow = Math.floor(perforNow / 16)
+    }
+    return (c === `x` ? random : (random & 0x3) | 0x8).toString(16)
+  })
+}
+
+export function isUTF8MultiByteStart(byte) {
+  // 如果字节的高位为11，则是多字节字符的起始字节
+  return (byte & 0xC0) === 0xC0
+}
+
+export function isUTF8MultiByteContinuation(byte) {
+  // 如果字节的高位为10，则是多字节字符的延续字节
+  return (byte & 0xC0) === 0x80
+}
+
+
+/**
+ * 根据字节长度分割字符串
+ * @param {*} param0
+ * @returns
+ */
+export function sliceStringByBytes({lib, str, sliceLength}) {
+  const uint8Array = lib.encoder.encode(str)
+  let slices = []
+  let start = 0
+
+  while (start < uint8Array.length) {
+    let end = start + sliceLength
+    if (end > uint8Array.length) {
+      end = uint8Array.length
+    } else {
+      // 确保不在多字节字符中间断开
+      while (end > start && isUTF8MultiByteContinuation(uint8Array[end - 1])) {
+        end--
+      }
+      // 如果我们在多字节字符的起始处中止，则再次前移
+      if (end > start && isUTF8MultiByteStart(uint8Array[end - 1])) {
+        end--
+      }
+    }
+
+    const slice = uint8Array.subarray(start, end)
+    slices.push(lib.decoder.decode(slice))
+    start = end // 设置下次分片的起始位置
+  }
+
+  return slices
+}
+
+export function isType(data, type = undefined) { // 判断数据是否为 type, 或返回 type
+  const dataType = Object.prototype.toString.call(data).match(/\s(.+)]/)[1].toLowerCase()
+  return type ? (dataType === type.toLowerCase()) : dataType
+}
+
+/**
+ * 判断是否为空值
+ * @param {*} value 要判断的值
+ */
+export function isEmpty(value) {
+  return [NaN, null, undefined, ``, [], {}].some((emptyItem) =>
+    typeof value === `string` && value
+      ? false
+      : JSON.stringify(value) === JSON.stringify(emptyItem),
+  )
+}
+
+/**
+ * 删除空值
+ * @param {object} obj 要处理的数据
+ */
+export function removeEmpty(obj) {
+  return JSON.parse(JSON.stringify(obj), (key, value) => {
+    if (isEmpty(value) === false && Array.isArray(value)) {
+      value = value.filter((v) => !isEmpty(v))
+    }
+    return isEmpty(value) ? undefined : value
+  })
+}
+
+/**
+ * 函数缓存器，相同参数只会执行一次
+ * @param {*} fn
+ * @returns
+ */
+export function memoize(fn) {
+  const cache = new Map() // 使用Map来存储缓存结果
+
+  function memoized(...args) {
+    const key = JSON.stringify(args) // 将参数转换为字符串作为缓存的键
+    if (cache.has(key)) {
+      return cache.get(key) // 如果缓存中已存在，直接返回缓存的结果
+    }
+
+    const result = fn.apply(this, args) // 否则，调用函数并存储结果
+    cache.set(key, result)
+    return result
+  }
+
+  // 添加一个方法来清除缓存
+  memoized.clearCache = function() {
+    cache.clear()
+  }
+
+  return memoized
+}

package/template/pack/package.json

@@ -0,0 +1,4 @@
+{
+  "browserArguments": "--disable-web-security --allow-running-insecure-content",
+  "page": "#{page}"
+}

package/template/pack/preload.js

@@ -0,0 +1,5 @@
+document.addEventListener(`DOMContentLoaded`, async () => {
+  new window.Sys().then(async main => {
+    window.sys = main
+  })
+})

package/template/pack/readme.md

@@ -0,0 +1,6 @@
+直接通过 url 生成程序。
+
+``` sh
+sys-shim pack --input [url]
+```
+

package/script/bin/sys-shim.cjs

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-
-const cp = require(`child_process`)
-const cwd = `${__dirname}/../npm-pkg/shim/win/`
-cp.execSync(`${cwd}/main.exe`, {
-  cwd,
-  stdio: `inherit`,
-})