eventmodeler 0.6.0 → 0.6.2

package/dist/commands/update.js

@@ -1,240 +0,0 @@
-import { getGlobalId } from '../lib/globals';
-import { requireModelId } from '../lib/model';
-import { resolveAnyElement, unwrap, elementIdKey } from '../lib/resolve';
-import * as sdk from '../api/generated/sdk.gen';
-const RENAME_FIELD_MAP = {
-    command: sdk.renameCommandField,
-    event: sdk.renameEventField,
-    readmodel: sdk.renameReadModelField,
-    screen: sdk.renameScreenField,
-    processor: sdk.renameProcessorField,
-    'external-event': sdk.renameExternalEventField,
-};
-const CHANGE_TYPE_MAP = {
-    command: sdk.changeCommandFieldType,
-    event: sdk.changeEventFieldType,
-    readmodel: sdk.changeReadModelFieldType,
-    screen: sdk.changeScreenFieldType,
-    processor: sdk.changeProcessorFieldType,
-    'external-event': sdk.changeExternalEventFieldType,
-};
-const REORDER_FIELD_MAP = {
-    command: sdk.reorderCommandField,
-    event: sdk.reorderEventField,
-    readmodel: sdk.reorderReadModelField,
-    screen: sdk.reorderScreenField,
-    processor: sdk.reorderProcessorField,
-    'external-event': sdk.reorderExternalEventField,
-};
-const RENAME_SUBFIELD_MAP = {
-    command: sdk.renameCommandSubfield,
-    event: sdk.renameEventSubfield,
-    readmodel: sdk.renameReadModelSubfield,
-    screen: sdk.renameScreenSubfield,
-    processor: sdk.renameProcessorSubfield,
-    'external-event': sdk.renameExternalEventSubfield,
-};
-const CHANGE_SUBFIELD_TYPE_MAP = {
-    command: sdk.changeCommandSubfieldType,
-    event: sdk.changeEventSubfieldType,
-    readmodel: sdk.changeReadModelSubfieldType,
-    screen: sdk.changeScreenSubfieldType,
-    processor: sdk.changeProcessorSubfieldType,
-    'external-event': sdk.changeExternalEventSubfieldType,
-};
-const REORDER_SUBFIELD_MAP = {
-    command: sdk.reorderCommandSubfield,
-    event: sdk.reorderEventSubfield,
-    readmodel: sdk.reorderReadModelSubfield,
-    screen: sdk.reorderScreenSubfield,
-    processor: sdk.reorderProcessorSubfield,
-    'external-event': sdk.reorderExternalEventSubfield,
-};
-const buildMarkMap = () => ({
-    command: {
-        optional: { mark: sdk.markCommandFieldAsOptional, unmark: sdk.unmarkCommandFieldAsOptional },
-        generated: { mark: sdk.markCommandFieldAsGenerated, unmark: sdk.unmarkCommandFieldAsGenerated },
-        list: { mark: sdk.markCommandFieldAsList, unmark: sdk.unmarkCommandFieldAsList },
-    },
-    event: {
-        optional: { mark: sdk.markEventFieldAsOptional, unmark: sdk.unmarkEventFieldAsOptional },
-        generated: { mark: sdk.markEventFieldAsGenerated, unmark: sdk.unmarkEventFieldAsGenerated },
-        list: { mark: sdk.markEventFieldAsList, unmark: sdk.unmarkEventFieldAsList },
-    },
-    readmodel: {
-        optional: { mark: sdk.markReadModelFieldAsOptional, unmark: sdk.unmarkReadModelFieldAsOptional },
-        generated: { mark: sdk.markReadModelFieldAsGenerated, unmark: sdk.unmarkReadModelFieldAsGenerated },
-        list: { mark: sdk.markReadModelFieldAsList, unmark: sdk.unmarkReadModelFieldAsList },
-    },
-    screen: {
-        optional: { mark: sdk.markScreenFieldAsOptional, unmark: sdk.unmarkScreenFieldAsOptional },
-        generated: { mark: sdk.markScreenFieldAsGenerated, unmark: sdk.unmarkScreenFieldAsGenerated },
-        list: { mark: sdk.markScreenFieldAsList, unmark: sdk.unmarkScreenFieldAsList },
-        'user-input': { mark: sdk.markScreenFieldAsUserInput, unmark: sdk.unmarkScreenFieldAsUserInput },
-    },
-    processor: {
-        optional: { mark: sdk.markProcessorFieldAsOptional, unmark: sdk.unmarkProcessorFieldAsOptional },
-        generated: { mark: sdk.markProcessorFieldAsGenerated, unmark: sdk.unmarkProcessorFieldAsGenerated },
-        list: { mark: sdk.markProcessorFieldAsList, unmark: sdk.unmarkProcessorFieldAsList },
-    },
-    'external-event': {
-        optional: { mark: sdk.markExternalEventFieldAsOptional, unmark: sdk.unmarkExternalEventFieldAsOptional },
-        list: { mark: sdk.markExternalEventFieldAsList, unmark: sdk.unmarkExternalEventFieldAsList },
-    },
-});
-const buildSubfieldMarkMap = () => ({
-    command: {
-        optional: { mark: sdk.markCommandSubfieldAsOptional, unmark: sdk.unmarkCommandSubfieldAsOptional },
-        generated: { mark: sdk.markCommandSubfieldAsGenerated, unmark: sdk.unmarkCommandSubfieldAsGenerated },
-        list: { mark: sdk.markCommandSubfieldAsList, unmark: sdk.unmarkCommandSubfieldAsList },
-    },
-    event: {
-        optional: { mark: sdk.markEventSubfieldAsOptional, unmark: sdk.unmarkEventSubfieldAsOptional },
-        generated: { mark: sdk.markEventSubfieldAsGenerated, unmark: sdk.unmarkEventSubfieldAsGenerated },
-        list: { mark: sdk.markEventSubfieldAsList, unmark: sdk.unmarkEventSubfieldAsList },
-    },
-    readmodel: {
-        optional: { mark: sdk.markReadModelSubfieldAsOptional, unmark: sdk.unmarkReadModelSubfieldAsOptional },
-        generated: { mark: sdk.markReadModelSubfieldAsGenerated, unmark: sdk.unmarkReadModelSubfieldAsGenerated },
-        list: { mark: sdk.markReadModelSubfieldAsList, unmark: sdk.unmarkReadModelSubfieldAsList },
-    },
-    screen: {
-        optional: { mark: sdk.markScreenSubfieldAsOptional, unmark: sdk.unmarkScreenSubfieldAsOptional },
-        generated: { mark: sdk.markScreenSubfieldAsGenerated, unmark: sdk.unmarkScreenSubfieldAsGenerated },
-        list: { mark: sdk.markScreenSubfieldAsList, unmark: sdk.unmarkScreenSubfieldAsList },
-        'user-input': { mark: sdk.markScreenSubfieldAsUserInput, unmark: sdk.unmarkScreenSubfieldAsUserInput },
-    },
-    processor: {
-        optional: { mark: sdk.markProcessorSubfieldAsOptional, unmark: sdk.unmarkProcessorSubfieldAsOptional },
-        generated: { mark: sdk.markProcessorSubfieldAsGenerated, unmark: sdk.unmarkProcessorSubfieldAsGenerated },
-        list: { mark: sdk.markProcessorSubfieldAsList, unmark: sdk.unmarkProcessorSubfieldAsList },
-    },
-    'external-event': {
-        optional: { mark: sdk.markExternalEventSubfieldAsOptional, unmark: sdk.unmarkExternalEventSubfieldAsOptional },
-        list: { mark: sdk.markExternalEventSubfieldAsList, unmark: sdk.unmarkExternalEventSubfieldAsList },
-    },
-});
-export function registerUpdateCommands(program) {
-    const update = program.command('update').description('Update fields and subfields');
-    update.command('field [elementName]')
-        .description('Update field properties')
-        .requiredOption('--field <name>', 'Field name')
-        .option('--name <newName>', 'Rename the field')
-        .option('--type <newType>', 'Change the field type')
-        .option('--optional <bool>', 'Mark as optional (true/false)')
-        .option('--generated <bool>', 'Mark as generated (true/false)')
-        .option('--list <bool>', 'Mark as list (true/false)')
-        .option('--user-input <bool>', 'Mark as user input (true/false, screens only)')
-        .action(async (elementName, opts, cmd) => {
-        const modelId = requireModelId();
-        const { elementId, elementType } = await resolveAnyElement(modelId, elementName ?? '', getGlobalId());
-        const key = elementIdKey(elementType);
-        const fieldResult = unwrap(await sdk.resolveField({
-            query: { modelId, elementId, fieldName: opts.field }
-        }));
-        const fieldId = fieldResult.fieldId;
-        if (opts.name) {
-            const fn = RENAME_FIELD_MAP[elementType];
-            if (!fn)
-                throw new Error(`Cannot rename fields on type: ${elementType}`);
-            unwrap(await fn({ body: { modelId, [key]: elementId, fieldId, fieldName: opts.name } }));
-            console.log(`Renamed field to "${opts.name}".`);
-        }
-        if (opts.type) {
-            const fn = CHANGE_TYPE_MAP[elementType];
-            if (!fn)
-                throw new Error(`Cannot change field type on: ${elementType}`);
-            unwrap(await fn({ body: { modelId, [key]: elementId, fieldId, fieldType: opts.type } }));
-            console.log(`Changed field type to "${opts.type}".`);
-        }
-        const markMap = buildMarkMap();
-        for (const flag of ['optional', 'generated', 'list', 'user-input']) {
-            const value = opts[flag === 'user-input' ? 'userInput' : flag];
-            if (value === undefined)
-                continue;
-            const boolVal = value === 'true';
-            const entry = markMap[elementType]?.[flag];
-            if (!entry)
-                throw new Error(`Cannot set ${flag} on type: ${elementType}`);
-            const fn = boolVal ? entry.mark : entry.unmark;
-            unwrap(await fn({ body: { modelId, [key]: elementId, fieldId } }));
-            console.log(`${boolVal ? 'Marked' : 'Unmarked'} field as ${flag}.`);
-        }
-    });
-    // update subfield [elementName] --subfield <subfieldId> [--name <newName>] [--type <newType>] [--list <bool>] ...
-    update.command('subfield [elementName]')
-        .description('Update subfield properties')
-        .requiredOption('--subfield <id>', 'Subfield ID (from show output)')
-        .option('--name <newName>', 'Rename the subfield')
-        .option('--type <newType>', 'Change the subfield type')
-        .option('--optional <bool>', 'Mark as optional (true/false)')
-        .option('--generated <bool>', 'Mark as generated (true/false)')
-        .option('--list <bool>', 'Mark as list (true/false)')
-        .option('--user-input <bool>', 'Mark as user input (true/false, screens only)')
-        .action(async (elementName, opts, cmd) => {
-        const modelId = requireModelId();
-        const { elementId, elementType } = await resolveAnyElement(modelId, elementName ?? '', getGlobalId());
-        const key = elementIdKey(elementType);
-        if (opts.name) {
-            const fn = RENAME_SUBFIELD_MAP[elementType];
-            if (!fn)
-                throw new Error(`Cannot rename subfields on type: ${elementType}`);
-            unwrap(await fn({ body: { modelId, [key]: elementId, subfieldId: opts.subfield, fieldName: opts.name } }));
-            console.log(`Renamed subfield to "${opts.name}".`);
-        }
-        if (opts.type) {
-            const fn = CHANGE_SUBFIELD_TYPE_MAP[elementType];
-            if (!fn)
-                throw new Error(`Cannot change subfield type on: ${elementType}`);
-            unwrap(await fn({ body: { modelId, [key]: elementId, subfieldId: opts.subfield, fieldType: opts.type } }));
-            console.log(`Changed subfield type to "${opts.type}".`);
-        }
-        const markMap = buildSubfieldMarkMap();
-        for (const flag of ['optional', 'generated', 'list', 'user-input']) {
-            const value = opts[flag === 'user-input' ? 'userInput' : flag];
-            if (value === undefined)
-                continue;
-            const boolVal = value === 'true';
-            const entry = markMap[elementType]?.[flag];
-            if (!entry)
-                throw new Error(`Cannot set ${flag} on type: ${elementType}`);
-            const fn = boolVal ? entry.mark : entry.unmark;
-            unwrap(await fn({ body: { modelId, [key]: elementId, subfieldId: opts.subfield } }));
-            console.log(`${boolVal ? 'Marked' : 'Unmarked'} subfield as ${flag}.`);
-        }
-    });
-    // update reorder [elementName] --field <name> --position <n>
-    update.command('reorder [elementName]')
-        .description('Reorder a field on an element')
-        .requiredOption('--field <name>', 'Field name')
-        .requiredOption('--position <n>', 'New position (0-based)', parseInt)
-        .action(async (elementName, opts, cmd) => {
-        const modelId = requireModelId();
-        const { elementId, elementType } = await resolveAnyElement(modelId, elementName ?? '', getGlobalId());
-        const fn = REORDER_FIELD_MAP[elementType];
-        if (!fn)
-            throw new Error(`Cannot reorder fields on type: ${elementType}`);
-        const fieldResult = unwrap(await sdk.resolveField({
-            query: { modelId, elementId, fieldName: opts.field }
-        }));
-        const fieldId = fieldResult.fieldId;
-        const key = elementIdKey(elementType);
-        unwrap(await fn({ body: { modelId, [key]: elementId, fieldId, position: opts.position } }));
-        console.log(`Moved field "${opts.field}" to position ${opts.position}.`);
-    });
-    // update reorder-subfield [elementName] --subfield <id> --position <n>
-    update.command('reorder-subfield [elementName]')
-        .description('Reorder a subfield within its parent')
-        .requiredOption('--subfield <id>', 'Subfield ID (from show output)')
-        .requiredOption('--position <n>', 'New position (0-based)', parseInt)
-        .action(async (elementName, opts, cmd) => {
-        const modelId = requireModelId();
-        const { elementId, elementType } = await resolveAnyElement(modelId, elementName ?? '', getGlobalId());
-        const fn = REORDER_SUBFIELD_MAP[elementType];
-        if (!fn)
-            throw new Error(`Cannot reorder subfields on type: ${elementType}`);
-        const key = elementIdKey(elementType);
-        unwrap(await fn({ body: { modelId, [key]: elementId, subfieldId: opts.subfield, position: opts.position } }));
-        console.log(`Moved subfield to position ${opts.position}.`);
-    });
-}

package/dist/lib/auth.js

@@ -1,331 +0,0 @@
-import * as http from 'node:http';
-import * as crypto from 'node:crypto';
-import { exec } from 'node:child_process';
-import { saveAuthTokens, clearAuthTokens, getAuthTokens, getKeycloakUrl } from './config';
-const KEYCLOAK_CLIENT_ID = 'eventmodeler-cli';
-const REDIRECT_URI = 'http://localhost:8787/callback';
-/**
- * Decode the payload of a JWT token (no signature verification - that's the server's job).
- */
-function decodeJwtPayload(token) {
-    const parts = token.split('.');
-    if (parts.length !== 3)
-        throw new Error('Invalid JWT format');
-    const payload = Buffer.from(parts[1], 'base64url').toString('utf-8');
-    return JSON.parse(payload);
-}
-/**
- * Generate PKCE code verifier and challenge.
- */
-function generatePKCE() {
-    // Generate a random code verifier (43-128 characters)
-    const codeVerifier = crypto.randomBytes(32).toString('base64url');
-    // Generate code challenge using S256 method
-    const codeChallenge = crypto
-        .createHash('sha256')
-        .update(codeVerifier)
-        .digest('base64url');
-    return { codeVerifier, codeChallenge };
-}
-/**
- * Starts the OAuth flow using Keycloak PKCE.
- * Opens browser and waits for the callback.
- */
-export async function startAuthFlow() {
-    return new Promise((resolve) => {
-        const keycloakUrl = getKeycloakUrl();
-        // Generate PKCE values
-        const { codeVerifier, codeChallenge } = generatePKCE();
-        // Generate state for CSRF protection
-        const state = crypto.randomBytes(16).toString('hex');
-        // Create local server to receive callback
-        const server = http.createServer(async (req, res) => {
-            const url = new URL(req.url ?? '/', `http://localhost:8787`);
-            if (url.pathname === '/callback') {
-                const code = url.searchParams.get('code');
-                const returnedState = url.searchParams.get('state');
-                const error = url.searchParams.get('error');
-                if (error) {
-                    res.writeHead(200, { 'Content-Type': 'text/html' });
-                    res.end(renderHtml('Authentication Failed', `Error: ${error}`, false));
-                    server.close();
-                    resolve({ success: false, error });
-                    return;
-                }
-                if (returnedState !== state) {
-                    res.writeHead(200, { 'Content-Type': 'text/html' });
-                    res.end(renderHtml('Authentication Failed', 'Invalid state parameter. Please try again.', false));
-                    server.close();
-                    resolve({ success: false, error: 'Invalid state parameter' });
-                    return;
-                }
-                if (!code) {
-                    res.writeHead(200, { 'Content-Type': 'text/html' });
-                    res.end(renderHtml('Authentication Failed', 'No authorization code received.', false));
-                    server.close();
-                    resolve({ success: false, error: 'No authorization code' });
-                    return;
-                }
-                try {
-                    // Exchange the code for tokens via Keycloak token endpoint (form-urlencoded)
-                    const tokenUrl = `${keycloakUrl}/protocol/openid-connect/token`;
-                    const body = new URLSearchParams({
-                        client_id: KEYCLOAK_CLIENT_ID,
-                        code,
-                        code_verifier: codeVerifier,
-                        grant_type: 'authorization_code',
-                        redirect_uri: REDIRECT_URI,
-                    });
-                    const tokenResponse = await fetch(tokenUrl, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/x-www-form-urlencoded',
-                        },
-                        body: body.toString(),
-                    });
-                    if (!tokenResponse.ok) {
-                        const errorData = await tokenResponse.json().catch(() => ({}));
-                        throw new Error(errorData.error_description ?? errorData.error ?? `Token exchange failed: ${tokenResponse.status}`);
-                    }
-                    const tokenData = await tokenResponse.json();
-                    // Extract user info from JWT claims
-                    const claims = decodeJwtPayload(tokenData.access_token);
-                    const expiresAt = Date.now() + (tokenData.expires_in ?? 3600) * 1000;
-                    const tokens = {
-                        accessToken: tokenData.access_token,
-                        refreshToken: tokenData.refresh_token ?? '',
-                        expiresAt,
-                        userId: String(claims.sub ?? ''),
-                        email: String(claims.email ?? ''),
-                    };
-                    saveAuthTokens(tokens);
-                    res.writeHead(200, { 'Content-Type': 'text/html' });
-                    res.end(renderHtml('Authentication Successful!', formatSuccessMessage(tokens.email), true));
-                    server.close();
-                    resolve({ success: true, tokens });
-                }
-                catch (err) {
-                    const errorMessage = err instanceof Error ? err.message : 'Unknown error';
-                    res.writeHead(200, { 'Content-Type': 'text/html' });
-                    res.end(renderHtml('Authentication Failed', errorMessage, false));
-                    server.close();
-                    resolve({ success: false, error: errorMessage });
-                }
-            }
-            else {
-                res.writeHead(404);
-                res.end('Not found');
-            }
-        });
-        server.listen(8787, () => {
-            // Build Keycloak authorization URL with PKCE
-            const params = new URLSearchParams({
-                client_id: KEYCLOAK_CLIENT_ID,
-                redirect_uri: REDIRECT_URI,
-                response_type: 'code',
-                state,
-                code_challenge: codeChallenge,
-                code_challenge_method: 'S256',
-                scope: 'openid email profile',
-            });
-            const authorizationUrl = `${keycloakUrl}/protocol/openid-connect/auth?${params}`;
-            console.log('\nOpening browser for authentication...');
-            // Open the browser
-            openBrowser(authorizationUrl);
-        });
-        // Timeout after 5 minutes
-        setTimeout(() => {
-            server.close();
-            resolve({ success: false, error: 'Authentication timed out' });
-        }, 5 * 60 * 1000);
-    });
-}
-/**
- * Refresh the access token using the refresh token.
- */
-export async function refreshAccessToken() {
-    const tokens = getAuthTokens();
-    if (!tokens?.refreshToken) {
-        return { success: false, error: 'No refresh token available' };
-    }
-    const keycloakUrl = getKeycloakUrl();
-    const tokenUrl = `${keycloakUrl}/protocol/openid-connect/token`;
-    try {
-        const body = new URLSearchParams({
-            client_id: KEYCLOAK_CLIENT_ID,
-            refresh_token: tokens.refreshToken,
-            grant_type: 'refresh_token',
-        });
-        const response = await fetch(tokenUrl, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded',
-            },
-            body: body.toString(),
-        });
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({}));
-            throw new Error(errorData.error_description ?? errorData.error ?? `Token refresh failed: ${response.status}`);
-        }
-        const tokenData = await response.json();
-        // Extract user info from refreshed JWT
-        const claims = decodeJwtPayload(tokenData.access_token);
-        const newTokens = {
-            accessToken: tokenData.access_token,
-            refreshToken: tokenData.refresh_token ?? tokens.refreshToken,
-            expiresAt: Date.now() + (tokenData.expires_in ?? 3600) * 1000,
-            userId: String(claims.sub ?? tokens.userId),
-            email: String(claims.email ?? tokens.email),
-        };
-        saveAuthTokens(newTokens);
-        return { success: true, tokens: newTokens };
-    }
-    catch (err) {
-        const errorMessage = err instanceof Error ? err.message : 'Unknown error';
-        return { success: false, error: errorMessage };
-    }
-}
-/**
- * Get a valid access token, refreshing if needed.
- */
-export async function getValidAccessToken() {
-    const tokens = getAuthTokens();
-    if (!tokens)
-        return null;
-    // If token is expired or will expire in 5 minutes, refresh it
-    if (tokens.expiresAt < Date.now() + 5 * 60 * 1000) {
-        const result = await refreshAccessToken();
-        if (!result.success || !result.tokens)
-            return null;
-        return result.tokens.accessToken;
-    }
-    return tokens.accessToken;
-}
-/**
- * Log out by clearing stored tokens.
- */
-export function logout() {
-    clearAuthTokens();
-}
-/**
- * Open a URL in the default browser.
- */
-function openBrowser(url) {
-    const platform = process.platform;
-    let command;
-    if (platform === 'darwin') {
-        command = `open "${url}"`;
-    }
-    else if (platform === 'win32') {
-        command = `start "" "${url}"`;
-    }
-    else {
-        command = `xdg-open "${url}"`;
-    }
-    exec(command, (err) => {
-        if (err) {
-            console.error('Failed to open browser:', err.message);
-        }
-    });
-}
-/**
- * Render a styled HTML page for the callback matching Event Modeler's design.
- */
-function renderHtml(title, message, success) {
-    const iconColor = success ? '#16a34a' : '#dc2626';
-    const icon = success
-        ? `<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 24 24" fill="none" stroke="${iconColor}" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"/><polyline points="22 4 12 14.01 9 11.01"/></svg>`
-        : `<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 24 24" fill="none" stroke="${iconColor}" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="15" y1="9" x2="9" y2="15"/><line x1="9" y1="9" x2="15" y2="15"/></svg>`;
-    return `<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>${title} - Event Modeler</title>
-    <style>
-      * { box-sizing: border-box; margin: 0; padding: 0; }
-      body {
-        font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-        display: flex;
-        flex-direction: column;
-        justify-content: center;
-        align-items: center;
-        min-height: 100vh;
-        background: #fafaf9;
-        color: #57534e;
-        padding: 1rem;
-      }
-      .card {
-        background: white;
-        border: 1px solid #e7e5e4;
-        border-radius: 12px;
-        padding: 2.5rem 3rem;
-        text-align: center;
-        max-width: 420px;
-        width: 100%;
-        box-shadow: 0 1px 3px rgba(0,0,0,0.05);
-      }
-      .icon {
-        margin-bottom: 1.5rem;
-      }
-      .logo {
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        gap: 0.5rem;
-        margin-bottom: 2rem;
-        font-weight: 600;
-        font-size: 1.125rem;
-        color: #44403c;
-      }
-      .logo svg {
-        width: 28px;
-        height: 28px;
-      }
-      h1 {
-        font-size: 1.5rem;
-        font-weight: 600;
-        color: #1c1917;
-        margin-bottom: 0.5rem;
-      }
-      .message {
-        color: #78716c;
-        margin-bottom: 1.5rem;
-        line-height: 1.5;
-      }
-      .hint {
-        font-size: 0.875rem;
-        color: #a8a29e;
-        padding-top: 1.5rem;
-        border-top: 1px solid #f5f5f4;
-      }
-      .email {
-        font-weight: 500;
-        color: #44403c;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="card">
-      <div class="logo">
-        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
-          <path d="M50 50 L50 5 A45 45 0 0 1 89.0 72.5 Z" fill="#D5F1A5"/>
-          <path d="M50 50 L89.0 72.5 A45 45 0 0 1 11.0 72.5 Z" fill="#FFB87B"/>
-          <path d="M50 50 L11.0 72.5 A45 45 0 0 1 50 5 Z" fill="#B7D3FE"/>
-        </svg>
-        Event Modeler
-      </div>
-      <div class="icon">${icon}</div>
-      <h1>${title}</h1>
-      <p class="message">${message}</p>
-      <p class="hint">You can close this window and return to the terminal.</p>
-    </div>
-  </body>
-</html>`;
-}
-/**
- * Format the success message with email highlighted.
- */
-function formatSuccessMessage(email) {
-    return `Signed in as <span class="email">${email}</span>`;
-}

package/dist/lib/config.js

@@ -1,80 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-const CONFIG_DIR = path.join(os.homedir(), '.eventmodeler');
-const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
-export function getConfigDir() {
-    return CONFIG_DIR;
-}
-export function getConfigPath() {
-    return CONFIG_PATH;
-}
-export function ensureConfigDir() {
-    if (!fs.existsSync(CONFIG_DIR)) {
-        fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
-    }
-}
-export function loadGlobalConfig() {
-    try {
-        if (fs.existsSync(CONFIG_PATH)) {
-            return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
-        }
-    }
-    catch {
-        // Ignore errors, return empty config
-    }
-    return {};
-}
-export function saveGlobalConfig(config) {
-    ensureConfigDir();
-    fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
-}
-export function getAuthTokens() {
-    const config = loadGlobalConfig();
-    return config.auth ?? null;
-}
-export function saveAuthTokens(tokens) {
-    const config = loadGlobalConfig();
-    config.auth = tokens;
-    saveGlobalConfig(config);
-}
-export function clearAuthTokens() {
-    const config = loadGlobalConfig();
-    delete config.auth;
-    saveGlobalConfig(config);
-}
-export function isAuthenticated() {
-    const tokens = getAuthTokens();
-    if (!tokens)
-        return false;
-    // Check if token is expired (with 5 minute buffer)
-    return tokens.expiresAt > Date.now() + 5 * 60 * 1000;
-}
-export function getBackendUrl() {
-    const config = loadGlobalConfig();
-    if (config.backendUrl)
-        return config.backendUrl;
-    if (process.env.EVENTMODELER_BACKEND_URL)
-        return process.env.EVENTMODELER_BACKEND_URL;
-    // Default to production unless development mode is enabled
-    return config.development ? 'http://localhost:8080' : 'https://api.eventmodeler.com';
-}
-export function setBackendUrl(url) {
-    const config = loadGlobalConfig();
-    config.backendUrl = url;
-    saveGlobalConfig(config);
-}
-export function getKeycloakUrl() {
-    const config = loadGlobalConfig();
-    if (config.keycloakUrl)
-        return config.keycloakUrl;
-    if (process.env.EVENTMODELER_KEYCLOAK_URL)
-        return process.env.EVENTMODELER_KEYCLOAK_URL;
-    // Default to production unless development mode is enabled
-    return config.development ? 'http://localhost:18180/realms/eventmodeler' : 'https://auth.eventmodeler.com/realms/eventmodeler';
-}
-export function setKeycloakUrl(url) {
-    const config = loadGlobalConfig();
-    config.keycloakUrl = url;
-    saveGlobalConfig(config);
-}