@allior/wmake-cli 0.0.1

package/README.md

@@ -0,0 +1,53 @@
+# @allior/wmake-cli
+
+CLI for streamiby / wmake: widget build, base64 encoding, field generation.
+
+## Installation
+
+```bash
+pnpm add -g @allior/wmake-cli
+# or from the monorepo:
+cd cli && pnpm install && pnpm run build
+```
+
+## Commands
+
+### `wmake widget`
+
+Builds chat-demo into widget files (html.txt, js.txt, css.txt, fields.txt, data.txt) and a zip archive in `examples/chat-demo/dist`.
+
+```bash
+wmake widget
+wmake widget --full   # full bundle without CDN (legacy build style)
+```
+
+### `wmake base64`
+
+Converts images, videos, and SVG to base64 for use in the browser.
+
+```bash
+wmake base64 <path>              # file or directory
+wmake base64 ./assets -o out     # output to file or directory
+wmake base64 ./img -f            # output with extra info
+```
+
+### `wmake generate-fields`
+
+Generates `fields.json` from `fields.base.json` and test data. Requires the `WMAKE_FIELDS_DIR` environment variable.
+
+```bash
+WMAKE_FIELDS_DIR=/path/to/fields wmake generate-fields
+```
+
+### `wmake extract-test-data`
+
+Test data lives in `streamelements/src/assets` as TS objects; this command is kept for compatibility.
+
+## Development
+
+```bash
+pnpm install
+pnpm run build    # compile
+pnpm run dev      # run via tsx (src/index.ts)
+pnpm start        # run compiled dist/index.js
+```

package/dist/base64.js

@@ -0,0 +1,85 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as mime from "mime-types";
+const SUPPORTED_IMAGE = [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".svg"];
+const SUPPORTED_VIDEO = [".mp4", ".webm", ".ogg", ".mov", ".avi"];
+const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB
+export function isSupportedFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return [...SUPPORTED_IMAGE, ...SUPPORTED_VIDEO].includes(ext);
+}
+export function fileToBase64(filePath) {
+    return new Promise((resolve, reject) => {
+        fs.stat(filePath, (err, stats) => {
+            if (err) {
+                reject(new Error(`Cannot access file: ${err.message}`));
+                return;
+            }
+            if (!stats.isFile()) {
+                reject(new Error("Path is not a file"));
+                return;
+            }
+            if (stats.size > MAX_FILE_SIZE) {
+                reject(new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE} bytes)`));
+                return;
+            }
+            if (!isSupportedFile(filePath)) {
+                reject(new Error("Unsupported file type"));
+                return;
+            }
+            fs.readFile(filePath, (err, data) => {
+                if (err) {
+                    reject(new Error(`Error reading file: ${err.message}`));
+                    return;
+                }
+                const mimeType = mime.lookup(filePath) || "application/octet-stream";
+                resolve({
+                    filename: path.basename(filePath),
+                    base64: data.toString("base64"),
+                    mimeType: String(mimeType),
+                    size: stats.size,
+                });
+            });
+        });
+    });
+}
+export function getOutputPath(output, originalFilename) {
+    if (fs.existsSync(output) && fs.statSync(output).isDirectory()) {
+        const name = path.basename(originalFilename, path.extname(originalFilename));
+        return path.join(output, `${name}_base64.txt`);
+    }
+    return output;
+}
+export async function processPath(inputPath, output, full) {
+    const stats = fs.statSync(inputPath);
+    if (stats.isFile()) {
+        const fileInfo = await fileToBase64(inputPath);
+        const dataUrl = `data:${fileInfo.mimeType};base64,${fileInfo.base64}`;
+        const content = full
+            ? `\nFile: ${fileInfo.filename}\nMIME Type: ${fileInfo.mimeType}\nSize: ${fileInfo.size} bytes\nBase64 Data URL:\n${dataUrl}\n${"-".repeat(50)}`
+            : dataUrl;
+        if (output) {
+            const outPath = getOutputPath(output, fileInfo.filename);
+            fs.writeFileSync(outPath, content);
+            console.log(`Output written to: ${outPath}`);
+        }
+        else {
+            console.log(content);
+        }
+    }
+    else if (stats.isDirectory()) {
+        const files = fs.readdirSync(inputPath);
+        let count = 0;
+        for (const file of files) {
+            const fullPath = path.join(inputPath, file);
+            if (fs.statSync(fullPath).isFile() && isSupportedFile(fullPath)) {
+                await processPath(fullPath, output, full);
+                count++;
+            }
+        }
+        if (count === 0)
+            console.log("No supported files found in directory");
+        else
+            console.log(`\nProcessed ${count} files`);
+    }
+}

package/dist/extract-test-data.js

@@ -0,0 +1,8 @@
+/**
+ * Раньше создавал test-messages.json и test-alerts.json в streamelements/src/assets.
+ * Теперь тестовые данные — объекты в скриптах: streamelements/src/assets/test-messages.ts и test-alerts.ts.
+ * Команда оставлена для совместимости (no-op).
+ */
+export async function runExtractTestData() {
+    console.log("Test data is defined in streamelements/src/assets (test-messages.ts, test-alerts.ts). No extraction needed.");
+}

package/dist/generate-fields-from-module-runner.js

@@ -0,0 +1,27 @@
+/**
+ * Запускается через tsx для загрузки TS-модуля с полями.
+ * Использование: tsx generate-fields-from-module-runner.ts <path-to-fields.ts> <path-to-fields.json>
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+const [, , modulePath, outPath] = process.argv;
+if (!modulePath || !outPath) {
+    console.error("Usage: tsx generate-fields-from-module-runner.ts <fields.ts> <fields.json>");
+    process.exit(1);
+}
+const absPath = path.resolve(modulePath);
+import(pathToFileURL(absPath).href)
+    .then((mod) => {
+    const fields = mod.default;
+    if (!Array.isArray(fields)) {
+        throw new Error(`Module must export default AdvancedField[]`);
+    }
+    const result = Object.assign({}, ...fields.map((f) => f.fieldObject));
+    fs.writeFileSync(outPath, JSON.stringify(result, null, 2), "utf-8");
+    console.log("Wrote", outPath);
+})
+    .catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/generate-fields.js

@@ -0,0 +1,88 @@
+/**
+ * Генерирует fields.json из fields.base.json и ключей из объектов testMessages / testAlerts.
+ * Путь к каталогу с fields.base.json задаётся WMAKE_FIELDS_DIR.
+ * Данные сообщений и алертов передаются объектами (из скриптов streamelements).
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+const TEST_GROUP = "Tests / Тесты";
+function pascalCase(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+/** camelCase → sentence case (e.g. veryShort → "Very short", selfSub → "Self sub") */
+function keyToTitle(key) {
+    const words = key
+        .replace(/([A-Z])/g, " $1")
+        .toLowerCase()
+        .trim();
+    return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function messageLabel(key) {
+    return `${keyToTitle(key)} message`;
+}
+function alertLabel(key) {
+    return `${keyToTitle(key)} alert`;
+}
+export function runGenerateFields(options) {
+    const { fieldsDir, testMessages: messages, testAlerts: alerts } = options;
+    const basePath = path.join(fieldsDir, "fields.base.json");
+    const outPath = path.join(fieldsDir, "fields.json");
+    const base = JSON.parse(fs.readFileSync(basePath, "utf-8"));
+    const messageKeys = Object.keys(messages);
+    const alertKeys = Object.keys(alerts);
+    const testMessageFields = {};
+    for (const key of messageKeys) {
+        const fieldId = "testMessage" + pascalCase(key);
+        testMessageFields[fieldId] = {
+            type: "button",
+            label: messageLabel(key),
+            group: TEST_GROUP,
+        };
+    }
+    const testAlertFields = {};
+    for (const key of alertKeys) {
+        const fieldId = "testAlert" + pascalCase(key);
+        testAlertFields[fieldId] = {
+            type: "button",
+            label: alertLabel(key),
+            group: TEST_GROUP,
+        };
+    }
+    const insertAfterKey = "blueFlowerAnimationDuration";
+    const result = {};
+    let inserted = false;
+    for (const k of Object.keys(base)) {
+        if (k.startsWith("_"))
+            continue;
+        result[k] = base[k];
+        if (k === insertAfterKey) {
+            Object.assign(result, testMessageFields, testAlertFields);
+            inserted = true;
+        }
+    }
+    if (!inserted) {
+        Object.assign(result, testMessageFields, testAlertFields);
+    }
+    fs.writeFileSync(outPath, JSON.stringify(result, null, 2), "utf-8");
+    console.log("Wrote", outPath);
+    console.log("Test message buttons:", messageKeys.length);
+    console.log("Test alert buttons:", alertKeys.length);
+}
+/**
+ * Генерирует fields.json из TS/JS модуля, экспортирующего default AdvancedField[].
+ * Использует tsx для загрузки .ts файлов.
+ */
+export function runGenerateFieldsFromModule(fieldsModulePath) {
+    const absPath = path.resolve(fieldsModulePath);
+    const outPath = path.join(path.dirname(absPath), "fields.json");
+    const runnerPath = path.join(__dirname, "..", "src", "generate-fields-from-module-runner.ts");
+    const r = spawnSync("npx", ["tsx", runnerPath, absPath, outPath], {
+        stdio: "inherit",
+        shell: true,
+        cwd: path.dirname(absPath),
+    });
+    if (r.status !== 0) {
+        throw new Error(`Failed to generate fields from ${fieldsModulePath}`);
+    }
+}

package/dist/get-events-data.mjs

@@ -0,0 +1,24 @@
+/**
+ * Запускается через node для загрузки ESM-модуля @allior/wmake-streamelements-events.
+ * Пишет в файл (argv[2]) JSON: { testMessages, testAlerts }.
+ * Использование: node get-events-data.mjs <output-path>
+ * Вызывать из корня пакета CLI (cwd = cli/), чтобы резолвился node_modules.
+ */
+import fs from "node:fs";
+import path from "node:path";
+
+const outPath = process.argv[2];
+if (!outPath) {
+  console.error("Usage: node get-events-data.mjs <output-path>");
+  process.exit(1);
+}
+
+const { testMessages, testAlerts } = await import(
+  "@allior/wmake-streamelements-events"
+);
+fs.writeFileSync(
+  path.resolve(outPath),
+  JSON.stringify({ testMessages, testAlerts }),
+  "utf-8",
+);
+console.log("Wrote", outPath);

package/dist/index.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { Command } from "commander";
+import * as fs from "fs";
+import { processPath } from "./base64.js";
+import { buildWidget } from "./widget.js";
+import { runGenerateFields } from "./generate-fields.js";
+import { runExtractTestData } from "./extract-test-data.js";
+const program = new Command();
+program.name("wmake").description("CLI for streamiby / wmake").version("1.0.0");
+program
+    .command("widget")
+    .description("Build chat-demo into widget files and zip in examples/chat-demo/dist")
+    .option("--full", "Full bundle (no CDN external), like the old build")
+    .action(async (opts) => {
+    try {
+        await buildWidget({ full: opts.full });
+    }
+    catch (e) {
+        console.error(e.message);
+        process.exit(1);
+    }
+});
+program
+    .command("generate-fields")
+    .description("Generate fields.json from fields.base.json and test data objects (WMAKE_FIELDS_DIR)")
+    .action(async () => {
+    try {
+        const fieldsDir = process.env.WMAKE_FIELDS_DIR;
+        if (!fieldsDir?.trim()) {
+            throw new Error("WMAKE_FIELDS_DIR must be set.");
+        }
+        const mod = (await import("@allior/wmake-streamelements-events"));
+        runGenerateFields({
+            fieldsDir: path.resolve(fieldsDir),
+            testMessages: mod.testMessages,
+            testAlerts: mod.testAlerts,
+        });
+    }
+    catch (e) {
+        console.error(e.message);
+        process.exit(1);
+    }
+});
+program
+    .command("extract-test-data")
+    .description("No-op: test data lives in streamelements/src/assets as TS objects")
+    .action(async () => {
+    try {
+        await runExtractTestData();
+    }
+    catch (e) {
+        console.error(e.message);
+        process.exit(1);
+    }
+});
+program
+    .command("base64")
+    .description("Convert images, videos, SVG to base64 for browsers")
+    .argument("<path>", "File or directory path")
+    .option("-o, --output <path>", "Output file or directory")
+    .option("-f, --full", "Output with additional info")
+    .action(async (inputPath, options) => {
+    if (!fs.existsSync(inputPath)) {
+        console.error("Error: Path does not exist");
+        process.exit(1);
+    }
+    try {
+        await processPath(inputPath, options.output ?? null, options.full ?? false);
+    }
+    catch (e) {
+        console.error("Error:", e.message);
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/widget.js

@@ -0,0 +1,135 @@
+/**
+ * Сборка виджета: html.txt, js.txt, css.txt, fields.txt, data.txt и архив .zip.
+ * Все пути относительно текущей папки (откуда вызывается скрипт).
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { runGenerateFields, runGenerateFieldsFromModule, } from "./generate-fields.js";
+/** Текущая папка (каталог проекта виджета). */
+function getProjectDir() {
+    return path.resolve(process.cwd());
+}
+function run(cmd, args, cwd, env) {
+    const r = spawnSync(cmd, args, {
+        cwd,
+        stdio: "inherit",
+        shell: true,
+        env: { ...process.env, ...env },
+    });
+    return r.status === 0;
+}
+export async function buildWidget(options) {
+    const projectDir = getProjectDir();
+    const distDir = path.join(projectDir, "dist");
+    const buildDir = path.resolve(projectDir, process.env.BUILD_DIR ?? "build");
+    const archiveName = process.env.ARCHIVE_NAME ?? "widget";
+    console.log("Generating fields...");
+    const basePath = path.join(projectDir, "fields.base.json");
+    const fieldsTsPath = path.join(projectDir, "fields.ts");
+    if (fs.existsSync(basePath)) {
+        const mod = (await import("@allior/wmake-streamelements-events"));
+        runGenerateFields({
+            fieldsDir: projectDir,
+            testMessages: mod.testMessages,
+            testAlerts: mod.testAlerts,
+        });
+    }
+    else if (fs.existsSync(fieldsTsPath)) {
+        runGenerateFieldsFromModule(fieldsTsPath);
+    }
+    else {
+        console.log("No fields.base.json or fields.ts found, skipping fields generation");
+    }
+    console.log("Building...");
+    const buildEnv = options.full ? { BUILD_FULL: "1" } : {};
+    if (!run("pnpm", ["run", "build"], projectDir, buildEnv)) {
+        throw new Error("Build failed.");
+    }
+    if (!fs.existsSync(distDir)) {
+        throw new Error("dist not found. Run build first.");
+    }
+    fs.mkdirSync(buildDir, { recursive: true });
+    const html = fs.readFileSync(path.join(distDir, "index.html"), "utf-8");
+    fs.writeFileSync(path.join(buildDir, "html.txt"), html);
+    const assetsDir = path.join(distDir, "assets");
+    const findFiles = (dir, ext) => {
+        const found = [];
+        const walk = (d) => {
+            if (!fs.existsSync(d))
+                return;
+            for (const e of fs.readdirSync(d)) {
+                const full = path.join(d, e);
+                const stat = fs.statSync(full);
+                if (stat.isDirectory())
+                    walk(full);
+                else if (e.endsWith(ext))
+                    found.push(full);
+            }
+        };
+        walk(dir);
+        return found;
+    };
+    const jsFiles = findFiles(assetsDir, ".js");
+    const cssFiles = findFiles(assetsDir, ".css");
+    if (jsFiles.length === 0 || cssFiles.length === 0) {
+        throw new Error("Expected .js and .css in dist/assets");
+    }
+    fs.writeFileSync(path.join(buildDir, "js.txt"), fs.readFileSync(jsFiles[0], "utf-8"));
+    fs.writeFileSync(path.join(buildDir, "css.txt"), fs.readFileSync(cssFiles[0], "utf-8"));
+    const fieldsJsonPath = path.join(projectDir, "fields.json");
+    if (fs.existsSync(fieldsJsonPath)) {
+        fs.copyFileSync(fieldsJsonPath, path.join(buildDir, "fields.txt"));
+    }
+    const pkgPath = path.join(projectDir, "package.json");
+    const wmakeVersion = fs.existsSync(pkgPath) &&
+        (() => {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+                return typeof pkg.version === "string" ? pkg.version : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+    const dataPath = path.join(projectDir, "data.json");
+    const data = fs.existsSync(dataPath)
+        ? JSON.parse(fs.readFileSync(dataPath, "utf-8"))
+        : {};
+    if (wmakeVersion) {
+        data.wmakeVersion = wmakeVersion;
+    }
+    fs.writeFileSync(path.join(buildDir, "data.txt"), JSON.stringify(data, null, 2));
+    console.log("Widget files:", path.join(buildDir, "html.txt"), "js.txt, css.txt, fields.txt, data.txt");
+    const zipPath = path.join(distDir, `${archiveName}.zip`);
+    const zip = spawnSync("zip", ["-r", zipPath, "."], {
+        cwd: buildDir,
+        stdio: "pipe",
+    });
+    if (zip.status === 0) {
+        console.log("Archive:", zipPath);
+        return;
+    }
+    try {
+        const AdmZip = (await import("adm-zip")).default;
+        const archive = new AdmZip();
+        for (const f of [
+            "html.txt",
+            "js.txt",
+            "css.txt",
+            "fields.txt",
+            "data.txt",
+        ]) {
+            const fp = path.join(buildDir, f);
+            if (fs.existsSync(fp))
+                archive.addLocalFile(fp, "", f);
+        }
+        archive.writeZip(zipPath);
+        console.log("Archive (adm-zip):", zipPath);
+    }
+    catch (e) {
+        console.error("zip failed and adm-zip fallback error:", e);
+        console.error("Install 'zip' (e.g. apk add zip) or ensure adm-zip is installed.");
+        throw e;
+    }
+}

package/eslint.config.mjs

@@ -0,0 +1,39 @@
+// @ts-check
+
+import eslint from '@eslint/js';
+import { defineConfig } from 'eslint/config';
+import react from "eslint-plugin-react";
+import tseslint from 'typescript-eslint';
+import globals from "globals";
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export default defineConfig(
+    eslint.configs.recommended,
+    tseslint.configs.strict,
+    tseslint.configs.stylistic,
+    {
+        files: ['**/*.{js,jsx,mjs,cjs,ts,tsx}'],
+        plugins: {
+            react,
+        },
+        languageOptions: {
+            parserOptions: {
+                tsconfigRootDir: __dirname,
+                ecmaFeatures: {
+                    jsx: true,
+                },
+            },
+            globals: {
+                ...globals.browser,
+            },
+        },
+        rules: {
+            'react/jsx-uses-react': 'error',
+            'react/jsx-uses-vars': 'error',
+        }
+    }
+);

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@allior/wmake-cli",
+  "version": "0.0.1",
+  "description": "Streamiby/wmake CLI: build widgets, base64 encode assets, generate fields",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "wmake-cli": "dist/index.js",
+    "@allior/wmake-cli": "dist/index.js"
+  },
+  "dependencies": {
+    "commander": "^11.1.0",
+    "mime-types": "^2.1.35",
+    "adm-zip": "^0.5.16",
+    "@allior/wmake-streamelements-events": "^0.0.3"
+  },
+  "devDependencies": {
+    "@types/mime-types": "^2.1.4",
+    "ts-node": "^10.9.0",
+    "tsx": "^4.20.6"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
+  }
+}

package/src/base64.ts

@@ -0,0 +1,97 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as mime from "mime-types";
+
+export interface FileInfo {
+  filename: string;
+  base64: string;
+  mimeType: string;
+  size: number;
+}
+
+const SUPPORTED_IMAGE = [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".svg"];
+const SUPPORTED_VIDEO = [".mp4", ".webm", ".ogg", ".mov", ".avi"];
+const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB
+
+export function isSupportedFile(filePath: string): boolean {
+  const ext = path.extname(filePath).toLowerCase();
+  return [...SUPPORTED_IMAGE, ...SUPPORTED_VIDEO].includes(ext);
+}
+
+export function fileToBase64(filePath: string): Promise<FileInfo> {
+  return new Promise((resolve, reject) => {
+    fs.stat(filePath, (err, stats) => {
+      if (err) {
+        reject(new Error(`Cannot access file: ${err.message}`));
+        return;
+      }
+      if (!stats.isFile()) {
+        reject(new Error("Path is not a file"));
+        return;
+      }
+      if (stats.size > MAX_FILE_SIZE) {
+        reject(new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE} bytes)`));
+        return;
+      }
+      if (!isSupportedFile(filePath)) {
+        reject(new Error("Unsupported file type"));
+        return;
+      }
+      fs.readFile(filePath, (err, data) => {
+        if (err) {
+          reject(new Error(`Error reading file: ${err.message}`));
+          return;
+        }
+        const mimeType = mime.lookup(filePath) || "application/octet-stream";
+        resolve({
+          filename: path.basename(filePath),
+          base64: data.toString("base64"),
+          mimeType: String(mimeType),
+          size: stats.size,
+        });
+      });
+    });
+  });
+}
+
+export function getOutputPath(output: string, originalFilename: string): string {
+  if (fs.existsSync(output) && fs.statSync(output).isDirectory()) {
+    const name = path.basename(originalFilename, path.extname(originalFilename));
+    return path.join(output, `${name}_base64.txt`);
+  }
+  return output;
+}
+
+export async function processPath(
+  inputPath: string,
+  output: string | null,
+  full: boolean
+): Promise<void> {
+  const stats = fs.statSync(inputPath);
+  if (stats.isFile()) {
+    const fileInfo = await fileToBase64(inputPath);
+    const dataUrl = `data:${fileInfo.mimeType};base64,${fileInfo.base64}`;
+    const content = full
+      ? `\nFile: ${fileInfo.filename}\nMIME Type: ${fileInfo.mimeType}\nSize: ${fileInfo.size} bytes\nBase64 Data URL:\n${dataUrl}\n${"-".repeat(50)}`
+      : dataUrl;
+    if (output) {
+      const outPath = getOutputPath(output, fileInfo.filename);
+      fs.writeFileSync(outPath, content);
+      console.log(`Output written to: ${outPath}`);
+    } else {
+      console.log(content);
+    }
+  } else if (stats.isDirectory()) {
+    const files = fs.readdirSync(inputPath);
+    let count = 0;
+    for (const file of files) {
+      const fullPath = path.join(inputPath, file);
+      if (fs.statSync(fullPath).isFile() && isSupportedFile(fullPath)) {
+        await processPath(fullPath, output, full);
+        count++;
+      }
+    }
+    if (count === 0) console.log("No supported files found in directory");
+    else console.log(`\nProcessed ${count} files`);
+  }
+}

package/src/extract-test-data.ts

@@ -0,0 +1,11 @@
+/**
+ * Раньше создавал test-messages.json и test-alerts.json в streamelements/src/assets.
+ * Теперь тестовые данные — объекты в скриптах: streamelements/src/assets/test-messages.ts и test-alerts.ts.
+ * Команда оставлена для совместимости (no-op).
+ */
+
+export async function runExtractTestData(): Promise<void> {
+  console.log(
+    "Test data is defined in streamelements/src/assets (test-messages.ts, test-alerts.ts). No extraction needed.",
+  );
+}

package/src/generate-fields-from-module-runner.ts

@@ -0,0 +1,36 @@
+/**
+ * Запускается через tsx для загрузки TS-модуля с полями.
+ * Использование: tsx generate-fields-from-module-runner.ts <path-to-fields.ts> <path-to-fields.json>
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+const [, , modulePath, outPath] = process.argv;
+if (!modulePath || !outPath) {
+  console.error(
+    "Usage: tsx generate-fields-from-module-runner.ts <fields.ts> <fields.json>",
+  );
+  process.exit(1);
+}
+
+const absPath = path.resolve(modulePath);
+import(pathToFileURL(absPath).href)
+  .then((mod) => {
+    const fields = mod.default;
+    if (!Array.isArray(fields)) {
+      throw new Error(`Module must export default AdvancedField[]`);
+    }
+    const result = Object.assign(
+      {},
+      ...fields.map(
+        (f: { fieldObject: Record<string, unknown> }) => f.fieldObject,
+      ),
+    );
+    fs.writeFileSync(outPath, JSON.stringify(result, null, 2), "utf-8");
+    console.log("Wrote", outPath);
+  })
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });

package/src/generate-fields.ts

@@ -0,0 +1,117 @@
+/**
+ * Генерирует fields.json из fields.base.json и ключей из объектов testMessages / testAlerts.
+ * Путь к каталогу с fields.base.json задаётся WMAKE_FIELDS_DIR.
+ * Данные сообщений и алертов передаются объектами (из скриптов streamelements).
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const TEST_GROUP = "Tests / Тесты";
+
+type FieldDef = Record<string, unknown>;
+type FieldsMap = Record<string, FieldDef>;
+
+function pascalCase(s: string): string {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+/** camelCase → sentence case (e.g. veryShort → "Very short", selfSub → "Self sub") */
+function keyToTitle(key: string): string {
+  const words = key
+    .replace(/([A-Z])/g, " $1")
+    .toLowerCase()
+    .trim();
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+
+function messageLabel(key: string): string {
+  return `${keyToTitle(key)} message`;
+}
+
+function alertLabel(key: string): string {
+  return `${keyToTitle(key)} alert`;
+}
+
+export type MessagesRecord = Record<string, unknown>;
+export type AlertsRecord = Record<string, unknown>;
+
+export function runGenerateFields(options: {
+  fieldsDir: string;
+  testMessages: MessagesRecord;
+  testAlerts: AlertsRecord;
+}): void {
+  const { fieldsDir, testMessages: messages, testAlerts: alerts } = options;
+
+  const basePath = path.join(fieldsDir, "fields.base.json");
+  const outPath = path.join(fieldsDir, "fields.json");
+
+  const base = JSON.parse(fs.readFileSync(basePath, "utf-8")) as FieldsMap;
+
+  const messageKeys = Object.keys(messages);
+  const alertKeys = Object.keys(alerts);
+
+  const testMessageFields: FieldsMap = {};
+  for (const key of messageKeys) {
+    const fieldId = "testMessage" + pascalCase(key);
+    testMessageFields[fieldId] = {
+      type: "button",
+      label: messageLabel(key),
+      group: TEST_GROUP,
+    };
+  }
+
+  const testAlertFields: FieldsMap = {};
+  for (const key of alertKeys) {
+    const fieldId = "testAlert" + pascalCase(key);
+    testAlertFields[fieldId] = {
+      type: "button",
+      label: alertLabel(key),
+      group: TEST_GROUP,
+    };
+  }
+
+  const insertAfterKey = "blueFlowerAnimationDuration";
+  const result: FieldsMap = {};
+  let inserted = false;
+  for (const k of Object.keys(base)) {
+    if (k.startsWith("_")) continue;
+    result[k] = base[k] as FieldDef;
+    if (k === insertAfterKey) {
+      Object.assign(result, testMessageFields, testAlertFields);
+      inserted = true;
+    }
+  }
+  if (!inserted) {
+    Object.assign(result, testMessageFields, testAlertFields);
+  }
+
+  fs.writeFileSync(outPath, JSON.stringify(result, null, 2), "utf-8");
+  console.log("Wrote", outPath);
+  console.log("Test message buttons:", messageKeys.length);
+  console.log("Test alert buttons:", alertKeys.length);
+}
+
+/**
+ * Генерирует fields.json из TS/JS модуля, экспортирующего default AdvancedField[].
+ * Использует tsx для загрузки .ts файлов.
+ */
+export function runGenerateFieldsFromModule(fieldsModulePath: string): void {
+  const absPath = path.resolve(fieldsModulePath);
+  const outPath = path.join(path.dirname(absPath), "fields.json");
+  const runnerPath = path.join(
+    __dirname,
+    "..",
+    "src",
+    "generate-fields-from-module-runner.ts",
+  );
+  const r = spawnSync("npx", ["tsx", runnerPath, absPath, outPath], {
+    stdio: "inherit",
+    shell: true,
+    cwd: path.dirname(absPath),
+  });
+  if (r.status !== 0) {
+    throw new Error(`Failed to generate fields from ${fieldsModulePath}`);
+  }
+}

package/src/index.ts

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import { Command } from "commander";
+import * as fs from "fs";
+import { processPath } from "./base64.js";
+import { buildWidget } from "./widget.js";
+import { runGenerateFields } from "./generate-fields.js";
+import { runExtractTestData } from "./extract-test-data.js";
+
+const program = new Command();
+
+program.name("wmake").description("CLI for streamiby / wmake").version("1.0.0");
+
+program
+  .command("widget")
+  .description(
+    "Build chat-demo into widget files and zip in examples/chat-demo/dist",
+  )
+  .option("--full", "Full bundle (no CDN external), like the old build")
+  .action(async (opts: { full?: boolean }) => {
+    try {
+      await buildWidget({ full: opts.full });
+    } catch (e) {
+      console.error((e as Error).message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("generate-fields")
+  .description(
+    "Generate fields.json from fields.base.json and test data objects (WMAKE_FIELDS_DIR)",
+  )
+  .action(async () => {
+    try {
+      const fieldsDir = process.env.WMAKE_FIELDS_DIR;
+      if (!fieldsDir?.trim()) {
+        throw new Error("WMAKE_FIELDS_DIR must be set.");
+      }
+      const mod =
+        (await import("@allior/wmake-streamelements-events")) as unknown as {
+          testMessages: Record<string, unknown>;
+          testAlerts: Record<string, unknown>;
+        };
+      runGenerateFields({
+        fieldsDir: path.resolve(fieldsDir),
+        testMessages: mod.testMessages,
+        testAlerts: mod.testAlerts,
+      });
+    } catch (e) {
+      console.error((e as Error).message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("extract-test-data")
+  .description(
+    "No-op: test data lives in streamelements/src/assets as TS objects",
+  )
+  .action(async () => {
+    try {
+      await runExtractTestData();
+    } catch (e) {
+      console.error((e as Error).message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("base64")
+  .description("Convert images, videos, SVG to base64 for browsers")
+  .argument("<path>", "File or directory path")
+  .option("-o, --output <path>", "Output file or directory")
+  .option("-f, --full", "Output with additional info")
+  .action(
+    async (inputPath: string, options: { output?: string; full?: boolean }) => {
+      if (!fs.existsSync(inputPath)) {
+        console.error("Error: Path does not exist");
+        process.exit(1);
+      }
+      try {
+        await processPath(
+          inputPath,
+          options.output ?? null,
+          options.full ?? false,
+        );
+      } catch (e) {
+        console.error("Error:", (e as Error).message);
+        process.exit(1);
+      }
+    },
+  );
+
+program.parse();

package/src/widget.ts

@@ -0,0 +1,171 @@
+/**
+ * Сборка виджета: html.txt, js.txt, css.txt, fields.txt, data.txt и архив .zip.
+ * Все пути относительно текущей папки (откуда вызывается скрипт).
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import {
+  runGenerateFields,
+  runGenerateFieldsFromModule,
+} from "./generate-fields.js";
+
+/** Текущая папка (каталог проекта виджета). */
+function getProjectDir(): string {
+  return path.resolve(process.cwd());
+}
+
+function run(
+  cmd: string,
+  args: string[],
+  cwd: string,
+  env?: NodeJS.ProcessEnv,
+): boolean {
+  const r = spawnSync(cmd, args, {
+    cwd,
+    stdio: "inherit",
+    shell: true,
+    env: { ...process.env, ...env },
+  });
+  return r.status === 0;
+}
+
+export async function buildWidget(options: { full?: boolean }): Promise<void> {
+  const projectDir = getProjectDir();
+  const distDir = path.join(projectDir, "dist");
+  const buildDir = path.resolve(projectDir, process.env.BUILD_DIR ?? "build");
+  const archiveName = process.env.ARCHIVE_NAME ?? "widget";
+
+  console.log("Generating fields...");
+  const basePath = path.join(projectDir, "fields.base.json");
+  const fieldsTsPath = path.join(projectDir, "fields.ts");
+  if (fs.existsSync(basePath)) {
+    const mod =
+      (await import("@allior/wmake-streamelements-events")) as unknown as {
+        testMessages: Record<string, unknown>;
+        testAlerts: Record<string, unknown>;
+      };
+    runGenerateFields({
+      fieldsDir: projectDir,
+      testMessages: mod.testMessages,
+      testAlerts: mod.testAlerts,
+    });
+  } else if (fs.existsSync(fieldsTsPath)) {
+    runGenerateFieldsFromModule(fieldsTsPath);
+  } else {
+    console.log(
+      "No fields.base.json or fields.ts found, skipping fields generation",
+    );
+  }
+  console.log("Building...");
+  const buildEnv = options.full ? { BUILD_FULL: "1" } : {};
+  if (!run("pnpm", ["run", "build"], projectDir, buildEnv)) {
+    throw new Error("Build failed.");
+  }
+
+  if (!fs.existsSync(distDir)) {
+    throw new Error("dist not found. Run build first.");
+  }
+
+  fs.mkdirSync(buildDir, { recursive: true });
+
+  const html = fs.readFileSync(path.join(distDir, "index.html"), "utf-8");
+  fs.writeFileSync(path.join(buildDir, "html.txt"), html);
+
+  const assetsDir = path.join(distDir, "assets");
+  const findFiles = (dir: string, ext: string): string[] => {
+    const found: string[] = [];
+    const walk = (d: string) => {
+      if (!fs.existsSync(d)) return;
+      for (const e of fs.readdirSync(d)) {
+        const full = path.join(d, e);
+        const stat = fs.statSync(full);
+        if (stat.isDirectory()) walk(full);
+        else if (e.endsWith(ext)) found.push(full);
+      }
+    };
+    walk(dir);
+    return found;
+  };
+  const jsFiles = findFiles(assetsDir, ".js");
+  const cssFiles = findFiles(assetsDir, ".css");
+
+  if (jsFiles.length === 0 || cssFiles.length === 0) {
+    throw new Error("Expected .js and .css in dist/assets");
+  }
+
+  fs.writeFileSync(
+    path.join(buildDir, "js.txt"),
+    fs.readFileSync(jsFiles[0], "utf-8"),
+  );
+  fs.writeFileSync(
+    path.join(buildDir, "css.txt"),
+    fs.readFileSync(cssFiles[0], "utf-8"),
+  );
+
+  const fieldsJsonPath = path.join(projectDir, "fields.json");
+  if (fs.existsSync(fieldsJsonPath)) {
+    fs.copyFileSync(fieldsJsonPath, path.join(buildDir, "fields.txt"));
+  }
+
+  const pkgPath = path.join(projectDir, "package.json");
+  const wmakeVersion =
+    fs.existsSync(pkgPath) &&
+    (() => {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        return typeof pkg.version === "string" ? pkg.version : undefined;
+      } catch {
+        return undefined;
+      }
+    })();
+  const dataPath = path.join(projectDir, "data.json");
+  const data = fs.existsSync(dataPath)
+    ? JSON.parse(fs.readFileSync(dataPath, "utf-8"))
+    : {};
+  if (wmakeVersion) {
+    data.wmakeVersion = wmakeVersion;
+  }
+  fs.writeFileSync(
+    path.join(buildDir, "data.txt"),
+    JSON.stringify(data, null, 2),
+  );
+
+  console.log(
+    "Widget files:",
+    path.join(buildDir, "html.txt"),
+    "js.txt, css.txt, fields.txt, data.txt",
+  );
+
+  const zipPath = path.join(distDir, `${archiveName}.zip`);
+  const zip = spawnSync("zip", ["-r", zipPath, "."], {
+    cwd: buildDir,
+    stdio: "pipe",
+  });
+  if (zip.status === 0) {
+    console.log("Archive:", zipPath);
+    return;
+  }
+  try {
+    const AdmZip = (await import("adm-zip")).default;
+    const archive = new AdmZip();
+    for (const f of [
+      "html.txt",
+      "js.txt",
+      "css.txt",
+      "fields.txt",
+      "data.txt",
+    ]) {
+      const fp = path.join(buildDir, f);
+      if (fs.existsSync(fp)) archive.addLocalFile(fp, "", f);
+    }
+    archive.writeZip(zipPath);
+    console.log("Archive (adm-zip):", zipPath);
+  } catch (e) {
+    console.error("zip failed and adm-zip fallback error:", e);
+    console.error(
+      "Install 'zip' (e.g. apk add zip) or ensure adm-zip is installed.",
+    );
+    throw e;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    }
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}