confluence-cli 1.14.0 → 1.15.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [1.15.0](https://github.com/pchuri/confluence-cli/compare/v1.14.0...v1.15.0) (2026-02-06)
+
+
+### Features
+
+* Add CLI flags to confluence init for non-interactive setup ([#30](https://github.com/pchuri/confluence-cli/issues/30)) ([09b6b85](https://github.com/pchuri/confluence-cli/commit/09b6b85a243da5ab86eb61a1a2376a64ce6979c7))
+
 # [1.14.0](https://github.com/pchuri/confluence-cli/compare/v1.13.0...v1.14.0) (2026-02-03)
 
 

package/README.md

@@ -67,13 +67,45 @@ npx confluence-cli
 confluence init
 ```
 
-The wizard now helps you choose the right API endpoint and authentication method. It recommends `/wiki/rest/api` for Atlassian Cloud domains (e.g., `*.atlassian.net`) and `/rest/api` for self-hosted/Data Center instances, then prompts for Basic (email + token) or Bearer authentication.
+The wizard helps you choose the right API endpoint and authentication method. It recommends `/wiki/rest/api` for Atlassian Cloud domains (e.g., `*.atlassian.net`) and `/rest/api` for self-hosted/Data Center instances, then prompts for Basic (email + token) or Bearer authentication.
 
-### Option 2: Environment Variables
+### Option 2: Non-interactive Setup (CLI Flags)
+
+Provide all required configuration via command-line flags. Perfect for CI/CD pipelines, Docker builds, and AI coding agents.
+
+**Complete non-interactive mode** (all required fields provided):
+```bash
+confluence init \
+  --domain "company.atlassian.net" \
+  --api-path "/wiki/rest/api" \
+  --auth-type "basic" \
+  --email "user@example.com" \
+  --token "your-api-token"
+```
+
+**Hybrid mode** (some fields provided, rest via prompts):
+```bash
+# Domain and token provided, will prompt for auth method and email
+confluence init --domain "company.atlassian.net" --token "your-api-token"
+
+# Email indicates basic auth, will prompt for domain and token
+confluence init --email "user@example.com" --token "your-api-token"
+```
+
+**Available flags:**
+- `-d, --domain <domain>` - Confluence domain (e.g., `company.atlassian.net`)
+- `-p, --api-path <path>` - REST API path (e.g., `/wiki/rest/api`)
+- `-a, --auth-type <type>` - Authentication type: `basic` or `bearer`
+- `-e, --email <email>` - Email for basic authentication
+- `-t, --token <token>` - API token
+
+⚠️ **Security note:** While flags work, storing tokens in shell history is risky. Prefer environment variables (Option 3) for production environments.
+
+### Option 3: Environment Variables
 ```bash
 export CONFLUENCE_DOMAIN="your-domain.atlassian.net"
 export CONFLUENCE_API_TOKEN="your-api-token"
-export CONFLUENCE_EMAIL="your.email@example.com"  # required when using Atlassian Cloud
+export CONFLUENCE_EMAIL="your.email@example.com"  # required when using basic auth
 export CONFLUENCE_API_PATH="/wiki/rest/api"         # Cloud default; use /rest/api for Server/DC
 # Optional: set to 'bearer' for self-hosted/Data Center instances
 export CONFLUENCE_AUTH_TYPE="basic"

package/bin/confluence.js

@@ -17,8 +17,13 @@ program
 program
   .command('init')
   .description('Initialize Confluence CLI configuration')
-  .action(async () => {
-    await initConfig();
+  .option('-d, --domain <domain>', 'Confluence domain')
+  .option('-p, --api-path <path>', 'REST API path')
+  .option('-a, --auth-type <type>', 'Authentication type (basic or bearer)')
+  .option('-e, --email <email>', 'Email for basic auth')
+  .option('-t, --token <token>', 'API token')
+  .action(async (options) => {
+    await initConfig(options);
   });
 
 // Read command

package/lib/config.js

@@ -55,22 +55,90 @@ const normalizeApiPath = (rawValue, domain) => {
   return withoutTrailing || inferApiPath(domain);
 };
 
-async function initConfig() {
-  console.log(chalk.blue('🚀 Confluence CLI Configuration'));
-  console.log('Please provide your Confluence connection details:\n');
+// Helper function to validate CLI-provided options
+const validateCliOptions = (options) => {
+  const errors = [];
 
-  const answers = await inquirer.prompt([
-    {
+  if (options.domain && !options.domain.trim()) {
+    errors.push('--domain cannot be empty');
+  }
+
+  if (options.token && !options.token.trim()) {
+    errors.push('--token cannot be empty');
+  }
+
+  if (options.email && !options.email.trim()) {
+    errors.push('--email cannot be empty');
+  }
+
+  if (options.apiPath) {
+    if (!options.apiPath.startsWith('/')) {
+      errors.push('--api-path must start with "/"');
+    } else {
+      // Validate API path format
+      try {
+        normalizeApiPath(options.apiPath, options.domain || 'example.com');
+      } catch (error) {
+        errors.push(`--api-path is invalid: ${error.message}`);
+      }
+    }
+  }
+
+  if (options.authType && !['basic', 'bearer'].includes(options.authType.toLowerCase())) {
+    errors.push('--auth-type must be "basic" or "bearer"');
+  }
+
+  // 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');
+  }
+
+  return errors;
+};
+
+// Helper function to save configuration with validation
+const saveConfig = (configData) => {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+
+  const config = {
+    domain: configData.domain.trim(),
+    apiPath: normalizeApiPath(configData.apiPath, configData.domain),
+    token: configData.token.trim(),
+    authType: configData.authType,
+    email: configData.authType === 'basic' && configData.email ? configData.email.trim() : undefined
+  };
+
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+
+  console.log(chalk.green('✅ Configuration saved successfully!'));
+  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"'));
+};
+
+// Helper function to prompt for missing values
+const promptForMissingValues = async (providedValues) => {
+  const questions = [];
+
+  // Domain question
+  if (!providedValues.domain) {
+    questions.push({
       type: 'input',
       name: 'domain',
       message: 'Confluence domain (e.g., yourcompany.atlassian.net):',
       validate: requiredInput('Domain')
-    },
-    {
+    });
+  }
+
+  // API Path question
+  if (!providedValues.apiPath) {
+    questions.push({
       type: 'input',
       name: 'apiPath',
       message: 'REST API path (Cloud: /wiki/rest/api, Server: /rest/api):',
-      default: (responses) => inferApiPath(responses.domain),
+      default: (responses) => inferApiPath(providedValues.domain || responses.domain),
       validate: (input, responses) => {
         const value = (input || '').trim();
         if (!value) {
@@ -80,52 +148,205 @@ async function initConfig() {
           return 'API path must start with "/"';
         }
         try {
-          normalizeApiPath(value, responses.domain);
+          const domain = providedValues.domain || responses.domain;
+          normalizeApiPath(value, domain);
           return true;
         } catch (error) {
           return error.message;
         }
       }
-    },
-    {
+    });
+  }
+
+  // Auth Type question
+  const hasEmail = Boolean(providedValues.email);
+  if (!providedValues.authType) {
+    questions.push({
       type: 'list',
       name: 'authType',
       message: 'Authentication method:',
       choices: AUTH_CHOICES,
-      default: 'basic'
-    },
-    {
+      default: hasEmail ? 'basic' : 'bearer'
+    });
+  }
+
+  // Email question (conditional on authType)
+  if (!providedValues.email) {
+    questions.push({
       type: 'input',
       name: 'email',
       message: 'Confluence email (used with API token):',
-      when: (responses) => responses.authType === 'basic',
+      when: (responses) => {
+        const authType = providedValues.authType || responses.authType;
+        return authType === 'basic';
+      },
       validate: requiredInput('Email')
-    },
-    {
+    });
+  }
+
+  // Token question
+  if (!providedValues.token) {
+    questions.push({
       type: 'password',
       name: 'token',
       message: 'API Token:',
       validate: requiredInput('API Token')
-    }
-  ]);
+    });
+  }
 
-  if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  if (questions.length === 0) {
+    return providedValues;
   }
 
-  const config = {
-    domain: answers.domain.trim(),
-    apiPath: normalizeApiPath(answers.apiPath, answers.domain),
-    token: answers.token.trim(),
-    authType: answers.authType,
-    email: answers.authType === 'basic' ? answers.email.trim() : undefined
+  const answers = await inquirer.prompt(questions);
+  return { ...providedValues, ...answers };
+};
+
+async function initConfig(cliOptions = {}) {
+  // Extract provided values from CLI options
+  const providedValues = {
+    domain: cliOptions.domain,
+    apiPath: cliOptions.apiPath,
+    authType: cliOptions.authType,
+    email: cliOptions.email,
+    token: cliOptions.token
   };
 
-  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+  // Check if any CLI options were provided
+  const hasCliOptions = Object.values(providedValues).some(v => v);
 
-  console.log(chalk.green('✅ Configuration saved successfully!'));
-  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"'));
+  if (!hasCliOptions) {
+    // Interactive mode: no CLI options provided
+    console.log(chalk.blue('🚀 Confluence CLI Configuration'));
+    console.log('Please provide your Confluence connection details:\n');
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'domain',
+        message: 'Confluence domain (e.g., yourcompany.atlassian.net):',
+        validate: requiredInput('Domain')
+      },
+      {
+        type: 'input',
+        name: 'apiPath',
+        message: 'REST API path (Cloud: /wiki/rest/api, Server: /rest/api):',
+        default: (responses) => inferApiPath(responses.domain),
+        validate: (input, responses) => {
+          const value = (input || '').trim();
+          if (!value) {
+            return true;
+          }
+          if (!value.startsWith('/')) {
+            return 'API path must start with "/"';
+          }
+          try {
+            normalizeApiPath(value, responses.domain);
+            return true;
+          } catch (error) {
+            return error.message;
+          }
+        }
+      },
+      {
+        type: 'list',
+        name: 'authType',
+        message: 'Authentication method:',
+        choices: AUTH_CHOICES,
+        default: 'basic'
+      },
+      {
+        type: 'input',
+        name: 'email',
+        message: 'Confluence email (used with API token):',
+        when: (responses) => responses.authType === 'basic',
+        validate: requiredInput('Email')
+      },
+      {
+        type: 'password',
+        name: 'token',
+        message: 'API Token:',
+        validate: requiredInput('API Token')
+      }
+    ]);
+
+    saveConfig(answers);
+    return;
+  }
+
+  // Non-interactive or hybrid mode: CLI options provided
+  // Validate provided options
+  const validationErrors = validateCliOptions(providedValues);
+  if (validationErrors.length > 0) {
+    console.error(chalk.red('❌ Configuration Error:'));
+    validationErrors.forEach(error => {
+      console.error(chalk.red(`  • ${error}`));
+    });
+    process.exit(1);
+  }
+
+  // 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.authType || providedValues.email)
+  );
+
+  if (hasRequiredValues) {
+    // Non-interactive mode: all required values provided
+    try {
+      // Infer authType if not provided
+      let inferredAuthType = providedValues.authType;
+      if (!inferredAuthType) {
+        inferredAuthType = providedValues.email ? 'basic' : 'bearer';
+      }
+
+      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'));
+        process.exit(1);
+      }
+
+      // Verify API path format if provided
+      if (providedValues.apiPath) {
+        normalizeApiPath(providedValues.apiPath, normalizedDomain);
+      }
+
+      const configData = {
+        domain: normalizedDomain,
+        apiPath: providedValues.apiPath || inferApiPath(normalizedDomain),
+        token: providedValues.token,
+        authType: normalizedAuthType,
+        email: providedValues.email
+      };
+
+      saveConfig(configData);
+    } catch (error) {
+      console.error(chalk.red(`❌ ${error.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Hybrid mode: some values provided, prompt for the rest
+  try {
+    console.log(chalk.blue('🚀 Confluence CLI Configuration'));
+    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);
+  } catch (error) {
+    console.error(chalk.red(`❌ ${error.message}`));
+    process.exit(1);
+  }
 }
 
 function getConfig() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "confluence-cli",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "description": "A command-line interface for Atlassian Confluence with page creation and editing capabilities",
   "main": "index.js",
   "bin": {