@bestend/confluence-cli 1.16.0 → 2.0.0

package/bin/index.js

@@ -21,4 +21,9 @@ if (!nodeVersion.startsWith('v') ||
 }
 
 // Load the main CLI application
-require('./confluence.js');
+const { program } = require('./confluence.js');
+
+if (process.argv.length <= 2) {
+  program.help({ error: false });
+}
+program.parse(process.argv);

package/lib/config.js

@@ -6,12 +6,15 @@ const chalk = require('chalk');
 
 const CONFIG_DIR = path.join(os.homedir(), '.confluence-cli');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const DEFAULT_PROFILE = 'default';
 
 const AUTH_CHOICES = [
-  { name: 'Basic (email + API token)', value: 'basic' },
+  { name: 'Basic (credentials)', value: 'basic' },
   { name: 'Bearer token', value: 'bearer' }
 ];
 
+const isValidProfileName = (name) => /^[a-zA-Z0-9_-]+$/.test(name);
+
 const requiredInput = (label) => (input) => {
   if (!input || !input.trim()) {
     return `${label} is required`;
@@ -19,6 +22,19 @@ const requiredInput = (label) => (input) => {
   return true;
 };
 
+const PROTOCOL_CHOICES = [
+  { name: 'HTTPS (recommended)', value: 'https' },
+  { name: 'HTTP', value: 'http' }
+];
+
+const normalizeProtocol = (rawValue) => {
+  const normalized = (rawValue || '').trim().toLowerCase();
+  if (normalized === 'http' || normalized === 'https') {
+    return normalized;
+  }
+  return 'https';
+};
+
 const normalizeAuthType = (rawValue, hasEmail) => {
   const normalized = (rawValue || '').trim().toLowerCase();
   if (normalized === 'basic' || normalized === 'bearer') {
@@ -55,6 +71,50 @@ const normalizeApiPath = (rawValue, domain) => {
   return withoutTrailing || inferApiPath(domain);
 };
 
+// Read config file with backward compatibility for old flat format
+function readConfigFile() {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return null;
+  }
+
+  try {
+    const raw = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+
+    // Detect old flat format (has domain at top level, no profiles key)
+    if (raw.domain && !raw.profiles) {
+      const profile = {
+        domain: raw.domain,
+        protocol: raw.protocol,
+        apiPath: raw.apiPath,
+        token: raw.token,
+        authType: raw.authType
+      };
+      if (raw.email) {
+        profile.email = raw.email;
+      }
+      return {
+        activeProfile: DEFAULT_PROFILE,
+        profiles: { [DEFAULT_PROFILE]: profile }
+      };
+    }
+
+    return raw;
+  } catch {
+    return null;
+  }
+}
+
+// Write the full multi-profile config structure
+function saveConfigFile(data) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  } else {
+    fs.chmodSync(CONFIG_DIR, 0o700);
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
+  fs.chmodSync(CONFIG_FILE, 0o600);
+}
+
 // Helper function to validate CLI-provided options
 const validateCliOptions = (options) => {
   const errors = [];
@@ -84,6 +144,10 @@ const validateCliOptions = (options) => {
     }
   }
 
+  if (options.protocol && !['http', 'https'].includes(options.protocol.toLowerCase())) {
+    errors.push('--protocol must be "http" or "https"');
+  }
+
   if (options.authType && !['basic', 'bearer'].includes(options.authType.toLowerCase())) {
     errors.push('--auth-type must be "basic" or "bearer"');
   }
@@ -91,29 +155,47 @@ const validateCliOptions = (options) => {
   // Check if basic auth is provided with email
   const normAuthType = options.authType ? normalizeAuthType(options.authType, Boolean(options.email)) : null;
   if (normAuthType === 'basic' && !options.email) {
-    errors.push('--email is required when using basic authentication');
+    errors.push('--email is required when using basic authentication (use your username for on-premise)');
   }
 
   return errors;
 };
 
 // Helper function to save configuration with validation
-const saveConfig = (configData) => {
-  if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-  }
-
+const saveConfig = (configData, profileName) => {
   const config = {
     domain: configData.domain.trim(),
+    protocol: normalizeProtocol(configData.protocol),
     apiPath: normalizeApiPath(configData.apiPath, configData.domain),
     token: configData.token.trim(),
-    authType: configData.authType,
-    email: configData.authType === 'basic' && configData.email ? configData.email.trim() : undefined
+    authType: configData.authType
   };
 
-  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+  if (configData.authType === 'basic' && configData.email) {
+    config.email = configData.email.trim();
+  }
+
+  if (configData.readOnly) {
+    config.readOnly = true;
+  }
+
+  // Read existing config file (or create new structure)
+  const fileData = readConfigFile() || { activeProfile: DEFAULT_PROFILE, profiles: {} };
+
+  const targetProfile = profileName || fileData.activeProfile || DEFAULT_PROFILE;
+  fileData.profiles[targetProfile] = config;
+
+  // If this is the first profile, make it active
+  if (!fileData.activeProfile || !fileData.profiles[fileData.activeProfile]) {
+    fileData.activeProfile = targetProfile;
+  }
+
+  saveConfigFile(fileData);
 
   console.log(chalk.green('✅ Configuration saved successfully!'));
+  if (profileName) {
+    console.log(`Profile: ${chalk.cyan(targetProfile)}`);
+  }
   console.log(`Config file location: ${chalk.gray(CONFIG_FILE)}`);
   console.log(chalk.yellow('\n💡 Tip: You can regenerate this config anytime by running "confluence init"'));
 };
@@ -122,6 +204,17 @@ const saveConfig = (configData) => {
 const promptForMissingValues = async (providedValues) => {
   const questions = [];
 
+  // Protocol question
+  if (!providedValues.protocol) {
+    questions.push({
+      type: 'list',
+      name: 'protocol',
+      message: 'Protocol:',
+      choices: PROTOCOL_CHOICES,
+      default: 'https'
+    });
+  }
+
   // Domain question
   if (!providedValues.domain) {
     questions.push({
@@ -175,12 +268,12 @@ const promptForMissingValues = async (providedValues) => {
     questions.push({
       type: 'input',
       name: 'email',
-      message: 'Confluence email (used with API token):',
+      message: 'Email / username:',
       when: (responses) => {
         const authType = providedValues.authType || responses.authType;
         return authType === 'basic';
       },
-      validate: requiredInput('Email')
+      validate: requiredInput('Email / username')
     });
   }
 
@@ -189,8 +282,8 @@ const promptForMissingValues = async (providedValues) => {
     questions.push({
       type: 'password',
       name: 'token',
-      message: 'API Token:',
-      validate: requiredInput('API Token')
+      message: 'API token / password:',
+      validate: requiredInput('API token / password')
     });
   }
 
@@ -203,8 +296,19 @@ const promptForMissingValues = async (providedValues) => {
 };
 
 async function initConfig(cliOptions = {}) {
+  const profileName = cliOptions.profile;
+
+  // Validate profile name if provided
+  if (profileName && !isValidProfileName(profileName)) {
+    console.error(chalk.red('❌ Invalid profile name. Use only letters, numbers, hyphens, and underscores.'));
+    process.exit(1);
+  }
+
+  const readOnly = cliOptions.readOnly || false;
+
   // Extract provided values from CLI options
   const providedValues = {
+    protocol: cliOptions.protocol,
     domain: cliOptions.domain,
     apiPath: cliOptions.apiPath,
     authType: cliOptions.authType,
@@ -218,9 +322,19 @@ async function initConfig(cliOptions = {}) {
   if (!hasCliOptions) {
     // Interactive mode: no CLI options provided
     console.log(chalk.blue('🚀 Confluence CLI Configuration'));
+    if (profileName) {
+      console.log(`Profile: ${chalk.cyan(profileName)}`);
+    }
     console.log('Please provide your Confluence connection details:\n');
 
     const answers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'protocol',
+        message: 'Protocol:',
+        choices: PROTOCOL_CHOICES,
+        default: 'https'
+      },
       {
         type: 'input',
         name: 'domain',
@@ -258,19 +372,19 @@ async function initConfig(cliOptions = {}) {
       {
         type: 'input',
         name: 'email',
-        message: 'Confluence email (used with API token):',
+        message: 'Email / username:',
         when: (responses) => responses.authType === 'basic',
-        validate: requiredInput('Email')
+        validate: requiredInput('Email / username')
       },
       {
         type: 'password',
         name: 'token',
-        message: 'API Token:',
-        validate: requiredInput('API Token')
+        message: 'API token / password:',
+        validate: requiredInput('API token / password')
       }
     ]);
 
-    saveConfig(answers);
+    saveConfig({ ...answers, readOnly }, profileName);
     return;
   }
 
@@ -288,8 +402,8 @@ async function initConfig(cliOptions = {}) {
   // Check if all required values are provided for non-interactive mode
   // Non-interactive requires: domain, token, and either authType or email (for inference)
   const hasRequiredValues = Boolean(
-    providedValues.domain && 
-    providedValues.token && 
+    providedValues.domain &&
+    providedValues.token &&
     (providedValues.authType || providedValues.email)
   );
 
@@ -304,7 +418,7 @@ async function initConfig(cliOptions = {}) {
 
       const normalizedAuthType = normalizeAuthType(inferredAuthType, Boolean(providedValues.email));
       const normalizedDomain = providedValues.domain.trim();
-      
+
       // Verify basic auth has email
       if (normalizedAuthType === 'basic' && !providedValues.email) {
         console.error(chalk.red('❌ Email is required for basic authentication'));
@@ -318,13 +432,15 @@ async function initConfig(cliOptions = {}) {
 
       const configData = {
         domain: normalizedDomain,
+        protocol: normalizeProtocol(providedValues.protocol),
         apiPath: providedValues.apiPath || inferApiPath(normalizedDomain),
         token: providedValues.token,
         authType: normalizedAuthType,
-        email: providedValues.email
+        email: providedValues.email,
+        readOnly
       };
 
-      saveConfig(configData);
+      saveConfig(configData, profileName);
     } catch (error) {
       console.error(chalk.red(`❌ ${error.message}`));
       process.exit(1);
@@ -335,26 +451,31 @@ async function initConfig(cliOptions = {}) {
   // Hybrid mode: some values provided, prompt for the rest
   try {
     console.log(chalk.blue('🚀 Confluence CLI Configuration'));
+    if (profileName) {
+      console.log(`Profile: ${chalk.cyan(profileName)}`);
+    }
     console.log('Completing configuration with interactive prompts:\n');
 
     const mergedValues = await promptForMissingValues(providedValues);
-    
+
     // Normalize auth type
     mergedValues.authType = normalizeAuthType(mergedValues.authType, Boolean(mergedValues.email));
-    
-    saveConfig(mergedValues);
+
+    saveConfig({ ...mergedValues, readOnly }, profileName);
   } catch (error) {
     console.error(chalk.red(`❌ ${error.message}`));
     process.exit(1);
   }
 }
 
-function getConfig() {
+function getConfig(profileName) {
   const envDomain = process.env.CONFLUENCE_DOMAIN || process.env.CONFLUENCE_HOST;
-  const envToken = process.env.CONFLUENCE_API_TOKEN;
-  const envEmail = process.env.CONFLUENCE_EMAIL;
+  const envToken = process.env.CONFLUENCE_API_TOKEN || process.env.CONFLUENCE_PASSWORD;
+  const envEmail = process.env.CONFLUENCE_EMAIL || process.env.CONFLUENCE_USERNAME;
   const envAuthType = process.env.CONFLUENCE_AUTH_TYPE;
   const envApiPath = process.env.CONFLUENCE_API_PATH;
+  const envProtocol = process.env.CONFLUENCE_PROTOCOL;
+  const envReadOnly = process.env.CONFLUENCE_READ_ONLY;
 
   if (envDomain && envToken) {
     const authType = normalizeAuthType(envAuthType, Boolean(envEmail));
@@ -368,29 +489,50 @@ function getConfig() {
     }
 
     if (authType === 'basic' && !envEmail) {
-      console.error(chalk.red('❌ Basic authentication requires CONFLUENCE_EMAIL.'));
-      console.log(chalk.yellow('Set CONFLUENCE_EMAIL or switch to bearer auth by setting CONFLUENCE_AUTH_TYPE=bearer.'));
+      console.error(chalk.red('❌ Basic authentication requires CONFLUENCE_EMAIL or CONFLUENCE_USERNAME.'));
+      console.log(chalk.yellow('Set CONFLUENCE_EMAIL (or CONFLUENCE_USERNAME for on-premise) or switch to bearer auth by setting CONFLUENCE_AUTH_TYPE=bearer.'));
       process.exit(1);
     }
 
     return {
       domain: envDomain.trim(),
+      protocol: normalizeProtocol(envProtocol),
       apiPath,
       token: envToken.trim(),
       email: envEmail ? envEmail.trim() : undefined,
-      authType
+      authType,
+      readOnly: envReadOnly === 'true'
     };
   }
 
-  if (!fs.existsSync(CONFIG_FILE)) {
+  // Resolve profile: explicit param > CONFLUENCE_PROFILE env var > activeProfile > default
+  const resolvedProfileName = profileName
+    || process.env.CONFLUENCE_PROFILE
+    || null;
+
+  const fileData = readConfigFile();
+
+  if (!fileData) {
     console.error(chalk.red('❌ No configuration found!'));
     console.log(chalk.yellow('Please run "confluence init" to set up your configuration.'));
-    console.log(chalk.gray('Or set environment variables: CONFLUENCE_DOMAIN, CONFLUENCE_API_TOKEN, CONFLUENCE_EMAIL, and optionally CONFLUENCE_API_PATH.'));
+    console.log(chalk.gray('Or set environment variables: CONFLUENCE_DOMAIN, CONFLUENCE_API_TOKEN (or CONFLUENCE_PASSWORD), CONFLUENCE_EMAIL (or CONFLUENCE_USERNAME), and optionally CONFLUENCE_API_PATH, CONFLUENCE_PROTOCOL.'));
+    process.exit(1);
+  }
+
+  const targetProfile = resolvedProfileName || fileData.activeProfile || DEFAULT_PROFILE;
+  const storedConfig = fileData.profiles && fileData.profiles[targetProfile];
+
+  if (!storedConfig) {
+    console.error(chalk.red(`❌ Profile "${targetProfile}" not found!`));
+    const available = fileData.profiles ? Object.keys(fileData.profiles) : [];
+    if (available.length > 0) {
+      console.log(chalk.yellow(`Available profiles: ${available.join(', ')}`));
+    }
+    console.log(chalk.yellow('Run "confluence init --profile <name>" to create it, or "confluence profile list" to see available profiles.'));
     process.exit(1);
   }
 
   try {
-    const storedConfig = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
     const trimmedDomain = (storedConfig.domain || '').trim();
     const trimmedToken = (storedConfig.token || '').trim();
     const trimmedEmail = storedConfig.email ? storedConfig.email.trim() : undefined;
@@ -404,8 +546,8 @@ function getConfig() {
     }
 
     if (authType === 'basic' && !trimmedEmail) {
-      console.error(chalk.red('❌ Basic authentication requires an email address.'));
-      console.log(chalk.yellow('Please rerun "confluence init" to add your Confluence email.'));
+      console.error(chalk.red('❌ Basic authentication requires an email address or username.'));
+      console.log(chalk.yellow('Please rerun "confluence init" to add your Confluence email or username.'));
       process.exit(1);
     }
 
@@ -417,12 +559,18 @@ function getConfig() {
       process.exit(1);
     }
 
+    const readOnly = envReadOnly !== undefined
+      ? envReadOnly === 'true'
+      : Boolean(storedConfig.readOnly);
+
     return {
       domain: trimmedDomain,
+      protocol: normalizeProtocol(storedConfig.protocol),
       apiPath,
       token: trimmedToken,
       email: trimmedEmail,
-      authType
+      authType,
+      readOnly
     };
   } catch (error) {
     console.error(chalk.red('❌ Error reading configuration file:'), error.message);
@@ -431,7 +579,61 @@ function getConfig() {
   }
 }
 
+function listProfiles() {
+  const fileData = readConfigFile();
+  if (!fileData || !fileData.profiles || Object.keys(fileData.profiles).length === 0) {
+    return { activeProfile: null, profiles: [] };
+  }
+  return {
+    activeProfile: fileData.activeProfile,
+    profiles: Object.keys(fileData.profiles).map(name => ({
+      name,
+      active: name === fileData.activeProfile,
+      domain: fileData.profiles[name].domain,
+      readOnly: Boolean(fileData.profiles[name].readOnly)
+    }))
+  };
+}
+
+function setActiveProfile(profileName) {
+  const fileData = readConfigFile();
+  if (!fileData) {
+    throw new Error('No configuration file found. Run "confluence init" first.');
+  }
+  if (!fileData.profiles || !fileData.profiles[profileName]) {
+    const available = fileData.profiles ? Object.keys(fileData.profiles) : [];
+    throw new Error(`Profile "${profileName}" not found. Available: ${available.join(', ')}`);
+  }
+  fileData.activeProfile = profileName;
+  saveConfigFile(fileData);
+}
+
+function deleteProfile(profileName) {
+  const fileData = readConfigFile();
+  if (!fileData) {
+    throw new Error('No configuration file found. Run "confluence init" first.');
+  }
+  if (!fileData.profiles || !fileData.profiles[profileName]) {
+    throw new Error(`Profile "${profileName}" not found.`);
+  }
+  if (Object.keys(fileData.profiles).length === 1) {
+    throw new Error('Cannot delete the only remaining profile.');
+  }
+  delete fileData.profiles[profileName];
+  if (fileData.activeProfile === profileName) {
+    fileData.activeProfile = Object.keys(fileData.profiles)[0];
+  }
+  saveConfigFile(fileData);
+}
+
 module.exports = {
   initConfig,
-  getConfig
+  getConfig,
+  listProfiles,
+  setActiveProfile,
+  deleteProfile,
+  isValidProfileName,
+  CONFIG_DIR,
+  CONFIG_FILE,
+  DEFAULT_PROFILE
 };