@bestend/confluence-cli 1.16.0 → 2.0.0

package/bin/confluence.js

@@ -4,26 +4,48 @@ const { program } = require('commander');
 const chalk = require('chalk');
 const inquirer = require('inquirer');
 const ConfluenceClient = require('../lib/confluence-client');
-const { getConfig, initConfig } = require('../lib/config');
+const { getConfig, initConfig, listProfiles, setActiveProfile, deleteProfile, isValidProfileName } = require('../lib/config');
 const Analytics = require('../lib/analytics');
 const pkg = require('../package.json');
 
+function buildPageUrl(config, path) {
+  const protocol = config.protocol || 'https';
+  return `${protocol}://${config.domain}${path}`;
+}
+
+function assertWritable(config) {
+  if (config.readOnly) {
+    console.error(chalk.red('Error: This profile is in read-only mode. Write operations are not allowed.'));
+    console.error(chalk.yellow('Tip: Use "confluence profile add <name>" without --read-only, or set readOnly to false in config.'));
+    process.exit(1);
+  }
+}
+
 program
   .name('confluence')
   .description('CLI tool for Atlassian Confluence')
-  .version(pkg.version);
+  .version(pkg.version)
+  .option('--profile <name>', 'Use a specific configuration profile');
+
+// Helper: resolve profile name from global --profile flag
+function getProfileName() {
+  return program.opts().profile || undefined;
+}
 
 // Init command
 program
   .command('init')
   .description('Initialize Confluence CLI configuration')
   .option('-d, --domain <domain>', 'Confluence domain')
+  .option('--protocol <protocol>', 'Protocol (http or https)')
   .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('-e, --email <email>', 'Email or username for basic auth')
   .option('-t, --token <token>', 'API token')
+  .option('--read-only', 'Set profile to read-only mode (blocks write operations)')
   .action(async (options) => {
-    await initConfig(options);
+    const profile = getProfileName();
+    await initConfig({ ...options, profile });
   });
 
 // Read command
@@ -34,7 +56,7 @@ program
   .action(async (pageId, options) => {
     const analytics = new Analytics();
     try {
-      const client = new ConfluenceClient(getConfig());
+      const client = new ConfluenceClient(getConfig(getProfileName()));
       const content = await client.readPage(pageId, options.format);
       console.log(content);
       analytics.track('read', true);
@@ -52,7 +74,7 @@ program
   .action(async (pageId) => {
     const analytics = new Analytics();
     try {
-      const client = new ConfluenceClient(getConfig());
+      const client = new ConfluenceClient(getConfig(getProfileName()));
       const info = await client.getPageInfo(pageId);
       console.log(chalk.blue('Page Information:'));
       console.log(`Title: ${chalk.green(info.title)}`);
@@ -75,11 +97,12 @@ program
   .command('search <query>')
   .description('Search for Confluence pages')
   .option('-l, --limit <limit>', 'Limit number of results', '10')
+  .option('--cql', 'Pass query as raw CQL instead of text search')
   .action(async (query, options) => {
     const analytics = new Analytics();
     try {
-      const client = new ConfluenceClient(getConfig());
-      const results = await client.search(query, parseInt(options.limit));
+      const client = new ConfluenceClient(getConfig(getProfileName()));
+      const results = await client.search(query, parseInt(options.limit), options.cql);
       
       if (results.length === 0) {
         console.log(chalk.yellow('No results found.'));
@@ -109,7 +132,7 @@ program
   .action(async () => {
     const analytics = new Analytics();
     try {
-      const config = getConfig();
+      const config = getConfig(getProfileName());
       const client = new ConfluenceClient(config);
       const spaces = await client.getSpaces();
       
@@ -139,22 +162,64 @@ program
     }
   });
 
+// Install skill command
+program
+  .command('install-skill')
+  .description('Copy Claude Code skill files into your project\'s .claude/skills/ directory')
+  .option('--dest <directory>', 'Target directory', './.claude/skills/confluence')
+  .option('-y, --yes', 'Skip confirmation prompt')
+  .action(async (options) => {
+    const fs = require('fs');
+    const path = require('path');
+
+    const skillSrc = path.join(__dirname, '..', '.claude', 'skills', 'confluence', 'SKILL.md');
+
+    if (!fs.existsSync(skillSrc)) {
+      console.error(chalk.red('Error: skill file not found in package. Try reinstalling confluence-cli.'));
+      process.exit(1);
+    }
+
+    const destDir = path.resolve(options.dest);
+    const destFile = path.join(destDir, 'SKILL.md');
+
+    if (fs.existsSync(destFile) && !options.yes) {
+      const { confirmed } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirmed',
+          default: true,
+          message: `Overwrite existing skill file at ${destFile}?`
+        }
+      ]);
+
+      if (!confirmed) {
+        console.log(chalk.yellow('Cancelled.'));
+        return;
+      }
+    }
+
+    fs.mkdirSync(destDir, { recursive: true });
+    fs.copyFileSync(skillSrc, destFile);
+
+    console.log(chalk.green('✅ Skill installed successfully!'));
+    console.log(`Location: ${chalk.gray(destFile)}`);
+    console.log(chalk.yellow('Claude Code will now pick up confluence-cli knowledge from this file.'));
+  });
+
 // Create command
 program
-  .command('create <title> [spaceKey]')
+  .command('create <title> <spaceKey>')
   .description('Create a new Confluence page')
   .option('-f, --file <file>', 'Read content from file')
   .option('-c, --content <content>', 'Page content as string')
   .option('--format <format>', 'Content format (storage, html, markdown)', 'storage')
-  .option('--parent <parentId>', 'Parent page ID (creates page as child of this page)')
-  .option('--validate-storage', 'Validate storage content (XML well-formed) before sending')
-  .option('--no-sanitize-storage', 'Disable auto-escaping raw ampersands in storage format')
   .action(async (title, spaceKey, options) => {
     const analytics = new Analytics();
     try {
-      const config = getConfig();
+      const config = getConfig(getProfileName());
+      assertWritable(config);
       const client = new ConfluenceClient(config);
-      
+
       let content = '';
       
       if (options.file) {
@@ -169,32 +234,13 @@ program
         throw new Error('Either --file or --content option is required');
       }
       
-      let result;
-      if (options.parent) {
-        const parentInfo = await client.getPageInfo(options.parent);
-        const derivedSpaceKey = parentInfo.space.key;
-        result = await client.createChildPage(title, derivedSpaceKey, options.parent, content, options.format, {
-          validateStorage: options.validateStorage,
-          sanitizeStorage: options.sanitizeStorage
-        });
-        console.log(chalk.green('✅ Page created successfully!'));
-        console.log(`Title: ${chalk.blue(result.title)}`);
-        console.log(`ID: ${chalk.blue(result.id)}`);
-        console.log(`Parent: ${chalk.blue(parentInfo.title)} (${options.parent})`);
-      } else {
-        if (!spaceKey) {
-          throw new Error('Space key is required when --parent is not specified');
-        }
-        result = await client.createPage(title, spaceKey, content, options.format, {
-          validateStorage: options.validateStorage,
-          sanitizeStorage: options.sanitizeStorage
-        });
-        console.log(chalk.green('✅ Page created successfully!'));
-        console.log(`Title: ${chalk.blue(result.title)}`);
-        console.log(`ID: ${chalk.blue(result.id)}`);
-      }
+      const result = await client.createPage(title, spaceKey, content, options.format);
+      
+      console.log(chalk.green('✅ Page created successfully!'));
+      console.log(`Title: ${chalk.blue(result.title)}`);
+      console.log(`ID: ${chalk.blue(result.id)}`);
       console.log(`Space: ${chalk.blue(result.space.name)} (${result.space.key})`);
-      console.log(`URL: ${chalk.gray(`https://${config.domain}/wiki${result._links.webui}`)}`);
+      console.log(`URL: ${chalk.gray(`${buildPageUrl(config, `/wiki${result._links.webui}`)}`)}`);
       
       analytics.track('create', true);
     } catch (error) {
@@ -211,16 +257,13 @@ program
   .option('-f, --file <file>', 'Read content from file')
   .option('-c, --content <content>', 'Page content as string')
   .option('--format <format>', 'Content format (storage, html, markdown)', 'storage')
-  .option('--validate-storage', 'Validate storage content (XML well-formed) before sending')
-  .option('--no-sanitize-storage', 'Disable auto-escaping raw ampersands in storage format')
-  .option('--validate-storage', 'Validate storage content (XML well-formed) before sending')
-  .option('--no-sanitize-storage', 'Disable auto-escaping raw ampersands in storage format')
   .action(async (title, parentId, options) => {
     const analytics = new Analytics();
     try {
-      const config = getConfig();
+      const config = getConfig(getProfileName());
+      assertWritable(config);
       const client = new ConfluenceClient(config);
-      
+
       // Get parent page info to get space key
       const parentInfo = await client.getPageInfo(parentId);
       const spaceKey = parentInfo.space.key;
@@ -239,17 +282,14 @@ program
         throw new Error('Either --file or --content option is required');
       }
       
-      const result = await client.createChildPage(title, spaceKey, parentId, content, options.format, {
-        validateStorage: options.validateStorage,
-        sanitizeStorage: options.sanitizeStorage
-      });
+      const result = await client.createChildPage(title, spaceKey, parentId, content, options.format);
       
       console.log(chalk.green('✅ Child page created successfully!'));
       console.log(`Title: ${chalk.blue(result.title)}`);
       console.log(`ID: ${chalk.blue(result.id)}`);
       console.log(`Parent: ${chalk.blue(parentInfo.title)} (${parentId})`);
       console.log(`Space: ${chalk.blue(result.space.name)} (${result.space.key})`);
-      console.log(`URL: ${chalk.gray(`https://${config.domain}/wiki${result._links.webui}`)}`);
+      console.log(`URL: ${chalk.gray(`${buildPageUrl(config, `/wiki${result._links.webui}`)}`)}`);
       
       analytics.track('create_child', true);
     } catch (error) {
@@ -267,8 +307,6 @@ program
   .option('-f, --file <file>', 'Read content from file')
   .option('-c, --content <content>', 'Page content as string')
   .option('--format <format>', 'Content format (storage, html, markdown)', 'storage')
-  .option('--validate-storage', 'Validate storage content (XML well-formed) before sending')
-  .option('--no-sanitize-storage', 'Disable auto-escaping raw ampersands in storage format')
   .action(async (pageId, options) => {
     const analytics = new Analytics();
     try {
@@ -277,9 +315,10 @@ program
         throw new Error('At least one of --title, --file, or --content must be provided.');
       }
 
-      const config = getConfig();
+      const config = getConfig(getProfileName());
+      assertWritable(config);
       const client = new ConfluenceClient(config);
-      
+
       let content = null; // Use null to indicate no content change
       
       if (options.file) {
@@ -292,16 +331,13 @@ program
         content = options.content;
       }
       
-      const result = await client.updatePage(pageId, options.title, content, options.format, {
-        validateStorage: options.validateStorage,
-        sanitizeStorage: options.sanitizeStorage
-      });
+      const result = await client.updatePage(pageId, options.title, content, options.format);
       
       console.log(chalk.green('✅ Page updated successfully!'));
       console.log(`Title: ${chalk.blue(result.title)}`);
       console.log(`ID: ${chalk.blue(result.id)}`);
       console.log(`Version: ${chalk.blue(result.version.number)}`);
-      console.log(`URL: ${chalk.gray(`https://${config.domain}/wiki${result._links.webui}`)}`);
+      console.log(`URL: ${chalk.gray(`${buildPageUrl(config, `/wiki${result._links.webui}`)}`)}`);
       
       analytics.track('update', true);
     } catch (error) {
@@ -311,6 +347,34 @@ program
     }
   });
 
+// Move command
+program
+  .command('move <pageId_or_url> <newParentId_or_url>')
+  .description('Move a page to a new parent location (within same space)')
+  .option('-t, --title <title>', 'New page title (optional)')
+  .action(async (pageId, newParentId, options) => {
+    const analytics = new Analytics();
+    try {
+      const config = getConfig(getProfileName());
+      assertWritable(config);
+      const client = new ConfluenceClient(config);
+      const result = await client.movePage(pageId, newParentId, options.title);
+
+      console.log(chalk.green('✅ Page moved successfully!'));
+      console.log(`Title: ${chalk.blue(result.title)}`);
+      console.log(`ID: ${chalk.blue(result.id)}`);
+      console.log(`New Parent: ${chalk.blue(newParentId)}`);
+      console.log(`Version: ${chalk.blue(result.version.number)}`);
+      console.log(`URL: ${chalk.gray(`${buildPageUrl(config, `/wiki${result._links.webui}`)}`)}`);
+
+      analytics.track('move', true);
+    } catch (error) {
+      analytics.track('move', false);
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
 // Delete command
 program
   .command('delete <pageIdOrUrl>')
@@ -319,7 +383,8 @@ program
   .action(async (pageIdOrUrl, options) => {
     const analytics = new Analytics();
     try {
-      const config = getConfig();
+      const config = getConfig(getProfileName());
+      assertWritable(config);
       const client = new ConfluenceClient(config);
       const pageInfo = await client.getPageInfo(pageIdOrUrl);
 
@@ -362,7 +427,8 @@ program
   .action(async (pageId, options) => {
     const analytics = new Analytics();
     try {
-      const config = getConfig();
+      const config = getConfig(getProfileName());
+      assertWritable(config);
       const client = new ConfluenceClient(config);
       const pageData = await client.getPageForEdit(pageId);
       
@@ -399,7 +465,7 @@ program
   .action(async (title, options) => {
     const analytics = new Analytics();
     try {
-      const config = getConfig();
+      const config = getConfig(getProfileName());
       const client = new ConfluenceClient(config);
       const pageInfo = await client.findPageByTitle(title, options.space);
       
@@ -407,7 +473,7 @@ program
       console.log(`Title: ${chalk.green(pageInfo.title)}`);
       console.log(`ID: ${chalk.green(pageInfo.id)}`);
       console.log(`Space: ${chalk.green(pageInfo.space.name)} (${pageInfo.space.key})`);
-      console.log(`URL: ${chalk.gray(`https://${config.domain}/wiki${pageInfo.url}`)}`);
+      console.log(`URL: ${chalk.gray(`${buildPageUrl(config, `/wiki${pageInfo.url}`)}`)}`);
       
       analytics.track('find', true);
     } catch (error) {
@@ -425,10 +491,11 @@ program
   .option('-p, --pattern <glob>', 'Filter attachments by filename (e.g., "*.png")')
   .option('-d, --download', 'Download matching attachments')
   .option('--dest <directory>', 'Directory to save downloads (default: current directory)', '.')
+  .option('-f, --format <format>', 'Output format (text, json)', 'text')
   .action(async (pageId, options) => {
     const analytics = new Analytics();
     try {
-      const config = getConfig();
+      const config = getConfig(getProfileName());
       const client = new ConfluenceClient(config);
       const maxResults = options.limit ? parseInt(options.limit, 10) : null;
       const pattern = options.pattern ? options.pattern.trim() : null;
@@ -437,22 +504,47 @@ program
         throw new Error('Limit must be a positive number.');
       }
 
+      const format = (options.format || 'text').toLowerCase();
+      if (!['text', 'json'].includes(format)) {
+        throw new Error('Format must be one of: text, json');
+      }
+
       const attachments = await client.getAllAttachments(pageId, { maxResults });
       const filtered = pattern ? attachments.filter(att => client.matchesPattern(att.title, pattern)) : attachments;
 
       if (filtered.length === 0) {
-        console.log(chalk.yellow('No attachments found.'));
+        if (format === 'json') {
+          console.log(JSON.stringify({ attachmentCount: 0, attachments: [] }, null, 2));
+        } else {
+          console.log(chalk.yellow('No attachments found.'));
+        }
         analytics.track('attachments', true);
         return;
       }
 
-      console.log(chalk.blue(`Found ${filtered.length} attachment${filtered.length === 1 ? '' : 's'}:`));
-      filtered.forEach((att, index) => {
-        const sizeKb = att.fileSize ? `${Math.max(1, Math.round(att.fileSize / 1024))} KB` : 'unknown size';
-        const typeLabel = att.mediaType || 'unknown';
-        console.log(`${index + 1}. ${chalk.green(att.title)} (ID: ${att.id})`);
-        console.log(`   Type: ${chalk.gray(typeLabel)} • Size: ${chalk.gray(sizeKb)} • Version: ${chalk.gray(att.version)}`);
-      });
+      if (format === 'json' && !options.download) {
+        const output = {
+          attachmentCount: filtered.length,
+          attachments: filtered.map(att => ({
+            id: att.id,
+            title: att.title,
+            mediaType: att.mediaType || '',
+            fileSize: att.fileSize,
+            fileSizeFormatted: att.fileSize ? `${Math.max(1, Math.round(att.fileSize / 1024))} KB` : 'unknown size',
+            version: att.version,
+            downloadLink: att.downloadLink
+          }))
+        };
+        console.log(JSON.stringify(output, null, 2));
+      } else if (!options.download) {
+        console.log(chalk.blue(`Found ${filtered.length} attachment${filtered.length === 1 ? '' : 's'}:`));
+        filtered.forEach((att, index) => {
+          const sizeKb = att.fileSize ? `${Math.max(1, Math.round(att.fileSize / 1024))} KB` : 'unknown size';
+          const typeLabel = att.mediaType || 'unknown';
+          console.log(`${index + 1}. ${chalk.green(att.title)} (ID: ${att.id})`);
+          console.log(`   Type: ${chalk.gray(typeLabel)} • Size: ${chalk.gray(sizeKb)} • Version: ${chalk.gray(att.version)}`);
+        });
+      }
 
       if (options.download) {
         const fs = require('fs');
@@ -481,17 +573,28 @@ program
           writer.on('finish', resolve);
         });
 
-        let downloaded = 0;
+        const downloadResults = [];
         for (const attachment of filtered) {
           const targetPath = uniquePathFor(destDir, attachment.title);
-          // Pass the full attachment object so downloadAttachment can use downloadLink directly
           const dataStream = await client.downloadAttachment(pageId, attachment);
           await writeStream(dataStream, targetPath);
-          downloaded += 1;
-          console.log(`⬇️  ${chalk.green(attachment.title)} -> ${chalk.gray(targetPath)}`);
+          downloadResults.push({ title: attachment.title, id: attachment.id, savedTo: targetPath });
+          if (format !== 'json') {
+            console.log(`⬇️  ${chalk.green(attachment.title)} -> ${chalk.gray(targetPath)}`);
+          }
         }
 
-        console.log(chalk.green(`Downloaded ${downloaded} attachment${downloaded === 1 ? '' : 's'} to ${destDir}`));
+        if (format === 'json') {
+          const output = {
+            attachmentCount: filtered.length,
+            downloaded: downloadResults.length,
+            destination: destDir,
+            attachments: downloadResults
+          };
+          console.log(JSON.stringify(output, null, 2));
+        } else {
+          console.log(chalk.green(`Downloaded ${downloadResults.length} attachment${downloadResults.length === 1 ? '' : 's'} to ${destDir}`));
+        }
       }
 
       analytics.track('attachments', true);
@@ -502,6 +605,318 @@ program
     }
   });
 
+// Attachment upload command
+program
+  .command('attachment-upload <pageId>')
+  .description('Upload one or more attachments to a page')
+  .option('-f, --file <file>', 'File to upload (repeatable)', (value, previous) => {
+    const files = Array.isArray(previous) ? previous : [];
+    files.push(value);
+    return files;
+  }, [])
+  .option('--comment <comment>', 'Comment for the attachment(s)')
+  .option('--replace', 'Replace an existing attachment with the same filename')
+  .option('--minor-edit', 'Mark the upload as a minor edit')
+  .action(async (pageId, options) => {
+    const analytics = new Analytics();
+    try {
+      const files = Array.isArray(options.file) ? options.file.filter(Boolean) : [];
+      if (files.length === 0) {
+        throw new Error('At least one --file option is required.');
+      }
+
+      const fs = require('fs');
+      const path = require('path');
+      const config = getConfig(getProfileName());
+      assertWritable(config);
+      const client = new ConfluenceClient(config);
+
+      const resolvedFiles = files.map((filePath) => ({
+        original: filePath,
+        resolved: path.resolve(filePath)
+      }));
+
+      resolvedFiles.forEach((file) => {
+        if (!fs.existsSync(file.resolved)) {
+          throw new Error(`File not found: ${file.original}`);
+        }
+      });
+
+      let uploaded = 0;
+      for (const file of resolvedFiles) {
+        const result = await client.uploadAttachment(pageId, file.resolved, {
+          comment: options.comment,
+          replace: options.replace,
+          minorEdit: options.minorEdit === true ? true : undefined
+        });
+        const attachment = result.results[0];
+        if (attachment) {
+          console.log(`⬆️  ${chalk.green(attachment.title)} (ID: ${attachment.id}, Version: ${attachment.version})`);
+        } else {
+          console.log(`⬆️  ${chalk.green(path.basename(file.resolved))}`);
+        }
+        uploaded += 1;
+      }
+
+      console.log(chalk.green(`Uploaded ${uploaded} attachment${uploaded === 1 ? '' : 's'} to page ${pageId}`));
+      analytics.track('attachment_upload', true);
+    } catch (error) {
+      analytics.track('attachment_upload', false);
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Attachment delete command
+program
+  .command('attachment-delete <pageId> <attachmentId>')
+  .description('Delete an attachment by ID from a page')
+  .option('-y, --yes', 'Skip confirmation prompt')
+  .action(async (pageId, attachmentId, options) => {
+    const analytics = new Analytics();
+    try {
+      const config = getConfig(getProfileName());
+      assertWritable(config);
+      const client = new ConfluenceClient(config);
+
+      if (!options.yes) {
+        const { confirmed } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'confirmed',
+            default: false,
+            message: `Delete attachment ${attachmentId} from page ${pageId}?`
+          }
+        ]);
+
+        if (!confirmed) {
+          console.log(chalk.yellow('Cancelled.'));
+          analytics.track('attachment_delete_cancel', true);
+          return;
+        }
+      }
+
+      const result = await client.deleteAttachment(pageId, attachmentId);
+
+      console.log(chalk.green('✅ Attachment deleted successfully!'));
+      console.log(`ID: ${chalk.blue(result.id)}`);
+      console.log(`Page ID: ${chalk.blue(result.pageId)}`);
+      analytics.track('attachment_delete', true);
+    } catch (error) {
+      analytics.track('attachment_delete', false);
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Property list command
+program
+  .command('property-list <pageId>')
+  .description('List all content properties for a page')
+  .option('-f, --format <format>', 'Output format (text, json)', 'text')
+  .option('-l, --limit <limit>', 'Maximum number of properties to fetch (default: 25)')
+  .option('--start <start>', 'Start index for results (default: 0)', '0')
+  .option('--all', 'Fetch all properties (ignores pagination)')
+  .action(async (pageId, options) => {
+    const analytics = new Analytics();
+    try {
+      const config = getConfig(getProfileName());
+      const client = new ConfluenceClient(config);
+
+      const format = (options.format || 'text').toLowerCase();
+      if (!['text', 'json'].includes(format)) {
+        throw new Error('Format must be one of: text, json');
+      }
+
+      const limit = options.limit ? parseInt(options.limit, 10) : null;
+      if (options.limit && (Number.isNaN(limit) || limit <= 0)) {
+        throw new Error('Limit must be a positive number.');
+      }
+
+      const start = options.start ? parseInt(options.start, 10) : 0;
+      if (options.start && (Number.isNaN(start) || start < 0)) {
+        throw new Error('Start must be a non-negative number.');
+      }
+
+      let properties = [];
+      let nextStart = null;
+
+      if (options.all) {
+        properties = await client.getAllProperties(pageId, {
+          maxResults: limit || null,
+          start
+        });
+      } else {
+        const response = await client.listProperties(pageId, {
+          limit: limit || undefined,
+          start
+        });
+        properties = response.results;
+        nextStart = response.nextStart;
+      }
+
+      if (format === 'json') {
+        const output = { properties };
+        if (!options.all) {
+          output.nextStart = nextStart;
+        }
+        console.log(JSON.stringify(output, null, 2));
+      } else if (properties.length === 0) {
+        console.log(chalk.yellow('No properties found.'));
+      } else {
+        properties.forEach((prop, i) => {
+          const preview = JSON.stringify(prop.value);
+          const truncated = preview.length > 80 ? preview.slice(0, 77) + '...' : preview;
+          console.log(`${chalk.blue(i + 1 + '.')} ${chalk.green(prop.key)} (v${prop.version.number}): ${truncated}`);
+        });
+
+        if (!options.all && nextStart !== null && nextStart !== undefined) {
+          console.log(chalk.gray(`Next start: ${nextStart}`));
+        }
+      }
+      analytics.track('property_list', true);
+    } catch (error) {
+      analytics.track('property_list', false);
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Property get command
+program
+  .command('property-get <pageId> <key>')
+  .description('Get a content property by key')
+  .option('-f, --format <format>', 'Output format (text, json)', 'text')
+  .action(async (pageId, key, options) => {
+    const analytics = new Analytics();
+    try {
+      const config = getConfig(getProfileName());
+      const client = new ConfluenceClient(config);
+
+      const format = (options.format || 'text').toLowerCase();
+      if (!['text', 'json'].includes(format)) {
+        throw new Error('Format must be one of: text, json');
+      }
+
+      const property = await client.getProperty(pageId, key);
+
+      if (format === 'json') {
+        console.log(JSON.stringify(property, null, 2));
+      } else {
+        console.log(`${chalk.green('Key:')} ${property.key}`);
+        console.log(`${chalk.green('Version:')} ${property.version.number}`);
+        console.log(`${chalk.green('Value:')}`);
+        console.log(JSON.stringify(property.value, null, 2));
+      }
+      analytics.track('property_get', true);
+    } catch (error) {
+      analytics.track('property_get', false);
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Property set command
+program
+  .command('property-set <pageId> <key>')
+  .description('Set a content property (create or update)')
+  .option('-v, --value <json>', 'Property value as JSON')
+  .option('--file <file>', 'Read property value from a JSON file')
+  .option('-f, --format <format>', 'Output format (text, json)', 'text')
+  .action(async (pageId, key, options) => {
+    const analytics = new Analytics();
+    try {
+      const config = getConfig(getProfileName());
+      assertWritable(config);
+      const client = new ConfluenceClient(config);
+
+      if (!options.value && !options.file) {
+        throw new Error('Provide a value with --value or --file.');
+      }
+
+      let value;
+      if (options.file) {
+        const fs = require('fs');
+        const raw = fs.readFileSync(options.file, 'utf-8');
+        try {
+          value = JSON.parse(raw);
+        } catch {
+          throw new Error(`Invalid JSON in file ${options.file}`);
+        }
+      } else {
+        try {
+          value = JSON.parse(options.value);
+        } catch {
+          throw new Error('Invalid JSON in --value');
+        }
+      }
+
+      const format = (options.format || 'text').toLowerCase();
+      if (!['text', 'json'].includes(format)) {
+        throw new Error('Format must be one of: text, json');
+      }
+
+      const result = await client.setProperty(pageId, key, value);
+
+      if (format === 'json') {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(chalk.green('✅ Property set successfully!'));
+        console.log(`${chalk.green('Key:')} ${result.key}`);
+        console.log(`${chalk.green('Version:')} ${result.version.number}`);
+        console.log(`${chalk.green('Value:')}`);
+        console.log(JSON.stringify(result.value, null, 2));
+      }
+      analytics.track('property_set', true);
+    } catch (error) {
+      analytics.track('property_set', false);
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Property delete command
+program
+  .command('property-delete <pageId> <key>')
+  .description('Delete a content property by key')
+  .option('-y, --yes', 'Skip confirmation prompt')
+  .action(async (pageId, key, options) => {
+    const analytics = new Analytics();
+    try {
+      const config = getConfig(getProfileName());
+      assertWritable(config);
+      const client = new ConfluenceClient(config);
+
+      if (!options.yes) {
+        const { confirmed } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'confirmed',
+            default: false,
+            message: `Delete property "${key}" from page ${pageId}?`
+          }
+        ]);
+
+        if (!confirmed) {
+          console.log(chalk.yellow('Cancelled.'));
+          analytics.track('property_delete_cancel', true);
+          return;
+        }
+      }
+
+      const result = await client.deleteProperty(pageId, key);
+
+      console.log(chalk.green('✅ Property deleted successfully!'));
+      console.log(`${chalk.green('Key:')} ${chalk.blue(result.key)}`);
+      console.log(`${chalk.green('Page ID:')} ${chalk.blue(result.pageId)}`);
+      analytics.track('property_delete', true);
+    } catch (error) {
+      analytics.track('property_delete', false);
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
 // Comments command
 program
   .command('comments <pageId>')
@@ -515,7 +930,7 @@ program
   .action(async (pageId, options) => {
     const analytics = new Analytics();
     try {
-      const config = getConfig();
+      const config = getConfig(getProfileName());
       const client = new ConfluenceClient(config);
 
       const format = (options.format || 'text').toLowerCase();
@@ -670,7 +1085,8 @@ program
     const analytics = new Analytics();
     let location = null;
     try {
-      const config = getConfig();
+      const config = getConfig(getProfileName());
+      assertWritable(config);
       const client = new ConfluenceClient(config);
 
       let content = '';
@@ -784,7 +1200,8 @@ program
   .action(async (commentId, options) => {
     const analytics = new Analytics();
     try {
-      const config = getConfig();
+      const config = getConfig(getProfileName());
+      assertWritable(config);
       const client = new ConfluenceClient(config);
 
       if (!options.yes) {
@@ -827,14 +1244,26 @@ program
   .option('--pattern <glob>', 'Filter attachments by filename (e.g., "*.png")')
   .option('--referenced-only', 'Download only attachments referenced in the page content')
   .option('--skip-attachments', 'Do not download attachments')
+  .option('-r, --recursive', 'Export page and all descendants')
+  .option('--max-depth <depth>', 'Limit recursion depth (default: 10)', parseInt)
+  .option('--exclude <patterns>', 'Comma-separated title glob patterns to skip')
+  .option('--delay-ms <ms>', 'Delay between page exports in ms (default: 100)', parseInt)
+  .option('--dry-run', 'Preview pages without writing files')
+  .option('--overwrite', 'Overwrite existing export directory (replaces content, removes stale files)')
   .action(async (pageId, options) => {
     const analytics = new Analytics();
     try {
-      const config = getConfig();
+      const config = getConfig(getProfileName());
       const client = new ConfluenceClient(config);
       const fs = require('fs');
       const path = require('path');
 
+      if (options.recursive) {
+        await exportRecursive(client, fs, path, pageId, options);
+        analytics.track('export', true);
+        return;
+      }
+
       const format = (options.format || 'markdown').toLowerCase();
       const formatExt = { markdown: 'md', html: 'html', text: 'txt' };
       const contentExt = formatExt[format] || 'txt';
@@ -852,11 +1281,18 @@ program
       const baseDir = path.resolve(options.dest || '.');
       const folderName = sanitizeTitle(pageInfo.title || 'page');
       const exportDir = path.join(baseDir, folderName);
+      if (options.overwrite && fs.existsSync(exportDir)) {
+        if (!isExportDirectory(fs, path, exportDir)) {
+          throw new Error(`Refusing to overwrite "${exportDir}" - it was not created by confluence-cli (missing ${EXPORT_MARKER}).`);
+        }
+        fs.rmSync(exportDir, { recursive: true, force: true });
+      }
       fs.mkdirSync(exportDir, { recursive: true });
 
       const contentFile = options.file || `page.${contentExt}`;
       const contentPath = path.join(exportDir, contentFile);
       fs.writeFileSync(contentPath, content);
+      writeExportMarker(fs, path, exportDir, { pageId, title: pageInfo.title });
 
       console.log(chalk.green('✅ Page exported'));
       console.log(`Title: ${chalk.blue(pageInfo.title)}`);
@@ -882,33 +1318,12 @@ program
           const attachmentsDir = path.join(exportDir, attachmentsDirName);
           fs.mkdirSync(attachmentsDir, { recursive: true });
 
-          const uniquePathFor = (dir, filename) => {
-            const parsed = path.parse(filename);
-            let attempt = path.join(dir, filename);
-            let counter = 1;
-            while (fs.existsSync(attempt)) {
-              const suffix = ` (${counter})`;
-              const nextName = `${parsed.name}${suffix}${parsed.ext}`;
-              attempt = path.join(dir, nextName);
-              counter += 1;
-            }
-            return attempt;
-          };
-
-          const writeStream = (stream, targetPath) => new Promise((resolve, reject) => {
-            const writer = fs.createWriteStream(targetPath);
-            stream.pipe(writer);
-            stream.on('error', reject);
-            writer.on('error', reject);
-            writer.on('finish', resolve);
-          });
-
           let downloaded = 0;
           for (const attachment of filtered) {
-            const targetPath = uniquePathFor(attachmentsDir, attachment.title);
+            const targetPath = uniquePathFor(fs, path, attachmentsDir, attachment.title);
             // Pass the full attachment object so downloadAttachment can use downloadLink directly
             const dataStream = await client.downloadAttachment(pageId, attachment);
-            await writeStream(dataStream, targetPath);
+            await writeStream(fs, dataStream, targetPath);
             downloaded += 1;
             console.log(`⬇️  ${chalk.green(attachment.title)} -> ${chalk.gray(targetPath)}`);
           }
@@ -925,6 +1340,219 @@ program
     }
   });
 
+const EXPORT_MARKER = '.confluence-export.json';
+
+function writeExportMarker(fs, path, exportDir, meta) {
+  const marker = {
+    exportedAt: new Date().toISOString(),
+    pageId: meta.pageId,
+    title: meta.title,
+    tool: 'confluence-cli',
+  };
+  fs.writeFileSync(path.join(exportDir, EXPORT_MARKER), JSON.stringify(marker, null, 2));
+}
+
+function isExportDirectory(fs, path, dir) {
+  return fs.existsSync(path.join(dir, EXPORT_MARKER));
+}
+
+function uniquePathFor(fs, path, dir, filename) {
+  const parsed = path.parse(filename);
+  let attempt = path.join(dir, filename);
+  let counter = 1;
+  while (fs.existsSync(attempt)) {
+    const suffix = ` (${counter})`;
+    const nextName = `${parsed.name}${suffix}${parsed.ext}`;
+    attempt = path.join(dir, nextName);
+    counter += 1;
+  }
+  return attempt;
+}
+
+function writeStream(fs, stream, targetPath) {
+  return new Promise((resolve, reject) => {
+    const writer = fs.createWriteStream(targetPath);
+    stream.pipe(writer);
+    stream.on('error', reject);
+    writer.on('error', reject);
+    writer.on('finish', resolve);
+  });
+}
+
+async function exportRecursive(client, fs, path, pageId, options) {
+  const maxDepth = options.maxDepth || 10;
+  const delayMs = options.delayMs != null ? options.delayMs : 100;
+  const excludePatterns = options.exclude
+    ? options.exclude.split(',').map(p => p.trim()).filter(Boolean)
+    : [];
+  const format = (options.format || 'markdown').toLowerCase();
+  const formatExt = { markdown: 'md', html: 'html', text: 'txt' };
+  const contentExt = formatExt[format] || 'txt';
+  const contentFile = options.file || `page.${contentExt}`;
+  const baseDir = path.resolve(options.dest || '.');
+
+  // 1. Fetch root page
+  const rootPage = await client.getPageInfo(pageId);
+  console.log(`Fetching descendants of "${chalk.blue(rootPage.title)}"...`);
+
+  // 2. Fetch all descendants
+  const descendants = await client.getAllDescendantPages(pageId, maxDepth);
+
+  // 3. Filter by exclude patterns
+  const allPages = [{ id: rootPage.id, title: rootPage.title, parentId: null }];
+  for (const page of descendants) {
+    if (excludePatterns.length && client.shouldExcludePage(page.title, excludePatterns)) {
+      continue;
+    }
+    allPages.push(page);
+  }
+
+  // 4. Build tree
+  const tree = client.buildPageTree(allPages.slice(1), pageId);
+
+  const totalPages = allPages.length;
+  console.log(`Found ${chalk.blue(totalPages)} page${totalPages === 1 ? '' : 's'} to export.`);
+
+  // 5. Dry run — print tree and return
+  if (options.dryRun) {
+    const printTree = (nodes, indent = '') => {
+      for (const node of nodes) {
+        console.log(`${indent}${chalk.blue(node.title)} (${node.id})`);
+        if (node.children && node.children.length) {
+          printTree(node.children, indent + '  ');
+        }
+      }
+    };
+    console.log(`\n${chalk.blue(rootPage.title)} (${rootPage.id})`);
+    printTree(tree, '  ');
+    console.log(chalk.yellow('\nDry run — no files written.'));
+    return;
+  }
+
+  // 6. Overwrite — remove existing root export directory for a clean slate
+  if (options.overwrite) {
+    const rootFolderName = sanitizeTitle(rootPage.title);
+    const rootExportDir = path.join(baseDir, rootFolderName);
+    if (fs.existsSync(rootExportDir)) {
+      if (!isExportDirectory(fs, path, rootExportDir)) {
+        throw new Error(`Refusing to overwrite "${rootExportDir}" - it was not created by confluence-cli (missing ${EXPORT_MARKER}).`);
+      }
+      fs.rmSync(rootExportDir, { recursive: true, force: true });
+    }
+  }
+
+  // 7. Walk tree depth-first and export each page
+  const failures = [];
+  let exported = 0;
+
+  async function exportPage(page, dir) {
+    exported += 1;
+    console.log(`[${exported}/${totalPages}] Exporting: ${chalk.blue(page.title)}`);
+
+    const folderName = sanitizeTitle(page.title);
+    let exportDir = path.join(dir, folderName);
+
+    // Handle duplicate sibling folder names
+    if (fs.existsSync(exportDir)) {
+      let counter = 1;
+      while (fs.existsSync(`${exportDir} (${counter})`)) {
+        counter += 1;
+      }
+      exportDir = `${exportDir} (${counter})`;
+    }
+    fs.mkdirSync(exportDir, { recursive: true });
+
+    // Fetch content and write
+    const content = await client.readPage(
+      page.id,
+      format,
+      options.referencedOnly ? { extractReferencedAttachments: true } : {}
+    );
+    const referencedAttachments = options.referencedOnly
+      ? (client._referencedAttachments || new Set())
+      : null;
+    fs.writeFileSync(path.join(exportDir, contentFile), content);
+
+    // Download attachments
+    if (!options.skipAttachments) {
+      const pattern = options.pattern ? options.pattern.trim() : null;
+      const allAttachments = await client.getAllAttachments(page.id);
+
+      let filtered;
+      if (pattern) {
+        filtered = allAttachments.filter(att => client.matchesPattern(att.title, pattern));
+      } else if (options.referencedOnly) {
+        filtered = allAttachments.filter(att => referencedAttachments?.has(att.title));
+      } else {
+        filtered = allAttachments;
+      }
+
+      if (filtered.length > 0) {
+        const attachmentsDirName = options.attachmentsDir || 'attachments';
+        const attachmentsDir = path.join(exportDir, attachmentsDirName);
+        fs.mkdirSync(attachmentsDir, { recursive: true });
+
+        for (const attachment of filtered) {
+          const targetPath = uniquePathFor(fs, path, attachmentsDir, attachment.title);
+          const dataStream = await client.downloadAttachment(page.id, attachment);
+          await writeStream(fs, dataStream, targetPath);
+        }
+      }
+    }
+
+    return exportDir;
+  }
+
+  async function walkTree(nodes, parentDir) {
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      try {
+        const nodeDir = await exportPage(node, parentDir);
+        if (node.children && node.children.length) {
+          await walkTree(node.children, nodeDir);
+        }
+      } catch (error) {
+        failures.push({ id: node.id, title: node.title, error: error.message });
+        console.error(chalk.red(`  Failed: ${node.title} — ${error.message}`));
+      }
+
+      // Rate limiting between pages
+      if (delayMs > 0 && exported < totalPages) {
+        await new Promise(resolve => setTimeout(resolve, delayMs));
+      }
+    }
+  }
+
+  // Export root page
+  let rootDir;
+  try {
+    rootDir = await exportPage(rootPage, baseDir);
+    writeExportMarker(fs, path, rootDir, { pageId, title: rootPage.title });
+  } catch (error) {
+    failures.push({ id: rootPage.id, title: rootPage.title, error: error.message });
+    console.error(chalk.red(`  Failed: ${rootPage.title} — ${error.message}`));
+    // Can't continue without root directory
+    throw new Error(`Failed to export root page: ${error.message}`);
+  }
+
+  if (delayMs > 0 && tree.length > 0) {
+    await new Promise(resolve => setTimeout(resolve, delayMs));
+  }
+
+  // Export descendants
+  await walkTree(tree, rootDir);
+
+  // 8. Summary
+  const succeeded = exported - failures.length;
+  console.log(chalk.green(`\n✅ Exported ${succeeded}/${totalPages} page${totalPages === 1 ? '' : 's'} to ${rootDir}`));
+  if (failures.length > 0) {
+    console.log(chalk.red(`\n${failures.length} failure${failures.length === 1 ? '' : 's'}:`));
+    for (const f of failures) {
+      console.log(chalk.red(`  - ${f.title} (${f.id}): ${f.error}`));
+    }
+  }
+}
+
 function sanitizeTitle(value) {
   const fallback = 'page';
   if (!value || typeof value !== 'string') {
@@ -991,9 +1619,10 @@ program
   .action(async (sourcePageId, targetParentId, newTitle, options) => {
     const analytics = new Analytics();
     try {
-      const config = getConfig();
+      const config = getConfig(getProfileName());
+      assertWritable(config);
       const client = new ConfluenceClient(config);
-      
+
       // Parse numeric flags with safe fallbacks
       const parsedDepth = parseInt(options.maxDepth, 10);
       const maxDepth = Number.isNaN(parsedDepth) ? 10 : parsedDepth;
@@ -1084,7 +1713,7 @@ program
           console.log(` - ...and ${result.failures.length - 10} more`);
         }
       }
-      console.log(`URL: ${chalk.gray(`https://${config.domain}/wiki${result.rootPage._links.webui}`)}`);
+      console.log(`URL: ${chalk.gray(`${buildPageUrl(config, `/wiki${result.rootPage._links.webui}`)}`)}`);
       if (options.failOnError && result.failures?.length) {
         analytics.track('copy_tree', false);
         console.error(chalk.red('Completed with failures and --fail-on-error is set.'));
@@ -1111,7 +1740,7 @@ program
   .action(async (pageId, options) => {
     const analytics = new Analytics();
     try {
-      const config = getConfig();
+      const config = getConfig(getProfileName());
       const client = new ConfluenceClient(config);
       
       // Extract page ID from URL if needed
@@ -1146,7 +1775,7 @@ program
             type: page.type,
             status: page.status,
             spaceKey: page.space?.key,
-            url: `https://${config.domain}/wiki/spaces/${page.space?.key}/pages/${page.id}`,
+            url: `${buildPageUrl(config, `/wiki/spaces/${page.space?.key}/pages/${page.id}`)}`,
             parentId: page.parentId || resolvedPageId
           }))
         };
@@ -1175,7 +1804,7 @@ program
           }
           
           if (options.showUrl) {
-            const url = `https://${config.domain}/wiki/spaces/${page.space?.key}/pages/${page.id}`;
+            const url = `${buildPageUrl(config, `/wiki/spaces/${page.space?.key}/pages/${page.id}`)}`;
             output += `\n   ${chalk.gray(url)}`;
           }
           
@@ -1240,7 +1869,7 @@ function printTree(nodes, config, options, depth = 1) {
     }
     
     if (options.showUrl) {
-      const url = `https://${config.domain}/wiki/spaces/${node.space?.key}/pages/${node.id}`;
+      const url = `${buildPageUrl(config, `/wiki/spaces/${node.space?.key}/pages/${node.id}`)}`;
       output += `\n${indent}${isLast ? '    ' : '│   '}${chalk.gray(url)}`;
     }
     
@@ -1252,8 +1881,99 @@ function printTree(nodes, config, options, depth = 1) {
   });
 }
 
-if (process.argv.length <= 2) {
-  program.help({ error: false });
-}
+// Profile management commands
+const profileCmd = program
+  .command('profile')
+  .description('Manage configuration profiles');
+
+profileCmd
+  .command('list')
+  .description('List all configuration profiles')
+  .action(() => {
+    const { profiles } = listProfiles();
+    if (profiles.length === 0) {
+      console.log(chalk.yellow('No profiles configured. Run "confluence init" to create one.'));
+      return;
+    }
+    console.log(chalk.blue('Configuration profiles:\n'));
+    profiles.forEach(p => {
+      const marker = p.active ? chalk.green(' (active)') : '';
+      const readOnlyBadge = p.readOnly ? chalk.red(' [read-only]') : '';
+      console.log(`  ${p.active ? chalk.green('*') : ' '} ${chalk.cyan(p.name)}${marker}${readOnlyBadge} - ${chalk.gray(p.domain)}`);
+    });
+  });
 
-program.parse(process.argv);
+profileCmd
+  .command('use <name>')
+  .description('Set the active configuration profile')
+  .action((name) => {
+    try {
+      setActiveProfile(name);
+      console.log(chalk.green(`Switched to profile "${name}"`));
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+profileCmd
+  .command('add <name>')
+  .description('Add a new configuration profile interactively')
+  .option('-d, --domain <domain>', 'Confluence domain')
+  .option('--protocol <protocol>', 'Protocol (http or https)')
+  .option('-p, --api-path <path>', 'REST API path')
+  .option('-a, --auth-type <type>', 'Authentication type (basic or bearer)')
+  .option('-e, --email <email>', 'Email or username for basic auth')
+  .option('-t, --token <token>', 'API token')
+  .option('--read-only', 'Set profile to read-only mode (blocks write operations)')
+  .action(async (name, options) => {
+    if (!isValidProfileName(name)) {
+      console.error(chalk.red('Invalid profile name. Use only letters, numbers, hyphens, and underscores.'));
+      process.exit(1);
+    }
+    await initConfig({ ...options, profile: name });
+  });
+
+profileCmd
+  .command('remove <name>')
+  .description('Remove a configuration profile')
+  .action(async (name) => {
+    try {
+      const { confirmed } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirmed',
+        message: `Delete profile "${name}"?`,
+        default: false
+      }]);
+      if (!confirmed) {
+        console.log(chalk.yellow('Cancelled.'));
+        return;
+      }
+      deleteProfile(name);
+      console.log(chalk.green(`Profile "${name}" removed.`));
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Exported for testing
+module.exports = {
+  program,
+  _test: {
+    EXPORT_MARKER,
+    writeExportMarker,
+    isExportDirectory,
+    uniquePathFor,
+    exportRecursive,
+    sanitizeTitle,
+    assertWritable,
+  },
+};
+
+if (require.main === module) {
+  if (process.argv.length <= 2) {
+    program.help({ error: false });
+  }
+  program.parse(process.argv);
+}