generate-ui-cli 1.0.0 → 2.1.0

package/README.md

@@ -1,32 +1,310 @@
 # GenerateUI CLI
 
-Generate UI from OpenAPI locally. Free works offline with 1 generation per device; Dev unlocks unlimited generation, safe regeneration, and UI overrides.
+Generate CRUD screens (List, Create/Edit, Delete), typed API services, and routes from your OpenAPI spec with real Angular code you can own and evolve.
 
-## Install
+Goal: stop rewriting repetitive CRUD and start with a functional, scalable UI foundation.
+
+## What GenerateUI Does
+
+Given an `openapi.yaml` (or `.json`), GenerateUI can generate:
+
+- `screens.json` (detected screens/endpoints)
+- one folder per feature/screen
+- typed API services and DTOs
+- plug-and-play routes
+- basic CRUD UI (list + form + delete confirmation)
+- UI states (loading / empty / error)
+
+GenerateUI is code generation, not runtime rendering.
+
+## Before You Start (Quick Checklist)
+
+You will need:
+
+- Node.js (LTS recommended)
+- A valid OpenAPI v3.x file
+- An Angular project (for Angular generation) > v.15
+- Optional: a design system (Material, PrimeNG, internal DS)
+
+Important:
+- Incomplete OpenAPI specs (missing schemas, responses, or types) may limit what can be generated.
+- Some public APIs require query params (e.g. `fields=...`). Make sure your API calls actually work.
+
+## Installation
+
+### Global install
 ```bash
 npm install -g generate-ui-cli
 ```
 
-## Usage
+### Local install
 ```bash
-generate-ui generate --openapi /path/to/openapi.yaml
+npm install -D generate-ui-cli
+```
+
+Then run:
+```bash
+npx generate-ui --help
+```
+
+## Recommended Workflow
+
+GenerateUI works in two main steps:
+
+1. Read the OpenAPI and generate `screens.json`
+2. Generate Angular code from `screens.json`
+
+## 1) Generate `screens.json`
+
+```bash
+generate-ui generate --openapi openapiWeather.yaml
+```
+
+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.
+- 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:
+
+- Are all expected screens present?
+- Are screen and route names correct?
+- Are required query params represented?
+- Do the detected fields match your API schemas?
+
+Tip: this is the best moment to adjust naming and structure before generating code.
+
+## 2) Generate Angular code from `screens.json`
+
+```bash
+generate-ui angular
 ```
 
-Safe regeneration (Dev):
+What happens after this command:
+
+- For each screen defined in `screens.json`, GenerateUI creates:
+  - a feature folder
+  - list and form components (create/edit)
+  - a typed API service
+  - DTO/types files
+  - route definitions
+
+What you should review now:
+
+- Are files generated in the correct location?
+- Does the project compile?
+- Are routes correctly generated and importable?
+- Does the basic UI work end-to-end?
+
+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 regenerate --openapi /path/to/openapi.yaml
+generate-ui angular \
+  --schemas /path/to/generate-ui \
+  --features /path/to/angular/features
 ```
 
-Login (Dev):
+Custom output folder for `generate`:
+
+```bash
+generate-ui generate --openapi youropenapi.yaml --output /path/to/generate-ui
+```
+
+## Login (Dev plan)
+
 ```bash
 generate-ui login
 ```
 
-Telemetry can be disabled with:
+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:
+
+- `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 { generatedRoutes } from '../generate-ui/routes.gen';
+
+export const routes = [
+  // ...your existing routes
+  ...generatedRoutes
+];
+```
+
+Things to pay attention to:
+
+- route prefixes (`/admin`, `/app`, etc.)
+- 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/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.component.ts
+    users.service.gen.ts
+    users.gen.ts
+  orders/
+    orders.component.ts
+    orders.service.gen.ts
+    orders.gen.ts
+```
+
+## After Generation: How to Customize Safely
+
+GenerateUI gives you a working baseline. From here, you typically:
+
+- Customize UI (design system components, masks, validators)
+- Add business logic (conditional fields, permissions)
+- Improve UX (pagination, filtering, empty/error states)
+
+Rule of thumb: the generated code is yours — generate once, then evolve freely.
+
+## Overrides and Regeneration Behavior
+
+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 `overlays/` will be mirrored the next time you regenerate.
+
+## Common Issues and Fixes
+
+### "required option '-o, --openapi <path>' not specified"
+
+You ran the command without passing the OpenAPI file.
+
+Fix:
 ```bash
-generate-ui --no-telemetry generate --openapi /path/to/openapi.yaml
+generate-ui generate --openapi /path/to/openapi.yaml
 ```
 
-## Local files
+### "An endpoint exists but no screen was generated"
+
+This may happen if:
+
+- `operationId` is missing
+- request/response schemas are empty
+- required response codes (`200`, `201`) are missing
+
+Recommendation:
+
+- always define `operationId`
+- include schemas in responses
+
+### "Routes were generated but navigation does not work"
+
+Usually a routing integration issue.
+
+Check:
+
+- if `GENERATED_ROUTES` is imported/spread
+- if route prefixes match your menu
+- if there is a `<router-outlet>` in your layout
+
+## Team Workflow Recommendation
+
+1. Update OpenAPI
+2. Generate `screens.json`
+3. Review `screens.json`
+4. Generate Angular code
+5. Customize UI and business rules
+6. Commit
+
+## Tips for Better Results
+
+- Use consistent `operationId`s (`users_list`, `users_create`, etc.)
+- Define complete schemas (types, required, enums)
+- Standardize responses (`200`, `201`, `204`)
+- Document important query params (pagination, filters)
+- If your API requires `fields=...`, reflect it in `screens.json`
+
+## Roadmap (Example)
+
+- [ ] Layout presets (minimal / enterprise / dashboard)
+- [ ] Design system adapters (Material / PrimeNG / custom)
+- [ ] Filters and real pagination
+- [ ] UI schema overrides (visual control without touching OpenAPI)
+- [ ] React support
+
+## Contributing
+
+Issues and PRs are welcome.
+If you use GenerateUI in a company or real project, let us know — it helps guide the roadmap.
+
+## License
+
+MIT
+
+## Local Files
+
 - `~/.generateui/device.json`
 - `~/.generateui/token.json`

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

@@ -11,9 +11,10 @@ const screen_generator_1 = require("../generators/screen.generator");
 const screen_merge_1 = require("../generators/screen.merge");
 const permissions_1 = require("../license/permissions");
 const device_1 = require("../license/device");
-const guard_1 = require("../license/guard");
 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
@@ -26,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 });
     /**
@@ -38,10 +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)(options.telemetryCommand, options.telemetryEnabled);
-    if (options.requireSafeRegeneration) {
-        (0, guard_1.requireFeature)(permissions.features, 'safeRegeneration', 'Regeneration requires safe regeneration.');
-    }
     if (permissions.features.maxGenerations > -1 &&
         device.freeGenerationsUsed >= permissions.features.maxGenerations) {
         throw new Error('🔒 Você já utilizou sua geração gratuita.\n' +
@@ -146,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,15 +19,16 @@ 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,
-            telemetryCommand: 'generate'
+            telemetryEnabled: telemetry
         });
     }
     catch (error) {
@@ -40,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 {
@@ -70,29 +71,6 @@ program
         handleCliError(error);
     }
 });
-/**
- * 4️⃣ Regenerate with safe merge
- */
-program
-    .command('regenerate')
-    .description('Regenerate screen schemas with safe merge')
-    .requiredOption('-o, --openapi <path>', 'OpenAPI file')
-    .option('-d, --debug', 'Explain merge decisions')
-    .action(async (options) => {
-    const { telemetry } = program.opts();
-    try {
-        await (0, generate_1.generate)({
-            openapi: options.openapi,
-            debug: options.debug,
-            telemetryEnabled: telemetry,
-            telemetryCommand: 'regenerate',
-            requireSafeRegeneration: true
-        });
-    }
-    catch (error) {
-        handleCliError(error);
-    }
-});
 function handleCliError(error) {
     if (error instanceof Error) {
         console.error(error.message.replace(/\\n/g, '\n'));

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": "1.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",