confluence-cli 1.6.0 → 1.8.0

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+# [1.8.0](https://github.com/pchuri/confluence-cli/compare/v1.7.0...v1.8.0) (2025-09-28)
+
+
+### Features
+
+* make Confluence API path configurable ([#14](https://github.com/pchuri/confluence-cli/issues/14)) ([be000e0](https://github.com/pchuri/confluence-cli/commit/be000e0d92881d65329b84bad6555dcad0bbb455)), closes [#13](https://github.com/pchuri/confluence-cli/issues/13)
+
+## [Unreleased]
+
+### Added
+- Make the Confluence REST base path configurable to support both `/rest/api` and `/wiki/rest/api`.
+
+# [1.7.0](https://github.com/pchuri/confluence-cli/compare/v1.6.0...v1.7.0) (2025-09-28)
+
+
+### Features
+
+* support basic auth for Atlassian API tokens ([#12](https://github.com/pchuri/confluence-cli/issues/12)) ([e80ea9b](https://github.com/pchuri/confluence-cli/commit/e80ea9b7913d5f497b60bf72149737b6f704c6b8))
+
 # [1.6.0](https://github.com/pchuri/confluence-cli/compare/v1.5.0...v1.6.0) (2025-09-05)
 
 

package/README.md

@@ -58,12 +58,20 @@ 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.
+
 ### Option 2: 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_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"
 ```
 
+`CONFLUENCE_API_PATH` defaults to `/wiki/rest/api` for Atlassian Cloud domains and `/rest/api` otherwise. Override it when your site lives under a custom reverse proxy or on-premises path. `CONFLUENCE_AUTH_TYPE` defaults to `basic` when an email is present and falls back to `bearer` otherwise.
+
 ### Getting Your API Token
 
 1. Go to [Atlassian Account Settings](https://id.atlassian.com/manage-profile/security/api-tokens)

package/lib/config.js

@@ -7,9 +7,54 @@ const chalk = require('chalk');
 const CONFIG_DIR = path.join(os.homedir(), '.confluence-cli');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 
-/**
- * Initialize configuration
- */
+const AUTH_CHOICES = [
+  { name: 'Basic (email + API token)', value: 'basic' },
+  { name: 'Bearer token', value: 'bearer' }
+];
+
+const requiredInput = (label) => (input) => {
+  if (!input || !input.trim()) {
+    return `${label} is required`;
+  }
+  return true;
+};
+
+const normalizeAuthType = (rawValue, hasEmail) => {
+  const normalized = (rawValue || '').trim().toLowerCase();
+  if (normalized === 'basic' || normalized === 'bearer') {
+    return normalized;
+  }
+  return hasEmail ? 'basic' : 'bearer';
+};
+
+const inferApiPath = (domain) => {
+  if (!domain) {
+    return '/rest/api';
+  }
+
+  const normalizedDomain = domain.trim().toLowerCase();
+  if (normalizedDomain.endsWith('.atlassian.net')) {
+    return '/wiki/rest/api';
+  }
+
+  return '/rest/api';
+};
+
+const normalizeApiPath = (rawValue, domain) => {
+  const trimmed = (rawValue || '').trim();
+
+  if (!trimmed) {
+    return inferApiPath(domain);
+  }
+
+  if (!trimmed.startsWith('/')) {
+    throw new Error('Confluence API path must start with "/".');
+  }
+
+  const withoutTrailing = trimmed.replace(/\/+$/, '');
+  return withoutTrailing || inferApiPath(domain);
+};
+
 async function initConfig() {
   console.log(chalk.blue('🚀 Confluence CLI Configuration'));
   console.log('Please provide your Confluence connection details:\n');
@@ -19,70 +64,145 @@ async function initConfig() {
       type: 'input',
       name: 'domain',
       message: 'Confluence domain (e.g., yourcompany.atlassian.net):',
-      validate: (input) => {
-        if (!input.trim()) {
-          return 'Domain is required';
+      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;
         }
-        return true;
       }
     },
+    {
+      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: (input) => {
-        if (!input.trim()) {
-          return 'API Token is required';
-        }
-        return true;
-      }
+      validate: requiredInput('API Token')
     }
   ]);
 
-  // Create config directory if it doesn't exist
   if (!fs.existsSync(CONFIG_DIR)) {
     fs.mkdirSync(CONFIG_DIR, { recursive: true });
   }
 
-  // Save configuration
   const config = {
     domain: answers.domain.trim(),
-    token: answers.token.trim()
+    apiPath: normalizeApiPath(answers.apiPath, answers.domain),
+    token: answers.token.trim(),
+    authType: answers.authType,
+    email: answers.authType === 'basic' ? answers.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"'));
 }
 
-/**
- * Get configuration
- */
 function getConfig() {
-  // First check for environment variables
   const envDomain = process.env.CONFLUENCE_DOMAIN || process.env.CONFLUENCE_HOST;
   const envToken = process.env.CONFLUENCE_API_TOKEN;
+  const envEmail = process.env.CONFLUENCE_EMAIL;
+  const envAuthType = process.env.CONFLUENCE_AUTH_TYPE;
+  const envApiPath = process.env.CONFLUENCE_API_PATH;
 
   if (envDomain && envToken) {
+    const authType = normalizeAuthType(envAuthType, Boolean(envEmail));
+    let apiPath;
+
+    try {
+      apiPath = normalizeApiPath(envApiPath, envDomain);
+    } catch (error) {
+      console.error(chalk.red(`❌ ${error.message}`));
+      process.exit(1);
+    }
+
+    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.'));
+      process.exit(1);
+    }
+
     return {
-      domain: envDomain,
-      token: envToken
+      domain: envDomain.trim(),
+      apiPath,
+      token: envToken.trim(),
+      email: envEmail ? envEmail.trim() : undefined,
+      authType
     };
   }
 
-  // Check for config file
   if (!fs.existsSync(CONFIG_FILE)) {
     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 and CONFLUENCE_API_TOKEN'));
+    console.log(chalk.gray('Or set environment variables: CONFLUENCE_DOMAIN, CONFLUENCE_API_TOKEN, CONFLUENCE_EMAIL, and optionally CONFLUENCE_API_PATH.'));
     process.exit(1);
   }
 
   try {
-    const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
-    return config;
+    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;
+    const authType = normalizeAuthType(storedConfig.authType, Boolean(trimmedEmail));
+    let apiPath;
+
+    if (!trimmedDomain || !trimmedToken) {
+      console.error(chalk.red('❌ Configuration file is missing required values.'));
+      console.log(chalk.yellow('Run "confluence init" to refresh your settings.'));
+      process.exit(1);
+    }
+
+    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.'));
+      process.exit(1);
+    }
+
+    try {
+      apiPath = normalizeApiPath(storedConfig.apiPath, trimmedDomain);
+    } catch (error) {
+      console.error(chalk.red(`❌ ${error.message}`));
+      console.log(chalk.yellow('Please rerun "confluence init" to update your API path.'));
+      process.exit(1);
+    }
+
+    return {
+      domain: trimmedDomain,
+      apiPath,
+      token: trimmedToken,
+      email: trimmedEmail,
+      authType
+    };
   } catch (error) {
     console.error(chalk.red('❌ Error reading configuration file:'), error.message);
     console.log(chalk.yellow('Please run "confluence init" to recreate your configuration.'));

package/lib/confluence-client.js

@@ -4,21 +4,48 @@ const MarkdownIt = require('markdown-it');
 
 class ConfluenceClient {
   constructor(config) {
-    this.baseURL = `https://${config.domain}/rest/api`;
-    this.token = config.token;
     this.domain = config.domain;
+    this.token = config.token;
+    this.email = config.email;
+    this.authType = (config.authType || (this.email ? 'basic' : 'bearer')).toLowerCase();
+    this.apiPath = this.sanitizeApiPath(config.apiPath);
+    this.baseURL = `https://${this.domain}${this.apiPath}`;
     this.markdown = new MarkdownIt();
     this.setupConfluenceMarkdownExtensions();
-    
+
+    const headers = {
+      'Content-Type': 'application/json',
+      'Authorization': this.authType === 'basic' ? this.buildBasicAuthHeader() : `Bearer ${this.token}`
+    };
+
     this.client = axios.create({
       baseURL: this.baseURL,
-      headers: {
-        'Authorization': `Bearer ${this.token}`,
-        'Content-Type': 'application/json'
-      }
+      headers
     });
   }
 
+  sanitizeApiPath(rawPath) {
+    const fallback = '/rest/api';
+    const value = (rawPath || '').trim();
+
+    if (!value) {
+      return fallback;
+    }
+
+    const withoutLeading = value.replace(/^\/+/, '');
+    const normalized = `/${withoutLeading}`.replace(/\/+$/, '');
+    return normalized || fallback;
+  }
+
+  buildBasicAuthHeader() {
+    if (!this.email) {
+      throw new Error('Basic authentication requires an email address.');
+    }
+
+    const encodedCredentials = Buffer.from(`${this.email}:${this.token}`).toString('base64');
+    return `Basic ${encodedCredentials}`;
+  }
+
   /**
    * Extract page ID from URL or return the ID if it's already a number
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "confluence-cli",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "A command-line interface for Atlassian Confluence with page creation and editing capabilities",
   "main": "index.js",
   "bin": {
@@ -22,7 +22,7 @@
   "author": "pchuri",
   "license": "MIT",
   "dependencies": {
-    "axios": "^1.6.2",
+    "axios": "^1.12.0",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "html-to-text": "^9.0.5",

package/tests/confluence-client.test.js

@@ -10,6 +10,58 @@ describe('ConfluenceClient', () => {
     });
   });
 
+  describe('api path handling', () => {
+    test('defaults to /rest/api when path is not provided', () => {
+      const defaultClient = new ConfluenceClient({
+        domain: 'example.com',
+        token: 'no-path-token'
+      });
+
+      expect(defaultClient.baseURL).toBe('https://example.com/rest/api');
+    });
+
+    test('normalizes custom api paths', () => {
+      const customClient = new ConfluenceClient({
+        domain: 'cloud.example',
+        token: 'custom-path',
+        apiPath: 'wiki/rest/api/'
+      });
+
+      expect(customClient.baseURL).toBe('https://cloud.example/wiki/rest/api');
+    });
+  });
+
+  describe('authentication setup', () => {
+    test('uses bearer token headers by default', () => {
+      const bearerClient = new ConfluenceClient({
+        domain: 'test.atlassian.net',
+        token: 'bearer-token'
+      });
+
+      expect(bearerClient.client.defaults.headers.Authorization).toBe('Bearer bearer-token');
+    });
+
+    test('builds basic auth headers when email is provided', () => {
+      const basicClient = new ConfluenceClient({
+        domain: 'test.atlassian.net',
+        token: 'basic-token',
+        authType: 'basic',
+        email: 'user@example.com'
+      });
+
+      const encoded = Buffer.from('user@example.com:basic-token').toString('base64');
+      expect(basicClient.client.defaults.headers.Authorization).toBe(`Basic ${encoded}`);
+    });
+
+    test('throws when basic auth is missing an email', () => {
+      expect(() => new ConfluenceClient({
+        domain: 'test.atlassian.net',
+        token: 'missing-email',
+        authType: 'basic'
+      })).toThrow('Basic authentication requires an email address.');
+    });
+  });
+
   describe('extractPageId', () => {
     test('should return numeric page ID as is', () => {
       expect(client.extractPageId('123456789')).toBe('123456789');