@camunda8/cli 1.1.0 → 2.0.0-alpha.10

package/dist/config.js

@@ -1,16 +1,107 @@
 /**
  * Configuration and session state management for c8ctl
- * Handles profiles, session state, and credential resolution
+ *
+ * c8ctl stores its own profiles in DATA_DIR/c8ctl/profiles.json
+ * Modeler connections are read from settings.json (read-only) with "modeler:" prefix
  */
 import { homedir, platform } from 'node:os';
 import { join } from 'node:path';
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
 import { c8ctl } from "./runtime.js";
+// ============================================================================
+// Constants - matching Camunda Modeler exactly
+// ============================================================================
+export const TARGET_TYPES = {
+    CAMUNDA_CLOUD: 'camundaCloud',
+    SELF_HOSTED: 'selfHosted',
+};
+export const AUTH_TYPES = {
+    NONE: 'none',
+    BASIC: 'basic',
+    OAUTH: 'oauth',
+};
+// ============================================================================
+// Validation - matching Camunda Modeler's validation rules
+// ============================================================================
+const VALIDATION_PATTERNS = {
+    URL: /^https?:\/\//,
+    CAMUNDA_CLOUD_REST_URL: /^https:\/\/[a-z]+-\d+\.zeebe\.camunda\.io(:443|)\/[a-z\d-]+\/?$/,
+};
+// Cloud URLs must be REST URLs (HTTP-based)
+const CAMUNDA_CLOUD_URL_PATTERN = VALIDATION_PATTERNS.CAMUNDA_CLOUD_REST_URL;
+/**
+ * Validate a connection configuration
+ * Returns array of error messages (empty if valid)
+ */
+export function validateConnection(conn) {
+    const errors = [];
+    if (!conn) {
+        errors.push('Connection configuration is required');
+        return errors;
+    }
+    if (!conn.id) {
+        errors.push('Connection must have an ID');
+    }
+    if (!conn.targetType) {
+        errors.push('Target type is required (camundaCloud or selfHosted)');
+        return errors;
+    }
+    if (conn.targetType === TARGET_TYPES.CAMUNDA_CLOUD) {
+        if (!conn.camundaCloudClusterUrl) {
+            errors.push('Cluster URL is required for Camunda Cloud');
+        }
+        else if (!CAMUNDA_CLOUD_URL_PATTERN.test(conn.camundaCloudClusterUrl)) {
+            errors.push('Cluster URL must be a valid Camunda 8 SaaS URL');
+        }
+        if (!conn.camundaCloudClientId) {
+            errors.push('Client ID is required for Camunda Cloud');
+        }
+        if (!conn.camundaCloudClientSecret) {
+            errors.push('Client Secret is required for Camunda Cloud');
+        }
+    }
+    else if (conn.targetType === TARGET_TYPES.SELF_HOSTED) {
+        if (!conn.contactPoint) {
+            errors.push('Cluster URL (contactPoint) is required for Self-Hosted');
+        }
+        else if (!VALIDATION_PATTERNS.URL.test(conn.contactPoint)) {
+            errors.push('Cluster URL must start with http:// or https://');
+        }
+        if (conn.authType === AUTH_TYPES.BASIC) {
+            if (!conn.basicAuthUsername) {
+                errors.push('Username is required for Basic authentication');
+            }
+            if (!conn.basicAuthPassword) {
+                errors.push('Password is required for Basic authentication');
+            }
+        }
+        else if (conn.authType === AUTH_TYPES.OAUTH) {
+            if (!conn.clientId) {
+                errors.push('Client ID is required for OAuth authentication');
+            }
+            if (!conn.clientSecret) {
+                errors.push('Client Secret is required for OAuth authentication');
+            }
+            if (!conn.oauthURL) {
+                errors.push('OAuth URL is required for OAuth authentication');
+            }
+            if (!conn.audience) {
+                errors.push('Audience is required for OAuth authentication');
+            }
+        }
+    }
+    else {
+        errors.push(`Unknown target type: ${conn.targetType}`);
+    }
+    return errors;
+}
+// ============================================================================
+// Directory and Path Utilities
+// ============================================================================
 /**
- * Get platform-specific user data directory
+ * Get platform-specific user data directory for c8ctl
  */
 export function getUserDataDir() {
-    // Allow override for testing
     if (process.env.C8CTL_DATA_DIR) {
         return process.env.C8CTL_DATA_DIR;
     }
@@ -21,14 +112,19 @@ export function getUserDataDir() {
             return join(process.env.APPDATA || join(home, 'AppData', 'Roaming'), 'c8ctl');
         case 'darwin':
             return join(home, 'Library', 'Application Support', 'c8ctl');
-        default: // linux and others
-            return join(process.env.XDG_DATA_HOME || join(home, '.local', 'share'), 'c8ctl');
+        default:
+            return join(process.env.XDG_CONFIG_HOME || join(home, '.config'), 'c8ctl');
     }
 }
 /**
  * Get platform-specific Camunda Modeler data directory
+ * Modeler stores connections in settings.json
  */
 export function getModelerDataDir() {
+    // Allow override for testing
+    if (process.env.C8CTL_MODELER_DIR) {
+        return process.env.C8CTL_MODELER_DIR;
+    }
     const plat = platform();
     const home = homedir();
     switch (plat) {
@@ -36,13 +132,10 @@ export function getModelerDataDir() {
             return join(process.env.APPDATA || join(home, 'AppData', 'Roaming'), 'camunda-modeler');
         case 'darwin':
             return join(home, 'Library', 'Application Support', 'camunda-modeler');
-        default: // linux and others
+        default:
             return join(process.env.XDG_CONFIG_HOME || join(home, '.config'), 'camunda-modeler');
     }
 }
-/**
- * Ensure user data directory exists
- */
 function ensureUserDataDir() {
     const dir = getUserDataDir();
     if (!existsSync(dir)) {
@@ -50,63 +143,53 @@ function ensureUserDataDir() {
     }
     return dir;
 }
-/**
- * Get profiles file path
- */
+function getSessionStatePath() {
+    return join(ensureUserDataDir(), 'session.json');
+}
 function getProfilesPath() {
     return join(ensureUserDataDir(), 'profiles.json');
 }
-/**
- * Get session state file path
- */
-function getSessionStatePath() {
-    return join(ensureUserDataDir(), 'session.json');
+function getModelerSettingsPath() {
+    return join(getModelerDataDir(), 'settings.json');
 }
 /**
- * Load all profiles
+ * Load c8ctl profiles from profiles.json
  */
 export function loadProfiles() {
-    const path = getProfilesPath();
-    if (!existsSync(path)) {
+    const profilesPath = getProfilesPath();
+    if (!existsSync(profilesPath)) {
         return [];
     }
     try {
-        const data = readFileSync(path, 'utf-8');
-        return JSON.parse(data);
+        const data = readFileSync(profilesPath, 'utf-8');
+        const profilesFile = JSON.parse(data);
+        return profilesFile.profiles || [];
     }
-    catch (error) {
+    catch {
         return [];
     }
 }
 /**
- * Save profiles to disk
+ * Save c8ctl profiles to profiles.json
  */
 export function saveProfiles(profiles) {
-    const path = getProfilesPath();
-    writeFileSync(path, JSON.stringify(profiles, null, 2), 'utf-8');
+    const profilesPath = getProfilesPath();
+    const profilesFile = { profiles };
+    writeFileSync(profilesPath, JSON.stringify(profilesFile, null, 2), 'utf-8');
 }
 /**
- * Get a profile by name
- * Supports both c8ctl profiles and modeler profiles (with 'modeler:' prefix)
+ * Get a c8ctl profile by name
  */
 export function getProfile(name) {
-    // Check if this is a modeler profile request
-    if (name.startsWith('modeler:')) {
-        const modelerProfile = getModelerProfile(name);
-        if (modelerProfile) {
-            return convertModelerProfile(modelerProfile);
-        }
-        return undefined;
-    }
-    // Check c8ctl profiles
     const profiles = loadProfiles();
     return profiles.find(p => p.name === name);
 }
 /**
- * Add or update a profile
+ * Add a c8ctl profile
  */
 export function addProfile(profile) {
     const profiles = loadProfiles();
+    // Check if profile already exists
     const existingIndex = profiles.findIndex(p => p.name === profile.name);
     if (existingIndex >= 0) {
         profiles[existingIndex] = profile;
@@ -117,25 +200,192 @@ export function addProfile(profile) {
     saveProfiles(profiles);
 }
 /**
- * Remove a profile
+ * Remove a c8ctl profile by name
  */
 export function removeProfile(name) {
     const profiles = loadProfiles();
     const filtered = profiles.filter(p => p.name !== name);
     if (filtered.length === profiles.length) {
-        return false; // Profile not found
+        return false;
     }
     saveProfiles(filtered);
     return true;
 }
+// ============================================================================
+// Modeler Connection Management - READ-ONLY from settings.json
+// ============================================================================
+export const MODELER_PREFIX = 'modeler:';
+/**
+ * Load connections from Modeler's settings.json (read-only)
+ * These are NOT modified by c8ctl
+ */
+export function loadModelerConnections() {
+    const settingsPath = getModelerSettingsPath();
+    if (!existsSync(settingsPath)) {
+        return [];
+    }
+    try {
+        const data = readFileSync(settingsPath, 'utf-8');
+        const settings = JSON.parse(data);
+        const connections = settings['connectionManagerPlugin.c8connections'];
+        if (!connections || !Array.isArray(connections)) {
+            return [];
+        }
+        // Filter out invalid connections (must have id)
+        return connections.filter(c => c && c.id);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get all profiles including c8ctl profiles and Modeler connections
+ * Modeler connections are prefixed with "modeler:"
+ */
+export function getAllProfiles() {
+    const c8ctlProfiles = loadProfiles();
+    const modelerConnections = loadModelerConnections();
+    // Convert Modeler connections to Profile format with "modeler:" prefix
+    const modelerProfiles = modelerConnections.map(connectionToProfile).map(p => ({
+        ...p,
+        name: `${MODELER_PREFIX}${p.name}`,
+    }));
+    return [...c8ctlProfiles, ...modelerProfiles];
+}
+/**
+ * Get a profile by name, checking both c8ctl and Modeler sources
+ * For Modeler profiles, accepts name with or without "modeler:" prefix
+ */
+export function getProfileOrModeler(name) {
+    // Try c8ctl profiles first
+    const c8ctlProfile = getProfile(name);
+    if (c8ctlProfile) {
+        return c8ctlProfile;
+    }
+    // Try Modeler connections (with or without prefix)
+    const modelerName = name.startsWith(MODELER_PREFIX) ? name.slice(MODELER_PREFIX.length) : name;
+    const modelerConnections = loadModelerConnections();
+    const modelerConnection = modelerConnections.find(c => c.name === modelerName || c.id === modelerName);
+    if (modelerConnection) {
+        const profile = connectionToProfile(modelerConnection);
+        return {
+            ...profile,
+            name: `${MODELER_PREFIX}${profile.name}`,
+        };
+    }
+    return undefined;
+}
+// ============================================================================
+// Conversion Utilities
+// ============================================================================
+/**
+ * Convert a Connection to ClusterConfig for API client use
+ */
+export function connectionToClusterConfig(conn) {
+    if (conn.targetType === TARGET_TYPES.CAMUNDA_CLOUD) {
+        return {
+            baseUrl: conn.camundaCloudClusterUrl || '',
+            clientId: conn.camundaCloudClientId,
+            clientSecret: conn.camundaCloudClientSecret,
+            audience: conn.camundaCloudClusterUrl, // Cloud uses URL as audience
+            oAuthUrl: 'https://login.cloud.camunda.io/oauth/token',
+        };
+    }
+    // Self-hosted
+    const config = {
+        baseUrl: conn.contactPoint || 'http://localhost:8080/v2',
+    };
+    if (conn.authType === AUTH_TYPES.BASIC) {
+        config.username = conn.basicAuthUsername;
+        config.password = conn.basicAuthPassword;
+    }
+    else if (conn.authType === AUTH_TYPES.OAUTH) {
+        config.clientId = conn.clientId;
+        config.clientSecret = conn.clientSecret;
+        config.oAuthUrl = conn.oauthURL;
+        config.audience = conn.audience;
+    }
+    return config;
+}
+/**
+ * Convert Connection to Profile format
+ * Used to convert read-only Modeler connections to c8ctl Profile format
+ */
+export function connectionToProfile(conn) {
+    const config = connectionToClusterConfig(conn);
+    return {
+        name: conn.name || conn.id,
+        baseUrl: config.baseUrl,
+        clientId: config.clientId,
+        clientSecret: config.clientSecret,
+        audience: config.audience,
+        oAuthUrl: config.oAuthUrl,
+        username: config.username,
+        password: config.password,
+        defaultTenantId: conn.tenantId,
+    };
+}
+/**
+ * Convert Profile to ClusterConfig for API client use
+ */
+export function profileToClusterConfig(profile) {
+    return {
+        baseUrl: profile.baseUrl,
+        clientId: profile.clientId,
+        clientSecret: profile.clientSecret,
+        audience: profile.audience,
+        oAuthUrl: profile.oAuthUrl,
+        username: profile.username,
+        password: profile.password,
+    };
+}
+/**
+ * Get display label for a connection
+ */
+export function getConnectionLabel(conn) {
+    if (conn.name) {
+        return conn.name;
+    }
+    // Fallback to URL-based label like Modeler does
+    const url = conn.targetType === TARGET_TYPES.CAMUNDA_CLOUD
+        ? conn.camundaCloudClusterUrl
+        : conn.contactPoint;
+    return url ? `Unnamed (${url})` : 'Unnamed connection';
+}
+/**
+ * Get auth type label for display
+ */
+export function getAuthTypeLabel(conn) {
+    if (conn.targetType === TARGET_TYPES.CAMUNDA_CLOUD) {
+        return 'OAuth (Cloud)';
+    }
+    switch (conn.authType) {
+        case AUTH_TYPES.BASIC:
+            return 'Basic';
+        case AUTH_TYPES.OAUTH:
+            return 'OAuth';
+        case AUTH_TYPES.NONE:
+        default:
+            return 'None';
+    }
+}
+/**
+ * Get target type label for display
+ */
+export function getTargetTypeLabel(conn) {
+    return conn.targetType === TARGET_TYPES.CAMUNDA_CLOUD
+        ? 'Camunda Cloud'
+        : 'Self-Hosted';
+}
+// ============================================================================
+// Session State Management
+// ============================================================================
 /**
  * Load session state from disk and populate c8ctl runtime object
- * Loads all session properties (activeProfile, activeTenant, outputMode)
  */
 export function loadSessionState() {
     const path = getSessionStatePath();
     if (!existsSync(path)) {
-        // Return default state if no session file exists
         return {
             activeProfile: c8ctl.activeProfile,
             activeTenant: c8ctl.activeTenant,
@@ -145,7 +395,6 @@ export function loadSessionState() {
     try {
         const data = readFileSync(path, 'utf-8');
         const state = JSON.parse(data);
-        // Populate c8ctl runtime with loaded state (convert null to undefined)
         c8ctl.activeProfile = state.activeProfile === null ? undefined : state.activeProfile;
         c8ctl.activeTenant = state.activeTenant === null ? undefined : state.activeTenant;
         c8ctl.outputMode = state.outputMode || 'text';
@@ -155,8 +404,7 @@ export function loadSessionState() {
             outputMode: c8ctl.outputMode,
         };
     }
-    catch (error) {
-        // Return current state if file is corrupted
+    catch {
         return {
             activeProfile: c8ctl.activeProfile,
             activeTenant: c8ctl.activeTenant,
@@ -166,7 +414,6 @@ export function loadSessionState() {
 }
 /**
  * Save session state from c8ctl runtime object to disk
- * Always persists all session properties (activeProfile, activeTenant, outputMode)
  */
 export function saveSessionState(state) {
     const stateToSave = {
@@ -174,18 +421,16 @@ export function saveSessionState(state) {
         activeTenant: state?.activeTenant ?? c8ctl.activeTenant,
         outputMode: state?.outputMode ?? c8ctl.outputMode,
     };
-    // Update c8ctl runtime if state is provided
     if (state) {
         c8ctl.activeProfile = state.activeProfile;
         c8ctl.activeTenant = state.activeTenant;
         c8ctl.outputMode = state.outputMode;
     }
     const path = getSessionStatePath();
-    // Use custom replacer to preserve undefined as null in JSON
-    writeFileSync(path, JSON.stringify(stateToSave, (key, value) => value === undefined ? null : value, 2), 'utf-8');
+    writeFileSync(path, JSON.stringify(stateToSave, (_, value) => (value === undefined ? null : value), 2), 'utf-8');
 }
 /**
- * Set active profile in session and persist to disk
+ * Set active profile/connection in session and persist to disk
  */
 export function setActiveProfile(name) {
     c8ctl.activeProfile = name;
@@ -205,46 +450,33 @@ export function setOutputMode(mode) {
     c8ctl.outputMode = mode;
     saveSessionState();
 }
+// ============================================================================
+// Cluster Configuration Resolution
+// ============================================================================
 /**
  * Resolve cluster configuration from session, flags, env vars, or defaults
  * Priority: profileFlag → session profile → env vars → localhost fallback
  */
 export function resolveClusterConfig(profileFlag) {
-    // 1. Try profile flag
+    // 1. Try profile flag (profile name, including modeler: prefix)
     if (profileFlag) {
-        const profile = getProfile(profileFlag);
+        const profile = getProfileOrModeler(profileFlag);
         if (profile) {
-            return {
-                baseUrl: profile.baseUrl,
-                clientId: profile.clientId,
-                clientSecret: profile.clientSecret,
-                audience: profile.audience,
-                oAuthUrl: profile.oAuthUrl,
-                username: profile.username,
-                password: profile.password,
-            };
+            return profileToClusterConfig(profile);
         }
     }
     // 2. Try session profile
     if (c8ctl.activeProfile) {
-        const profile = getProfile(c8ctl.activeProfile);
+        const profile = getProfileOrModeler(c8ctl.activeProfile);
         if (profile) {
-            return {
-                baseUrl: profile.baseUrl,
-                clientId: profile.clientId,
-                clientSecret: profile.clientSecret,
-                audience: profile.audience,
-                oAuthUrl: profile.oAuthUrl,
-                username: profile.username,
-                password: profile.password,
-            };
+            return profileToClusterConfig(profile);
         }
     }
     // 3. Try environment variables
     const baseUrl = process.env.CAMUNDA_BASE_URL;
     const clientId = process.env.CAMUNDA_CLIENT_ID;
     const clientSecret = process.env.CAMUNDA_CLIENT_SECRET;
-    const audience = process.env.CAMUNDA_AUDIENCE;
+    const audience = process.env.CAMUNDA_TOKEN_AUDIENCE;
     const oAuthUrl = process.env.CAMUNDA_OAUTH_URL;
     const username = process.env.CAMUNDA_USERNAME;
     const password = process.env.CAMUNDA_PASSWORD;
@@ -260,8 +492,6 @@ export function resolveClusterConfig(profileFlag) {
         };
     }
     // 4. Localhost fallback with basic auth (demo/demo)
-    // These default credentials match the docker-compose configuration
-    // and are intended for local development only
     return {
         baseUrl: 'http://localhost:8080/v2',
         username: 'demo',
@@ -270,7 +500,7 @@ export function resolveClusterConfig(profileFlag) {
 }
 /**
  * Resolve tenant ID from session, profile, env vars, or default
- * Priority: session tenant → profile default tenant → env var → '<default>'
+ * Priority: session tenant → profile tenant → env var → '<default>'
  */
 export function resolveTenantId(profileFlag) {
     // 1. Try session tenant
@@ -280,7 +510,7 @@ export function resolveTenantId(profileFlag) {
     // 2. Try profile default tenant (from flag or session)
     const profileName = profileFlag || c8ctl.activeProfile;
     if (profileName) {
-        const profile = getProfile(profileName);
+        const profile = getProfileOrModeler(profileName);
         if (profile?.defaultTenantId) {
             return profile.defaultTenantId;
         }
@@ -293,93 +523,4 @@ export function resolveTenantId(profileFlag) {
     // 4. Default tenant
     return '<default>';
 }
-/**
- * Load Camunda Modeler profiles from profiles.json
- * Always reads fresh from disk (no caching)
- *
- * TODO: Consider introducing caching mechanism for better performance.
- * Current implementation reads from disk on every call. For commands that
- * list profiles or look up multiple profiles, this could be optimized by
- * implementing per-execution memoization or a time-based cache.
- */
-export function loadModelerProfiles() {
-    try {
-        const modelerDir = getModelerDataDir();
-        const profilesPath = join(modelerDir, 'profiles.json');
-        if (!existsSync(profilesPath)) {
-            return [];
-        }
-        const data = readFileSync(profilesPath, 'utf-8');
-        const parsed = JSON.parse(data);
-        return parsed.profiles || [];
-    }
-    catch (error) {
-        // Silently return empty array if file can't be read or parsed
-        return [];
-    }
-}
-/**
- * Get a modeler profile by name or cluster ID
- * Accepts 'modeler:name' or 'modeler:id' format, or just 'name'/'id'
- */
-export function getModelerProfile(identifier) {
-    const profiles = loadModelerProfiles();
-    // Remove 'modeler:' prefix if present
-    const searchId = identifier.startsWith('modeler:')
-        ? identifier.substring(8)
-        : identifier;
-    // Search by name first, then by clusterId
-    return profiles.find(p => p.name === searchId || p.clusterId === searchId);
-}
-/**
- * Construct REST API URL from modeler profile
- * For cloud: uses clusterUrl as-is (Camunda cloud URLs don't need /v2)
- * For self-managed: localhost URLs get /v2 appended
- * Does not derive values - uses what's provided
- *
- * Note: Self-managed clusters should include /v2 in their clusterUrl if needed
- */
-export function constructApiUrl(profile) {
-    // If clusterUrl is provided, use it as the base
-    if (profile.clusterUrl) {
-        const url = profile.clusterUrl;
-        // If it already has /v2 endpoint, use as-is
-        if (url.includes('/v2')) {
-            return url;
-        }
-        // Only append /v2 for localhost URLs
-        // Self-managed clusters should include /v2 in their clusterUrl if needed
-        if (url.includes('localhost') || url.includes('127.0.0.1')) {
-            return `${url.replace(/\/$/, '')}/v2`;
-        }
-        // For all other URLs (including cloud), use as-is
-        return url;
-    }
-    // If no clusterUrl but have clusterId, construct cloud URL
-    if (profile.clusterId) {
-        // Cloud cluster URLs follow pattern: https://{clusterId}.{region}.zeebe.camunda.io
-        // We can't derive the region, so just use the clusterId as a fallback base
-        return `https://${profile.clusterId}.zeebe.camunda.io`;
-    }
-    // Fallback to localhost
-    return 'http://localhost:8080/v2';
-}
-/**
- * Convert a modeler profile to a c8ctl Profile
- */
-export function convertModelerProfile(modelerProfile) {
-    const name = modelerProfile.name || modelerProfile.clusterId || 'unknown';
-    const baseUrl = constructApiUrl(modelerProfile);
-    return {
-        name: `modeler:${name}`,
-        baseUrl,
-        clientId: modelerProfile.clientId,
-        clientSecret: modelerProfile.clientSecret,
-        audience: modelerProfile.audience,
-        // Cloud clusters typically use the standard OAuth URL
-        oAuthUrl: modelerProfile.audience ?
-            'https://login.cloud.camunda.io/oauth/token' :
-            undefined,
-    };
-}
 //# sourceMappingURL=config.js.map