@jayfong/x-utils 1.0.0-202407012223

package/_cjs/unicode/unicode.js

@@ -0,0 +1,441 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var unicode_exports = {};
+__export(unicode_exports, {
+  XUnicode: () => XUnicode
+});
+module.exports = __toCommonJS(unicode_exports);
+var import_vtils = require("vtils");
+var import_puppeteer = require("../puppeteer.js");
+var import_text = require("../text.js");
+var import_lib_unicode = require("./lib_unicode.js");
+const ublockMap = {
+  // @index('./lib_unicode.js', /BlockStart\[(\d+)\]\s*=\s*"(.+?)";\s*\/\/\s*([^\(\r\n]+)\b/g, m => `'${m[3]}': ${m[1]},`)
+  "Basic Latin": 0,
+  "Latin-1 Supplement": 1,
+  "Latin Extended-A": 2,
+  "Latin Extended-B": 3,
+  "IPA Extensions": 4,
+  "Spacing Modifier Letters": 5,
+  "Combining Diacritical Marks": 6,
+  "Greek and Coptic": 7,
+  Cyrillic: 8,
+  "Cyrillic Supplement": 9,
+  Armenian: 10,
+  Hebrew: 11,
+  Arabic: 12,
+  Syriac: 13,
+  "Arabic Supplement": 14,
+  Thaana: 15,
+  NKo: 16,
+  Samaritan: 17,
+  Mandaic: 18,
+  "Syriac Supplement": 19,
+  "Arabic Extended-B": 20,
+  "Arabic Extended-A": 21,
+  Devanagari: 22,
+  Bengali: 23,
+  Gurmukhi: 24,
+  Gujarati: 25,
+  Oriya: 26,
+  Tamil: 27,
+  Telugu: 28,
+  Kannada: 29,
+  Malayalam: 30,
+  Sinhala: 31,
+  Thai: 32,
+  Lao: 33,
+  Tibetan: 34,
+  Myanmar: 35,
+  Georgian: 36,
+  "Hangul Jamo": 37,
+  Ethiopic: 38,
+  "Ethiopic Supplement": 39,
+  Cherokee: 40,
+  "Unified Canadian Aboriginal Syllabics": 41,
+  Ogham: 42,
+  Runic: 43,
+  Tagalog: 44,
+  Hanunoo: 45,
+  Buhid: 46,
+  Tagbanwa: 47,
+  Khmer: 48,
+  Mongolian: 49,
+  "Unified Canadian Aboriginal Syllabics Extended": 50,
+  Limbu: 51,
+  "Tai Le": 52,
+  "New Tai Lue": 53,
+  "Khmer Symbols": 54,
+  Buginese: 55,
+  "Tai Tham": 56,
+  "Combining Diacritical Marks Extended": 57,
+  Balinese: 58,
+  Sundanese: 59,
+  Batak: 60,
+  Lepcha: 61,
+  "Ol Chiki": 62,
+  "Cyrillic Extended-C": 63,
+  "Georgian Extended": 64,
+  "Sundanese Supplement": 65,
+  "Vedic Extensions": 66,
+  "Phonetic Extensions": 67,
+  "Phonetic Extensions Supplement": 68,
+  "Combining Diacritical Marks Supplement": 69,
+  "Latin Extended Additional": 70,
+  "Greek Extended": 71,
+  "General Punctuation": 72,
+  "Superscripts and Subscripts": 73,
+  "Currency Symbols": 74,
+  "Combining Diacritical Marks for Symbols": 75,
+  "Letterlike Symbols": 76,
+  "Number Forms": 77,
+  Arrows: 78,
+  "Mathematical Operators": 79,
+  "Miscellaneous Technical": 80,
+  "Control Pictures": 81,
+  "Optical Character Recognition": 82,
+  "Enclosed Alphanumerics": 83,
+  "Box Drawing": 84,
+  "Block Elements": 85,
+  "Geometric Shapes": 86,
+  "Miscellaneous Symbols": 87,
+  Dingbats: 88,
+  "Miscellaneous Mathematical Symbols-A": 89,
+  "Supplemental Arrows-A": 90,
+  "Braille Patterns": 91,
+  "Supplemental Arrows-B": 92,
+  "Miscellaneous Mathematical Symbols-B": 93,
+  "Supplemental Mathematical Operators": 94,
+  "Miscellaneous Symbols and Arrows": 95,
+  Glagolitic: 96,
+  "Latin Extended-C": 97,
+  Coptic: 98,
+  "Georgian Supplement": 99,
+  Tifinagh: 100,
+  "Ethiopic Extended": 101,
+  "Cyrillic Extended-A": 102,
+  "Supplemental Punctuation": 103,
+  "CJK Radicals Supplement": 104,
+  "Kangxi Radicals": 105,
+  "Ideographic Description Characters": 106,
+  "CJK Symbols and Punctuation": 107,
+  Hiragana: 108,
+  Katakana: 109,
+  Bopomofo: 110,
+  "Hangul Compatibility Jamo": 111,
+  Kanbun: 112,
+  "Bopomofo Extended": 113,
+  "CJK Strokes": 114,
+  "Katakana Phonetic Extensions": 115,
+  "Enclosed CJK Letters and Months": 116,
+  "CJK Compatibility": 117,
+  "CJK Unified Ideographs Extension A": 118,
+  "Yijing Hexagram Symbols": 119,
+  "CJK Unified Ideographs": 120,
+  "Yi Syllables": 121,
+  "Yi Radicals": 122,
+  Lisu: 123,
+  Vai: 124,
+  "Cyrillic Extended-B": 125,
+  Bamum: 126,
+  "Modifier Tone Letters": 127,
+  "Latin Extended-D": 128,
+  "Syloti Nagri": 129,
+  "Common Indic Number Forms": 130,
+  "Phags-pa": 131,
+  Saurashtra: 132,
+  "Devanagari Extended": 133,
+  "Kayah Li": 134,
+  Rejang: 135,
+  "Hangul Jamo Extended-A": 136,
+  Javanese: 137,
+  "Myanmar Extended-B": 138,
+  Cham: 139,
+  "Myanmar Extended-A": 140,
+  "Tai Viet": 141,
+  "Meetei Mayek Extensions": 142,
+  "Ethiopic Extended-A": 143,
+  "Latin Extended-E": 144,
+  "Cherokee Supplement": 145,
+  "Meetei Mayek": 146,
+  "Hangul Syllables": 147,
+  "Hangul Jamo Extended-B": 148,
+  "Private Use Area": 149,
+  "CJK Compatibility Ideographs": 150,
+  "Alphabetic Presentation Forms": 151,
+  "Arabic Presentation Forms-A": 152,
+  "Variation Selectors": 153,
+  "Vertical Forms": 154,
+  "Combining Half Marks": 155,
+  "CJK Compatibility Forms": 156,
+  "Small Form Variants": 157,
+  "Arabic Presentation Forms-B": 158,
+  "Halfwidth and Fullwidth Forms": 159,
+  Specials: 160,
+  "Linear B Syllabary": 161,
+  "Linear B Ideograms": 162,
+  "Aegean Numbers": 163,
+  "Ancient Greek Numbers": 164,
+  "Ancient Symbols": 165,
+  "Phaistos Disc": 166,
+  Lycian: 167,
+  Carian: 168,
+  "Coptic Epact Numbers": 169,
+  "Old Italic": 170,
+  Gothic: 171,
+  "Old Permic": 172,
+  Ugaritic: 173,
+  "Old Persian": 174,
+  Deseret: 175,
+  Shavian: 176,
+  Osmanya: 177,
+  Osage: 178,
+  Elbasan: 179,
+  "Caucasian Albanian": 180,
+  Vithkuqi: 181,
+  "Linear A": 182,
+  "Latin Extended-F": 183,
+  "Cypriot Syllabary": 184,
+  "Imperial Aramaic": 185,
+  Palmyrene: 186,
+  Nabataean: 187,
+  Hatran: 188,
+  Phoenician: 189,
+  Lydian: 190,
+  "Meroitic Hieroglyphs": 191,
+  "Meroitic Cursive": 192,
+  Kharoshthi: 193,
+  "Old South Arabian": 194,
+  "Old North Arabian": 195,
+  Manichaean: 196,
+  Avestan: 197,
+  "Inscriptional Parthian": 198,
+  "Inscriptional Pahlavi": 199,
+  "Psalter Pahlavi": 200,
+  "Old Turkic": 201,
+  "Old Hungarian": 202,
+  "Hanifi Rohingya": 203,
+  "Rumi Numeral Symbols": 204,
+  Yezidi: 205,
+  "Arabic Extended-C": 206,
+  "Old Sogdian": 207,
+  Sogdian: 208,
+  "Old Uyghur": 209,
+  Chorasmian: 210,
+  Elymaic: 211,
+  Brahmi: 212,
+  Kaithi: 213,
+  "Sora Sompeng": 214,
+  Chakma: 215,
+  Mahajani: 216,
+  Sharada: 217,
+  "Sinhala Archaic Numbers": 218,
+  Khojki: 219,
+  Multani: 220,
+  Khudawadi: 221,
+  Grantha: 222,
+  Newa: 223,
+  Tirhuta: 224,
+  Siddham: 225,
+  Modi: 226,
+  "Mongolian Supplement": 227,
+  Takri: 228,
+  Ahom: 229,
+  Dogra: 230,
+  "Warang Citi": 231,
+  "Dives Akuru": 232,
+  Nandinagari: 233,
+  "Zanabazar Square": 234,
+  Soyombo: 235,
+  "Unified Canadian Aboriginal Syllabics Extended-A": 236,
+  "Pau Cin Hau": 237,
+  "Devanagari Extended-A": 238,
+  Bhaiksuki: 239,
+  Marchen: 240,
+  "Masaram Gondi": 241,
+  "Gunjala Gondi": 242,
+  Makasar: 243,
+  Kawi: 244,
+  "Lisu Supplement": 245,
+  "Tamil Supplement": 246,
+  Cuneiform: 247,
+  "Cuneiform Numbers and Punctuation": 248,
+  "Early Dynastic Cuneiform": 249,
+  "Cypro-Minoan": 250,
+  "Egyptian Hieroglyphs": 251,
+  "Egyptian Hieroglyph Format Controls": 252,
+  "Anatolian Hieroglyphs": 253,
+  "Bamum Supplement": 254,
+  Mro: 255,
+  Tangsa: 256,
+  "Bassa Vah": 257,
+  "Pahawh Hmong": 258,
+  Medefaidrin: 259,
+  Miao: 260,
+  "Ideographic Symbols and Punctuation": 261,
+  Tangut: 262,
+  "Tangut Components": 263,
+  "Khitan Small Script": 264,
+  "Tangut Supplement": 265,
+  "Kana Extended-B": 266,
+  "Kana Supplement": 267,
+  "Kana Extended-A": 268,
+  "Small Kana Extension": 269,
+  Nushu: 270,
+  Duployan: 271,
+  "Shorthand Format Controls": 272,
+  "Znamenny Musical Notation": 273,
+  "Byzantine Musical Symbols": 274,
+  "Musical Symbols": 275,
+  "Ancient Greek Musical Notation": 276,
+  "Kaktovik Numerals": 277,
+  "Mayan Numerals": 278,
+  "Tai Xuan Jing Symbols": 279,
+  "Counting Rod Numerals": 280,
+  "Mathematical Alphanumeric Symbols": 281,
+  "Sutton SignWriting": 282,
+  "Latin Extended-G": 283,
+  "Glagolitic Supplement": 284,
+  "Cyrillic Extended-D": 285,
+  "Nyiakeng Puachue Hmong": 286,
+  Toto: 287,
+  Wancho: 288,
+  "Nag Mundari": 289,
+  "Ethiopic Extended-B": 290,
+  "Mende Kikakui": 291,
+  Adlam: 292,
+  "Indic Siyaq Numbers": 293,
+  "Ottoman Siyaq Numbers": 294,
+  "Arabic Mathematical Alphabetic Symbols": 295,
+  "Mahjong Tiles": 296,
+  "Domino Tiles": 297,
+  "Playing Cards": 298,
+  "Enclosed Alphanumeric Supplement": 299,
+  "Enclosed Ideographic Supplement": 300,
+  "Miscellaneous Symbols and Pictographs": 301,
+  Emoticons: 302,
+  "Ornamental Dingbats": 303,
+  "Transport and Map Symbols": 304,
+  "Alchemical Symbols": 305,
+  "Geometric Shapes Extended": 306,
+  "Supplemental Arrows-C": 307,
+  "Supplemental Symbols and Pictographs": 308,
+  "Chess Symbols": 309,
+  "Symbols and Pictographs Extended-A": 310,
+  "Symbols for Legacy Computing": 311,
+  "CJK Unified Ideographs Extension B": 312,
+  "CJK Unified Ideographs Extension C": 313,
+  "CJK Unified Ideographs Extension D": 314,
+  "CJK Unified Ideographs Extension E": 315,
+  "CJK Unified Ideographs Extension F": 316,
+  "CJK Unified Ideographs Extension I": 317,
+  "CJK Compatibility Ideographs Supplement": 318,
+  "CJK Unified Ideographs Extension G": 319,
+  "CJK Unified Ideographs Extension H": 320,
+  Tags: 321,
+  "Variation Selectors Supplement": 322,
+  "Supplementary Private Use Area-A": 323,
+  "Supplementary Private Use Area-B": 324
+  // @endindex
+};
+class XUnicode {
+  static getBlockNames() {
+    return (0, import_vtils.keysStrict)(ublockMap).sort();
+  }
+  static getCharName(char) {
+    return (0, import_lib_unicode.ToCharacterNames)(char, false, true).trim().replace(/[\r\n]+/g, ";");
+  }
+  static getBlockChars(blockName) {
+    const ublock = ublockMap[blockName];
+    const start = (0, import_lib_unicode.GetBlockStart)(ublock);
+    const end = parseInt(import_lib_unicode.BlockEnd[ublock], 16);
+    const chars = [];
+    for (let char = start; char <= end; char++) {
+      if ((0, import_lib_unicode.GetCharacterName)(ublock, char, true)) {
+        chars.push(String.fromCodePoint(char));
+      }
+    }
+    return chars;
+  }
+  static isCharVisibleId = 0;
+  static isCharVisibleGetCharBuffer = async (char, page) => {
+    const id = `_${XUnicode.isCharVisibleId++}`;
+    await page.evaluate(
+      (char2, id2) => {
+        const el = document.createElement("span");
+        el.innerText = char2;
+        el.id = id2;
+        document.body.appendChild(el);
+      },
+      char,
+      id
+    );
+    const charEl = await page.$(`#${id}`);
+    const charBuffer = await charEl.screenshot();
+    await page.evaluate((id2) => {
+      document.querySelector(`#${id2}`)?.remove();
+    }, id);
+    return charBuffer;
+  };
+  static isCharVisibleBrowsers = [];
+  static isCharVisibleInit = (0, import_vtils.memoize)(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async (flag) => {
+      const { html } = import_text.XText;
+      const browser = await import_puppeteer.XPuppeteer.openBrowser();
+      XUnicode.isCharVisibleBrowsers.push(browser);
+      const page = await browser.openPage(html`
+        <html>
+          <head>
+            <style>
+              span {
+                display: inline-block;
+                width: 100px;
+                height: 100px;
+                font-size: 40px;
+                color: red;
+              }
+            </style>
+          </head>
+          <body></body>
+        </html>
+      `);
+      const invisibleCharBuffer = await XUnicode.isCharVisibleGetCharBuffer(
+        "\u{18BE8}",
+        page
+      );
+      return {
+        browser,
+        page,
+        invisibleCharBuffer
+      };
+    },
+    (flag) => flag
+  );
+  static async isCharVisibleDispose() {
+    await Promise.all(
+      XUnicode.isCharVisibleBrowsers.map((browser) => browser.close())
+    );
+  }
+  static async isCharVisible(char, flag = 0) {
+    const { page, invisibleCharBuffer } = await XUnicode.isCharVisibleInit(flag);
+    const charBuffer = await XUnicode.isCharVisibleGetCharBuffer(char, page);
+    return !charBuffer.equals(invisibleCharBuffer);
+  }
+}

package/_cjs/upload.js

@@ -0,0 +1,100 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var upload_exports = {};
+__export(upload_exports, {
+  XUpload: () => XUpload
+});
+module.exports = __toCommonJS(upload_exports);
+var import_x_request = require("@jayfong/x-request");
+var import_file_type = require("file-type");
+var fs = __toESM(require("node:fs"), 1);
+var import_sharp = __toESM(require("sharp"), 1);
+var import_vtils = require("vtils");
+var import_env = require("./env.js");
+class XUpload {
+  /**
+   * 上传文件
+   *
+   * @param file 文件本地路径、文件 URL、文件 Buffer
+   * @param options 选项
+   * @param options.provider 默认 auto
+   * @param options.source 默认 my-auto-tasks
+   */
+  static async upload(file, {
+    serverUrl,
+    serverToken,
+    provider = "auto",
+    source = "my-auto-tasks",
+    compress = false
+  } = {}) {
+    if (serverUrl == null) {
+      serverUrl = await import_env.XEnv.getEnvVar("X_UPLOAD_SERVER_URL");
+    }
+    if (serverToken == null) {
+      serverToken = await import_env.XEnv.getEnvVar("X_UPLOAD_SERVER_TOKEN");
+    }
+    if (typeof file === "string") {
+      if ((0, import_vtils.isUrl)(file)) {
+        const { data: data2 } = await import_x_request.xr.get({
+          url: file,
+          autoReferer: true
+        });
+        file = data2;
+      } else {
+        file = await fs.promises.readFile(file);
+      }
+    }
+    const { ext: fileExt } = await (0, import_file_type.fileTypeFromBuffer)(file);
+    const imageExts = ["jpg", "png", "gif"];
+    const isImage = imageExts.includes(fileExt);
+    provider = provider === "auto" ? isImage ? "image" : "file" : provider;
+    if (isImage && compress) {
+      const compressor = (0, import_sharp.default)(file);
+      file = fileExt === "png" ? await compressor.png({
+        quality: 80,
+        compressionLevel: 6
+      }).toBuffer() : fileExt === "jpg" ? await compressor.jpeg({
+        quality: 80
+      }).toBuffer() : file;
+    }
+    const { data } = await import_x_request.xr.postJson({
+      url: serverUrl,
+      data: import_x_request.xr.formData({
+        token: serverToken,
+        provider,
+        returnRawUrl: 1,
+        source,
+        file: import_x_request.xr.formFile(file, {
+          name: `xxx.${fileExt}`
+        })
+      })
+    });
+    return data;
+  }
+}

package/_cjs/yaml.js

@@ -0,0 +1,52 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var yaml_exports = {};
+__export(yaml_exports, {
+  XYaml: () => XYaml
+});
+module.exports = __toCommonJS(yaml_exports);
+var fs = __toESM(require("node:fs"), 1);
+var import_yaml = __toESM(require("yaml"), 1);
+class XYaml {
+  static parse(value) {
+    return import_yaml.default.parse(value);
+  }
+  static stringify(value) {
+    return import_yaml.default.stringify(value, {
+      blockQuote: "literal"
+    });
+  }
+  static async read(file) {
+    const value = await fs.promises.readFile(file, "utf8");
+    return XYaml.parse(value);
+  }
+  static async write(file, value) {
+    await fs.promises.writeFile(file, XYaml.stringify(value));
+  }
+}

package/ai.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="lodash" />
+declare abstract class AiProvider {
+    abstract prepare(): Promise<void>;
+    abstract ask(question: string): Promise<string>;
+}
+export declare class CozeAiProvider extends AiProvider {
+    private options;
+    private xp;
+    private page;
+    constructor(options: {
+        botUrl: string;
+    });
+    prepare(): Promise<void>;
+    ask(question: string): Promise<string>;
+}
+export type XAiOptions = {
+    provider: AiProvider;
+};
+export declare class XAi {
+    private options;
+    private provider;
+    constructor(options: XAiOptions);
+    prepare: (() => Promise<void>) & import("lodash").MemoizedFunction;
+    ask(question: string): Promise<string>;
+}
+export {};

package/ai.js

@@ -0,0 +1,60 @@
+import { loopUntil, memoize, wait } from "vtils";
+import { XPuppeteer } from "./puppeteer.js";
+class AiProvider {
+}
+class CozeAiProvider extends AiProvider {
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  xp;
+  page;
+  async prepare() {
+    this.xp = new XPuppeteer();
+    await this.xp.connectSystemBrowser();
+    this.page = await this.xp.openPage(this.options.botUrl);
+  }
+  async ask(question) {
+    const page = this.page;
+    await page.evaluate(
+      () => document.querySelector("textarea:not([placeholder])").parentElement.parentElement.previousElementSibling.firstElementChild.click()
+    );
+    await wait(300);
+    await this.page.type("textarea:not([placeholder])", question);
+    await wait(500);
+    await this.page.keyboard.press("Enter");
+    await wait(1e3);
+    await loopUntil(
+      () => page.$$eval(
+        "button",
+        (els) => !els.find((el) => el.textContent.includes("Stop Responding"))?.parentElement.getBoundingClientRect().height
+      ),
+      {
+        retryDelay: 300
+      }
+    );
+    await wait(300);
+    const code = await page.$$eval(
+      'div[class^="code-area"]',
+      (els) => els.pop().querySelector('[class^="content"]').textContent
+    );
+    return code;
+  }
+}
+class XAi {
+  constructor(options) {
+    this.options = options;
+    this.provider = options.provider;
+  }
+  provider;
+  prepare = memoize(() => this.provider.prepare());
+  async ask(question) {
+    await this.prepare();
+    const answer = await this.provider.ask(question);
+    return answer;
+  }
+}
+export {
+  CozeAiProvider,
+  XAi
+};

package/cli.d.ts

@@ -0,0 +1,14 @@
+export type XCliPromptType = 'confirm' | 'input';
+export type XCliPromptResult = {
+    confirm: boolean;
+    input: string;
+};
+export type XCliPromptOptions<T extends XCliPromptType> = {
+    message: string;
+    type: T;
+    default?: XCliPromptResult[T];
+};
+export declare class XCli {
+    static prompt<T extends XCliPromptType>(options: XCliPromptOptions<T>): Promise<XCliPromptResult[T]>;
+    static table(data: any[][]): string;
+}