generate-ui-cli 2.0.0 → 2.1.0

package/README.md

@@ -65,8 +65,9 @@ What happens after this command:
 - GenerateUI reads your OpenAPI and detects endpoints.
 - It identifies CRUD-like operations (list, get by id, create, update, delete).
 - It maps request/response schemas.
-- A `screens.json` file is created in the output folder.
-- Two JSON folders are created: `generated/` (auto-created files) and `override/` (your manual edits that should be preserved on regeneration).
+- If your project has a `src/` folder, GenerateUI creates `src/generate-ui/`.
+- Otherwise it creates `generate-ui/` next to your OpenAPI file.
+- Inside it you get `generated/`, `overlays/`, `screens.json`, `routes.json`, and `routes.gen.ts`.
 
 What you should review now:
 
@@ -80,9 +81,7 @@ Tip: this is the best moment to adjust naming and structure before generating co
 ## 2) Generate Angular code from `screens.json`
 
 ```bash
-generate-ui angular \
-  --schemas /Users/nicoleprevid/Downloads/generateui-playground/frontend/src/app/assets/generate-ui \
-  --features /Users/nicoleprevid/Downloads/generateui-playground/frontend/src/app/features
+generate-ui angular
 ```
 
 What happens after this command:
@@ -104,6 +103,24 @@ What you should review now:
 Note:
 If your project uses custom routing, standalone components, or advanced layouts, you may need to adjust how routes are plugged in.
 
+Defaults:
+- `--schemas` defaults to the last generated path (stored in `~/.generateui/config.json`), otherwise `./src/generate-ui` (or `./frontend/src/generate-ui` / `./generate-ui`)
+- `--features` defaults to `./src/app/features` when it exists, otherwise `./frontend/src/app/features` or `./features`
+
+Optional paths:
+
+```bash
+generate-ui angular \
+  --schemas /path/to/generate-ui \
+  --features /path/to/angular/features
+```
+
+Custom output folder for `generate`:
+
+```bash
+generate-ui generate --openapi youropenapi.yaml --output /path/to/generate-ui
+```
+
 ## Login (Dev plan)
 
 ```bash
@@ -115,21 +132,26 @@ What happens after this command:
 - You authenticate your device to unlock Dev features.
 - Dev features include safe regeneration, UI overrides, and unlimited generations.
 
+## Telemetry
+
+GenerateUI collects anonymous usage data such as CLI version, OS, and executed commands to improve the product.
+No source code or OpenAPI content is ever sent.
+Telemetry can be disabled by setting `telemetry=false` in `~/.generateui/config.json` or by running with `--no-telemetry`.
+
 ## Plugging Routes into Your App
 
 GenerateUI usually creates route files such as:
 
-- `generated.routes.ts`
-- or per feature: `users.routes.ts`, `orders.routes.ts`
+- `src/generate-ui/routes.gen.ts` or `frontend/src/generate-ui/routes.gen.ts` or `generate-ui/routes.gen.ts`
 
 Example (Angular Router):
 
 ```ts
-import { GENERATED_ROUTES } from './app/generated/generated.routes';
+import { generatedRoutes } from '../generate-ui/routes.gen';
 
 export const routes = [
   // ...your existing routes
-  ...GENERATED_ROUTES
+  ...generatedRoutes
 ];
 ```
 
@@ -139,23 +161,63 @@ Things to pay attention to:
 - authentication guards
 - layout components (`<router-outlet>` placement)
 
+## Angular >= 15 (standalone) setup
+
+Step-by-step:
+
+1) Generate files:
+
+```bash
+generate-ui generate --openapi /path/to/openapi.yaml
+generate-ui angular
+```
+
+2) Import generated routes in `src/app/app.routes.ts`:
+
+```ts
+import { generatedRoutes } from '../generate-ui/routes.gen'
+
+export const routes: Routes = [
+  // your existing routes
+  ...generatedRoutes
+]
+```
+
+3) Ensure `provideRouter` is used in `src/main.ts`:
+
+```ts
+import { provideRouter } from '@angular/router'
+import { routes } from './app/app.routes'
+
+bootstrapApplication(AppComponent, {
+  providers: [provideRouter(routes)]
+})
+```
+
+4) Check `@angular/router` is installed:
+
+```bash
+npm ls @angular/router
+```
+
 ## Example Generated Structure
 
 ```txt
-src/app/generated/
+src/generate-ui/ or frontend/src/generate-ui/ or generate-ui/
+  generated/
+  overlays/
+  routes.json
+  routes.gen.ts
+  screens.json
+frontend/src/app/features/
   users/
-    users-list.component.ts
-    users-form.component.ts
-    users.routes.ts
-    users.service.ts
-    users.types.ts
+    users.component.ts
+    users.service.gen.ts
+    users.gen.ts
   orders/
-    orders-list.component.ts
-    orders-form.component.ts
-    orders.routes.ts
-    orders.service.ts
-    orders.types.ts
-  generated.routes.ts
+    orders.component.ts
+    orders.service.gen.ts
+    orders.gen.ts
 ```
 
 ## After Generation: How to Customize Safely
@@ -170,9 +232,9 @@ Rule of thumb: the generated code is yours — generate once, then evolve freely
 
 ## Overrides and Regeneration Behavior
 
-You can edit files inside `override/` to customize labels, placeholders, hints, and other details. When your API changes and you regenerate, GenerateUI updates what is safe to change from the OpenAPI, but preserves what you defined in `override/` to avoid breaking your flow.
+You can edit files inside `overlays/` to customize labels, placeholders, hints, and other details. When your API changes and you regenerate, GenerateUI updates what is safe to change from the OpenAPI, but preserves what you defined in `overlays/` to avoid breaking your flow.
 
-Even after the Angular TypeScript files are generated, changes you make in `override/` will be mirrored the next time you regenerate.
+Even after the Angular TypeScript files are generated, changes you make in `overlays/` will be mirrored the next time you regenerate.
 
 ## Common Issues and Fixes
 

package/dist/commands/angular.js

@@ -9,12 +9,15 @@ const path_1 = __importDefault(require("path"));
 const feature_generator_1 = require("../generators/angular/feature.generator");
 const routes_generator_1 = require("../generators/angular/routes.generator");
 const telemetry_1 = require("../telemetry");
+const user_config_1 = require("../runtime/user-config");
 async function angular(options) {
+    void (0, telemetry_1.trackCommand)('angular', options.telemetryEnabled);
+    const featuresRoot = resolveFeaturesRoot(options.featuresPath);
+    const schemasRoot = resolveSchemasRoot(options.schemasPath, featuresRoot);
     /**
      * Onde estão os schemas
-     * Ex: frontend/src/app/assets/generate-ui
+     * Ex: generate-ui
      */
-    const schemasRoot = path_1.default.resolve(process.cwd(), options.schemasPath);
     const overlaysDir = path_1.default.join(schemasRoot, 'overlays');
     if (!fs_1.default.existsSync(overlaysDir)) {
         throw new Error(`Overlays directory not found: ${overlaysDir}`);
@@ -25,15 +28,60 @@ async function angular(options) {
     /**
      * Onde gerar as features Angular
      */
-    const featuresRoot = path_1.default.resolve(process.cwd(), options.featuresPath);
     fs_1.default.mkdirSync(featuresRoot, { recursive: true });
     const routes = [];
     for (const file of screens) {
         const schema = JSON.parse(fs_1.default.readFileSync(path_1.default.join(overlaysDir, file), 'utf-8'));
-        const route = (0, feature_generator_1.generateFeature)(schema, featuresRoot);
+        const route = (0, feature_generator_1.generateFeature)(schema, featuresRoot, schemasRoot);
         routes.push(route);
     }
-    (0, routes_generator_1.generateRoutes)(routes, featuresRoot);
-    await (0, telemetry_1.sendTelemetry)('generate', options.telemetryEnabled);
+    (0, routes_generator_1.generateRoutes)(routes, featuresRoot, schemasRoot);
     console.log(`✔ Angular features generated at ${featuresRoot}`);
 }
+function resolveSchemasRoot(value, featuresRoot) {
+    if (value) {
+        return path_1.default.resolve(process.cwd(), value);
+    }
+    const config = (0, user_config_1.loadUserConfig)();
+    if (config?.lastSchemasPath) {
+        const resolved = path_1.default.resolve(config.lastSchemasPath);
+        if (fs_1.default.existsSync(path_1.default.join(resolved, 'overlays'))) {
+            return resolved;
+        }
+    }
+    const inferred = inferSchemasRootFromFeatures(featuresRoot);
+    if (inferred)
+        return inferred;
+    return resolveDefaultSchemasRoot();
+}
+function resolveFeaturesRoot(value) {
+    if (value) {
+        return path_1.default.resolve(process.cwd(), value);
+    }
+    const defaultApp = path_1.default.resolve(process.cwd(), 'src', 'app', 'features');
+    if (fs_1.default.existsSync(defaultApp)) {
+        return defaultApp;
+    }
+    const defaultFrontend = path_1.default.resolve(process.cwd(), 'frontend', 'src', 'app', 'features');
+    if (fs_1.default.existsSync(defaultFrontend)) {
+        return defaultFrontend;
+    }
+    return path_1.default.resolve(process.cwd(), 'features');
+}
+function inferSchemasRootFromFeatures(featuresRoot) {
+    const candidate = path_1.default.resolve(featuresRoot, '../../..', 'generate-ui');
+    if (fs_1.default.existsSync(path_1.default.join(candidate, 'overlays'))) {
+        return candidate;
+    }
+    return null;
+}
+function resolveDefaultSchemasRoot() {
+    const cwd = process.cwd();
+    if (fs_1.default.existsSync(path_1.default.join(cwd, 'src'))) {
+        return path_1.default.join(cwd, 'src', 'generate-ui');
+    }
+    if (fs_1.default.existsSync(path_1.default.join(cwd, 'frontend', 'src'))) {
+        return path_1.default.join(cwd, 'frontend', 'src', 'generate-ui');
+    }
+    return path_1.default.join(cwd, 'generate-ui');
+}

package/dist/commands/generate.js

@@ -12,7 +12,9 @@ const screen_merge_1 = require("../generators/screen.merge");
 const permissions_1 = require("../license/permissions");
 const device_1 = require("../license/device");
 const telemetry_1 = require("../telemetry");
+const user_config_1 = require("../runtime/user-config");
 async function generate(options) {
+    void (0, telemetry_1.trackCommand)('generate', options.telemetryEnabled);
     /**
      * Caminho absoluto do OpenAPI (YAML)
      * Ex: /Users/.../generateui-playground/realWorldOpenApi.yaml
@@ -25,9 +27,13 @@ async function generate(options) {
     /**
      * Onde o Angular consome os arquivos
      */
-    const generateUiRoot = path_1.default.join(projectRoot, 'frontend', 'src', 'app', 'assets', 'generate-ui');
+    const generateUiRoot = resolveGenerateUiRoot(projectRoot, options.output);
     const generatedDir = path_1.default.join(generateUiRoot, 'generated');
     const overlaysDir = path_1.default.join(generateUiRoot, 'overlays');
+    (0, user_config_1.updateUserConfig)(config => ({
+        ...config,
+        lastSchemasPath: generateUiRoot
+    }));
     fs_1.default.mkdirSync(generatedDir, { recursive: true });
     fs_1.default.mkdirSync(overlaysDir, { recursive: true });
     /**
@@ -37,7 +43,6 @@ async function generate(options) {
     const usedOperationIds = new Set();
     const permissions = await (0, permissions_1.getPermissions)();
     const device = (0, device_1.loadDeviceIdentity)();
-    await (0, telemetry_1.sendTelemetry)('generate', options.telemetryEnabled);
     if (permissions.features.maxGenerations > -1 &&
         device.freeGenerationsUsed >= permissions.features.maxGenerations) {
         throw new Error('🔒 Você já utilizou sua geração gratuita.\n' +
@@ -142,6 +147,20 @@ async function generate(options) {
     }
     console.log('✔ Routes generated');
 }
+function resolveGenerateUiRoot(projectRoot, output) {
+    if (output) {
+        return path_1.default.resolve(process.cwd(), output);
+    }
+    const srcRoot = path_1.default.join(projectRoot, 'src');
+    if (fs_1.default.existsSync(srcRoot)) {
+        return path_1.default.join(srcRoot, 'generate-ui');
+    }
+    const frontendSrcRoot = path_1.default.join(projectRoot, 'frontend', 'src');
+    if (fs_1.default.existsSync(frontendSrcRoot)) {
+        return path_1.default.join(frontendSrcRoot, 'generate-ui');
+    }
+    return path_1.default.join(projectRoot, 'generate-ui');
+}
 function mergeParameters(pathParams, opParams) {
     const all = [...(pathParams ?? []), ...(opParams ?? [])];
     const seen = new Set();

package/dist/commands/login.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.login = login;
 const http_1 = __importDefault(require("http"));
 const url_1 = require("url");
+const promises_1 = require("readline/promises");
 const config_1 = require("../runtime/config");
 const open_browser_1 = require("../runtime/open-browser");
 const token_1 = require("../license/token");
@@ -13,6 +14,7 @@ const permissions_1 = require("../license/permissions");
 const telemetry_1 = require("../telemetry");
 const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
 async function login(options) {
+    void (0, telemetry_1.trackCommand)('login', options.telemetryEnabled);
     const token = await waitForLogin();
     (0, token_1.saveToken)(token);
     try {
@@ -21,9 +23,26 @@ async function login(options) {
     catch {
         // Cached permissions will be refreshed on next online command.
     }
-    await (0, telemetry_1.sendTelemetry)('login', options.telemetryEnabled);
+    const email = await promptEmail();
+    await (0, telemetry_1.trackLogin)(email, options.telemetryEnabled);
     console.log('✔ Login completo');
 }
+async function promptEmail() {
+    if (!process.stdin.isTTY)
+        return null;
+    const rl = (0, promises_1.createInterface)({
+        input: process.stdin,
+        output: process.stdout
+    });
+    try {
+        const value = await rl.question('Email (optional): ');
+        const trimmed = value.trim();
+        return trimmed.length ? trimmed : null;
+    }
+    finally {
+        rl.close();
+    }
+}
 async function waitForLogin() {
     return new Promise((resolve, reject) => {
         const server = http_1.default.createServer((req, res) => {

package/dist/generators/angular/feature.generator.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateFeature = generateFeature;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-function generateFeature(schema, root) {
+function generateFeature(schema, root, schemasRoot) {
     const rawName = schema.api.operationId;
     const name = toPascalCase(rawName);
     const folder = toFolderName(name);
@@ -47,6 +47,7 @@ function generateFeature(schema, root) {
         ? String(schema.entity).trim()
         : rawName;
     const subtitle = `${method.toUpperCase()} ${endpoint}`;
+    const schemaImportPath = buildSchemaImportPath(featureDir, schemasRoot, rawName);
     /**
      * 1️⃣ Component (sempre sobrescreve)
      */
@@ -60,7 +61,7 @@ import { UiFieldComponent } from '../../ui/ui-field/ui-field.component'
 import { UiButtonComponent } from '../../ui/ui-button/ui-button.component'
 import { ${name}Service } from './${fileBase}.service.gen'
 import { ${name}Gen } from './${fileBase}.gen'
-import screenSchema from '../../assets/generate-ui/overlays/${rawName}.screen.json'
+import screenSchema from '${schemaImportPath}'
 
 @Component({
   selector: 'app-${toKebab(name)}',
@@ -1209,3 +1210,15 @@ function toPascalCase(value) {
         .map(part => part[0].toUpperCase() + part.slice(1))
         .join('');
 }
+function buildSchemaImportPath(featureDir, schemasRoot, rawName) {
+    const schemaFile = path_1.default.join(schemasRoot, 'overlays', `${rawName}.screen.json`);
+    let relativePath = path_1.default.relative(featureDir, schemaFile);
+    relativePath = toPosixPath(relativePath);
+    if (!relativePath.startsWith('.')) {
+        relativePath = `./${relativePath}`;
+    }
+    return relativePath;
+}
+function toPosixPath(value) {
+    return value.split(path_1.default.sep).join(path_1.default.posix.sep);
+}

package/dist/generators/angular/routes.generator.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateRoutes = generateRoutes;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-function generateRoutes(routes, featuresRoot) {
-    const appRoot = path_1.default.resolve(featuresRoot, '..');
-    const out = path_1.default.join(appRoot, 'generated', 'routes.gen.ts');
+function generateRoutes(routes, featuresRoot, schemasRoot) {
+    const out = path_1.default.join(schemasRoot, 'routes.gen.ts');
+    const featuresImportBase = buildRelativeImportBase(schemasRoot, featuresRoot);
     fs_1.default.mkdirSync(path_1.default.dirname(out), { recursive: true });
     const content = `
 import { Routes } from '@angular/router'
@@ -16,10 +16,11 @@ import { Routes } from '@angular/router'
 export const generatedRoutes: Routes = [
 ${routes
         .flatMap(r => {
+        const baseImport = ensureRelativeImport(toPosixPath(path_1.default.join(featuresImportBase, r.folder, `${r.fileBase}.component`)));
         const base = `  {
     path: '${r.path}',
     loadComponent: () =>
-      import('../features/${r.folder}/${r.fileBase}.component')
+      import('${baseImport}')
         .then(m => m.${r.component})
   }`;
         const pascal = toPascalCase(r.path);
@@ -28,7 +29,7 @@ ${routes
         const alias = `  {
     path: '${pascal}',
     loadComponent: () =>
-      import('../features/${r.folder}/${r.fileBase}.component')
+      import('${baseImport}')
         .then(m => m.${r.component})
   }`;
         return [base, alias];
@@ -43,3 +44,19 @@ function toPascalCase(value) {
         return value;
     return value[0].toUpperCase() + value.slice(1);
 }
+function buildRelativeImportBase(fromDir, toDir) {
+    let relativePath = path_1.default.relative(fromDir, toDir);
+    relativePath = toPosixPath(relativePath);
+    if (!relativePath.startsWith('.')) {
+        relativePath = `./${relativePath}`;
+    }
+    return relativePath;
+}
+function toPosixPath(value) {
+    return value.split(path_1.default.sep).join(path_1.default.posix.sep);
+}
+function ensureRelativeImport(value) {
+    if (value.startsWith('.'))
+        return value;
+    return `./${value}`;
+}

package/dist/index.js

@@ -19,12 +19,14 @@ program
     .command('generate')
     .description('Generate screen schemas from OpenAPI')
     .requiredOption('-o, --openapi <path>', 'OpenAPI file')
+    .option('--output <path>', 'Output directory for generate-ui (default: ./src/generate-ui or ./generate-ui)')
     .option('-d, --debug', 'Explain merge decisions')
     .action(async (options) => {
     const { telemetry } = program.opts();
     try {
         await (0, generate_1.generate)({
             openapi: options.openapi,
+            output: options.output,
             debug: options.debug,
             telemetryEnabled: telemetry
         });
@@ -39,8 +41,8 @@ program
 program
     .command('angular')
     .description('Generate Angular code from screen schemas')
-    .requiredOption('-s, --schemas <path>', 'Directory containing generate-ui (with overlays/)')
-    .requiredOption('-f, --features <path>', 'Angular features output directory')
+    .option('-s, --schemas <path>', 'Directory containing generate-ui (with overlays/)')
+    .option('-f, --features <path>', 'Angular features output directory')
     .action(async (options) => {
     const { telemetry } = program.opts();
     try {

package/dist/runtime/user-config.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserConfigPath = getUserConfigPath;
+exports.loadUserConfig = loadUserConfig;
+exports.saveUserConfig = saveUserConfig;
+exports.updateUserConfig = updateUserConfig;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+function getUserConfigPath() {
+    return path_1.default.join(os_1.default.homedir(), '.generateui', 'config.json');
+}
+function loadUserConfig() {
+    const configPath = getUserConfigPath();
+    if (!fs_1.default.existsSync(configPath))
+        return null;
+    try {
+        const raw = fs_1.default.readFileSync(configPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function saveUserConfig(config) {
+    const configPath = getUserConfigPath();
+    fs_1.default.mkdirSync(path_1.default.dirname(configPath), { recursive: true });
+    fs_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+function updateUserConfig(updater) {
+    const current = loadUserConfig() ?? {};
+    const next = updater(current);
+    saveUserConfig(next);
+    return next;
+}

package/dist/telemetry.js

@@ -1,40 +1,117 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendTelemetry = sendTelemetry;
+exports.trackCommand = trackCommand;
+exports.trackLogin = trackLogin;
+const crypto_1 = require("crypto");
 const config_1 = require("./runtime/config");
+const user_config_1 = require("./runtime/user-config");
 const device_1 = require("./license/device");
+const TELEMETRY_URL = process.env.GENERATEUI_TELEMETRY_URL?.trim() ||
+    'https://api.generateui.dev/events';
+const TELEMETRY_TIMEOUT_MS = 1000;
 function getOsName() {
-    switch (process.platform) {
-        case 'darwin':
-            return 'macos';
-        case 'win32':
-            return 'windows';
-        default:
-            return 'linux';
-    }
+    return process.platform;
 }
-async function sendTelemetry(command, enabled) {
-    if (!enabled)
-        return;
-    const apiBase = (0, config_1.getApiBaseUrl)();
-    const device = (0, device_1.loadDeviceIdentity)();
-    const payload = {
-        deviceId: device.deviceId,
-        command,
-        cliVersion: (0, config_1.getCliVersion)(),
-        os: getOsName(),
-        timestamp: new Date().toISOString()
+function loadOrCreateConfig() {
+    let config = (0, user_config_1.loadUserConfig)();
+    let isNew = false;
+    let shouldWrite = false;
+    if (!config) {
+        isNew = true;
+        shouldWrite = true;
+        config = {
+            installationId: (0, crypto_1.randomUUID)(),
+            telemetry: true
+        };
+    }
+    else if (!config.installationId) {
+        isNew = true;
+        shouldWrite = true;
+        config.installationId = (0, crypto_1.randomUUID)();
+        if (config.telemetry === undefined) {
+            config.telemetry = true;
+        }
+    }
+    else if (config.telemetry === undefined) {
+        shouldWrite = true;
+        config.telemetry = true;
+    }
+    if (shouldWrite) {
+        (0, user_config_1.saveUserConfig)(config);
+    }
+    const installationId = config.installationId ?? (0, crypto_1.randomUUID)();
+    if (installationId !== config.installationId) {
+        shouldWrite = true;
+        config.installationId = installationId;
+    }
+    if (shouldWrite) {
+        (0, user_config_1.saveUserConfig)(config);
+    }
+    return {
+        config: {
+            installationId,
+            telemetry: config.telemetry
+        },
+        isNew
     };
+}
+function isTelemetryEnabled(cliEnabled, config) {
+    if (!cliEnabled)
+        return false;
+    return config.telemetry !== false;
+}
+async function sendEvent(payload) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), TELEMETRY_TIMEOUT_MS);
     try {
-        await fetch(`${apiBase}/telemetry`, {
+        await fetch(TELEMETRY_URL, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json'
             },
-            body: JSON.stringify(payload)
+            body: JSON.stringify(payload),
+            signal: controller.signal
         });
     }
     catch {
         // Telemetry must never block execution.
     }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function trackCommand(command, cliEnabled) {
+    const { config, isNew } = loadOrCreateConfig();
+    const enabled = isTelemetryEnabled(cliEnabled, config);
+    if (!enabled)
+        return;
+    const device = (0, device_1.loadDeviceIdentity)();
+    if (isNew) {
+        await sendEvent({
+            event: 'first_run',
+            installationId: config.installationId,
+            deviceId: device.deviceId,
+            os: getOsName(),
+            arch: process.arch,
+            cliVersion: (0, config_1.getCliVersion)()
+        });
+    }
+    await sendEvent({
+        event: 'command_run',
+        installationId: config.installationId,
+        command,
+        cliVersion: (0, config_1.getCliVersion)()
+    });
+}
+async function trackLogin(email, cliEnabled) {
+    const { config } = loadOrCreateConfig();
+    const enabled = isTelemetryEnabled(cliEnabled, config);
+    if (!enabled)
+        return;
+    await sendEvent({
+        event: 'login',
+        installationId: config.installationId,
+        email: email ?? '',
+        cliVersion: (0, config_1.getCliVersion)()
+    });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "generate-ui-cli",
-  "version": "2.0.0",
-  "description": "Generate UI from OpenAPI locally with optional Dev unlocks.",
+  "version": "2.1.0",
+  "description": "Generate UI from OpenAPI",
   "license": "MIT",
   "repository": {
     "type": "git",