confluence-cli 2.3.1 → 2.5.0

package/README.md

@@ -466,7 +466,14 @@ confluence export 123456789 --skip-attachments
 
 ### List Spaces
 ```bash
+# Default: up to 500 spaces (paginated automatically across requests)
 confluence spaces
+
+# Increase the cap when your tenant has more than 500 spaces
+confluence spaces --limit 2000
+
+# Fetch every space, regardless of how many pages it takes
+confluence spaces --all
 ```
 
 ### List Child Pages
@@ -691,7 +698,7 @@ confluence stats
 | `read <pageId_or_url>` | Read page content | `--format <html\|text\|storage\|markdown>` |
 | `info <pageId_or_url>` | Get page information | `--format <text\|json>` |
 | `search <query>` | Search for pages | `--limit <number>` |
-| `spaces` | List available spaces | `--limit <number>` |
+| `spaces` | List available spaces | `--limit <number>`, `--all` |
 | `find <title>` | Find a page by its title | `--space <spaceKey>` |
 | `children <pageId>` | List child pages of a page | `--recursive`, `--max-depth <number>`, `--format <list\|tree\|json>`, `--show-url`, `--show-id` |
 | `create <title> <spaceKey>` | Create a new page or folder | `--content <string>`, `--file <path>`, `--format <storage\|html\|markdown>`, `--type <page\|folder>` |
@@ -700,6 +707,9 @@ confluence stats
 | `update <pageId>` | Update a page's title or content | `--title <string>`, `--content <string>`, `--file <path>`, `--format <storage\|html\|markdown>` |
 | `move <pageId_or_url> <newParentId_or_url>` | Move a page to a new parent location | `--title <string>` |
 | `delete <pageId_or_url>` | Delete a page by ID or URL | `--yes` |
+| `versions <pageId_or_url>` | List historical versions of a page | `--format <text\|json>` |
+| `version-delete <pageId_or_url> <versionNumber>` | Delete a single non-current version of a page | `--yes` |
+| `versions-purge <pageId_or_url>` | Delete every non-current historical version of a page | `--yes`, `--throttle <seconds>` |
 | `edit <pageId>` | Export page content for editing | `--output <file>` |
 | `attachments <pageId_or_url>` | List or download attachments for a page | `--limit <number>`, `--pattern <glob>`, `--download`, `--dest <directory>` |
 | `attachment-upload <pageId_or_url>` | Upload attachments to a page | `--file <path>`, `--comment <text>`, `--replace`, `--minor-edit` |

package/bin/confluence.js

@@ -154,15 +154,17 @@ program
 program
   .command('spaces')
   .description('List Confluence spaces')
-  .option('-l, --limit <limit>', 'Limit number of results', '500')
+  .option('-l, --limit <limit>', 'Maximum total spaces to return across paginated requests', '500')
+  .option('--all', 'Fetch every space, paginating through all results (overrides --limit)')
   .action(async (options) => {
     const analytics = new Analytics();
     try {
       const config = getConfig(getProfileName());
       const client = new ConfluenceClient(config);
-      const spaces = await client.getSpaces(parseInt(options.limit));
-      
-      console.log(chalk.blue('Available spaces:'));
+      const maxResults = options.all ? null : parseInt(options.limit);
+      const spaces = await client.getSpaces(maxResults);
+
+      console.log(chalk.blue(`Available spaces (${spaces.length}):`));
       spaces.forEach(space => {
         console.log(`${chalk.green(space.key)} - ${space.name}`);
       });
@@ -451,6 +453,147 @@ program
     }
   });
 
+// List historical versions of a page
+program
+  .command('versions <pageId>')
+  .description('List historical versions of a Confluence page')
+  .option('--format <format>', 'Output format: text or json (default: text)', 'text')
+  .action(async (pageId, options) => {
+    const analytics = new Analytics();
+    try {
+      const config = getConfig(getProfileName());
+      const client = new ConfluenceClient(config);
+      const resolvedId = String(await client.extractPageId(pageId));
+      const versions = await client.listVersions(resolvedId);
+
+      if (options.format === 'json') {
+        console.log(JSON.stringify({ pageId: resolvedId, versions }, null, 2));
+      } else {
+        const max = versions.length ? Math.max(...versions.map(v => v.number)) : 0;
+        console.log(chalk.blue(`Versions for page ${resolvedId} (${versions.length} total):`));
+        if (versions.length === 0) {
+          console.log(chalk.yellow('  (no versions returned)'));
+        }
+        for (const v of versions) {
+          const tag = v.number === max ? chalk.green(' [current]') : '';
+          const author = v.by || 'unknown';
+          const note = v.message ? `  — ${v.message}` : '';
+          console.log(`  v${v.number}${tag}  ${v.when}  ${author}${note}`);
+        }
+      }
+      analytics.track('versions', true);
+    } catch (error) {
+      handleCommandError(analytics, 'versions', error);
+    }
+  });
+
+// Delete a single historical version of a page
+program
+  .command('version-delete <pageId> <versionNumber>')
+  .description('Delete a single historical version of a page (cannot delete the current version)')
+  .option('-y, --yes', 'Skip confirmation prompt')
+  .action(async (pageId, versionNumber, options) => {
+    const analytics = new Analytics();
+    try {
+      const config = getConfig(getProfileName());
+      assertWritable(config);
+      const client = new ConfluenceClient(config);
+      const resolvedId = String(await client.extractPageId(pageId));
+      const n = Number(versionNumber);
+
+      if (!options.yes) {
+        const { confirmed } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'confirmed',
+          default: false,
+          message: `Delete v${n} of page ${resolvedId}? This cannot be undone.`
+        }]);
+        if (!confirmed) {
+          console.log(chalk.yellow('Cancelled.'));
+          analytics.track('version_delete_cancel', true);
+          return;
+        }
+      }
+
+      const result = await client.deleteVersion(resolvedId, n);
+      const note = result.viaExperimental ? chalk.yellow(' (via experimental endpoint)') : '';
+      console.log(chalk.green(`✅ Deleted v${result.versionNumber} of page ${result.id}${note}`));
+      analytics.track('version_delete', true);
+    } catch (error) {
+      handleCommandError(analytics, 'version_delete', error);
+    }
+  });
+
+// Convenience: delete every non-current historical version of a page,
+// keeping only the current one.
+program
+  .command('versions-purge <pageId>')
+  .description('Delete every non-current historical version of a page (keeps only current)')
+  .option('-y, --yes', 'Skip confirmation prompt')
+  .option('--throttle <seconds>', 'Sleep between version-delete calls', '0')
+  .action(async (pageId, options) => {
+    const analytics = new Analytics();
+    try {
+      const config = getConfig(getProfileName());
+      assertWritable(config);
+      const client = new ConfluenceClient(config);
+      const resolvedId = String(await client.extractPageId(pageId));
+      const versions = await client.listVersions(resolvedId);
+
+      if (versions.length === 0) {
+        console.log(chalk.yellow(`No versions returned for page ${resolvedId}.`));
+        analytics.track('versions_purge', true);
+        return;
+      }
+      const max = Math.max(...versions.map(v => v.number));
+      const historicalCount = versions.filter(v => v.number !== max).length;
+      if (historicalCount === 0) {
+        console.log(chalk.yellow(`Only current version v${max} exists for page ${resolvedId}; nothing to purge.`));
+        analytics.track('versions_purge', true);
+        return;
+      }
+
+      if (!options.yes) {
+        const { confirmed } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'confirmed',
+          default: false,
+          message: `Delete ${historicalCount} historical version(s) of page ${resolvedId}? Current version (v${max}) will be kept.`
+        }]);
+        if (!confirmed) {
+          console.log(chalk.yellow('Cancelled.'));
+          analytics.track('versions_purge_cancel', true);
+          return;
+        }
+      }
+
+      const throttleMs = Math.max(0, parseFloat(options.throttle || '0')) * 1000;
+      const result = await client.purgeNonCurrentVersions(resolvedId, {
+        onProgress: async (event) => {
+          if (event.kind === 'deleted') {
+            const note = event.viaExperimental ? chalk.yellow(' (experimental)') : '';
+            console.log(chalk.green(`  ✓ deleted v${event.versionNumber}${note}`));
+          } else if (event.kind === 'failed') {
+            console.log(chalk.red(`  ✗ v${event.versionNumber}: ${event.message}`));
+          }
+          if (throttleMs > 0) {
+            await new Promise(r => setTimeout(r, throttleMs));
+          }
+        }
+      });
+
+      console.log('');
+      console.log(chalk.green(`✅ Purge complete for page ${result.id}: ` +
+        `${result.deleted} deleted, ${result.failed} failed, kept v${result.kept}.`));
+      analytics.track('versions_purge', result.failed === 0);
+      if (result.failed > 0) {
+        process.exitCode = 1;
+      }
+    } catch (error) {
+      handleCommandError(analytics, 'versions_purge', error);
+    }
+  });
+
 // Edit command - opens page content for editing
 program
   .command('edit <pageId>')

package/lib/confluence-client.js

@@ -437,20 +437,58 @@ class ConfluenceClient {
   }
 
   /**
-   * Get spaces
+   * List a single page of spaces with pagination metadata
    */
-  async getSpaces(limit = 500) {
+  async listSpaces(options = {}) {
+    const limit = this.parsePositiveInt(options.limit, 500);
+    const start = this.parsePositiveInt(options.start, 0);
+
     const response = await this.client.get('/space', {
-      params: {
-        limit
-      }
+      params: { limit, start }
     });
 
-    return response.data.results.map(space => ({
-      key: space.key,
-      name: space.name,
-      type: space.type
-    }));
+    const results = Array.isArray(response.data?.results)
+      ? response.data.results.map(space => ({
+        key: space.key,
+        name: space.name,
+        type: space.type
+      }))
+      : [];
+
+    return {
+      results,
+      nextStart: this.parseNextStart(response.data?._links?.next)
+    };
+  }
+
+  /**
+   * Get spaces, paginating through results until maxResults is reached or
+   * the server stops returning a `_links.next`. Pass `null` to fetch every space.
+   */
+  async getSpaces(maxResults = 500, options = {}) {
+    const cap = maxResults === null || maxResults === undefined
+      ? null
+      : this.parsePositiveInt(maxResults, 500);
+    const pageSize = this.parsePositiveInt(options.pageSize, 500);
+    let start = this.parsePositiveInt(options.start, 0);
+    const spaces = [];
+
+    let hasNext = true;
+    while (hasNext) {
+      if (cap !== null && spaces.length >= cap) break;
+      const requestLimit = cap === null
+        ? pageSize
+        : Math.min(pageSize, cap - spaces.length);
+      const page = await this.listSpaces({ limit: requestLimit, start });
+      spaces.push(...page.results);
+
+      hasNext = page.nextStart !== null && page.nextStart !== undefined;
+      if (hasNext) {
+        start = page.nextStart;
+      }
+    }
+
+    return cap !== null ? spaces.slice(0, cap) : spaces;
   }
 
   /**
@@ -1405,6 +1443,148 @@ class ConfluenceClient {
     return { id: String(pageId) };
   }
 
+  /**
+   * Build the absolute URL for the experimental version endpoint.
+   * Confluence Server/Data Center exposes content versions only at
+   * /rest/experimental/ (the modern /rest/api/.../version path 404s
+   * there). Cloud accepts both. We use this as a fallback when the
+   * configured apiPath returns 404/405.
+   */
+  experimentalVersionUrl(pageId, versionNumber = null) {
+    const base = `${this.protocol}://${this.domain}${this.webUrlPrefix}/rest/experimental/content/${pageId}/version`;
+    return versionNumber == null ? base : `${base}/${versionNumber}`;
+  }
+
+  /**
+   * List historical versions of a page. Returns an array sorted by
+   * version number ascending. Each entry has: number, when, by,
+   * minorEdit, message.
+   *
+   * Pages with many versions (e.g. heavily edited or repeatedly
+   * uploaded) may exceed a single page of results, so this paginates
+   * via start/limit until all versions are collected.
+   *
+   * Path strategy: try the configured /rest/api/ path first; on 404
+   * or 405 (typical of Server/DC where the version endpoints live
+   * under /rest/experimental/), fall back transparently. Subsequent
+   * pages use whichever path succeeded so we don't double the
+   * round-trip count on long histories.
+   */
+  async listVersions(pageIdOrUrl) {
+    const pageId = await this.extractPageId(pageIdOrUrl);
+    const limit = 200;
+    let start = 0;
+    let useExperimental = false;
+    const all = [];
+    while (true) {
+      let response;
+      try {
+        const url = useExperimental
+          ? this.experimentalVersionUrl(pageId)
+          : `/content/${pageId}/version`;
+        response = await this.client.get(url, { params: { start, limit } });
+      } catch (error) {
+        const status = error.response && error.response.status;
+        if (!useExperimental && (status === 404 || status === 405)) {
+          useExperimental = true;
+          continue;
+        }
+        throw error;
+      }
+      const results = response.data.results || [];
+      all.push(...results);
+      if (results.length < limit) {
+        break;
+      }
+      start += limit;
+    }
+    return all.map(v => ({
+      number: v.number,
+      when: v.when,
+      by: v.by ? (v.by.displayName || v.by.publicName || v.by.email || null) : null,
+      minorEdit: v.minorEdit === true,
+      message: v.message || ''
+    })).sort((a, b) => a.number - b.number);
+  }
+
+  /**
+   * Delete a single historical version of a page.
+   *
+   * Confluence refuses to delete the current version (returns 400).
+   * The "rolled up into the next version" wording in Atlassian's
+   * docs refers to the diff representation; the deleted version's
+   * snapshot is removed from page history.
+   *
+   * Server/DC instances expose this only at /rest/experimental/, so
+   * a 404 or 405 on the configured /rest/api/ path triggers a
+   * one-shot retry against the experimental URL.
+   */
+  async deleteVersion(pageIdOrUrl, versionNumber) {
+    const pageId = await this.extractPageId(pageIdOrUrl);
+    const n = Number(versionNumber);
+    if (!Number.isInteger(n) || n < 1) {
+      throw new Error(`versionNumber must be a positive integer, got: ${versionNumber}`);
+    }
+    try {
+      await this.client.delete(`/content/${pageId}/version/${n}`);
+      return { id: String(pageId), versionNumber: n, viaExperimental: false };
+    } catch (error) {
+      const status = error.response && error.response.status;
+      if (status !== 404 && status !== 405) {
+        throw error;
+      }
+      await this.client.delete(this.experimentalVersionUrl(pageId, n));
+      return { id: String(pageId), versionNumber: n, viaExperimental: true };
+    }
+  }
+
+  /**
+   * Delete every non-current version of a page. Used to purge the
+   * historical content snapshots that may still hold a leaked secret
+   * even after the current version has been overwritten with a
+   * redacted copy.
+   *
+   * Returns { id, kept, deleted, failed } where `kept` is the version
+   * number that survived (the current one) and `deleted`/`failed` are
+   * the counts of historical versions removed/errored.
+   */
+  async purgeNonCurrentVersions(pageIdOrUrl, options = {}) {
+    const onProgress = typeof options.onProgress === 'function' ? options.onProgress : () => {};
+    const pageId = String(await this.extractPageId(pageIdOrUrl));
+    const versions = await this.listVersions(pageId);
+
+    if (versions.length === 0) {
+      return { id: pageId, kept: null, deleted: 0, failed: 0, errors: [] };
+    }
+
+    const max = Math.max(...versions.map(v => v.number));
+    // Delete in descending order. Some Confluence builds renumber
+    // historical versions when an earlier one is removed; deleting
+    // newest-first sidesteps the resulting off-by-one drift.
+    const toDelete = versions
+      .filter(v => v.number !== max)
+      .map(v => v.number)
+      .sort((a, b) => b - a);
+
+    let deleted = 0;
+    const errors = [];
+    for (const n of toDelete) {
+      try {
+        const res = await this.deleteVersion(pageId, n);
+        deleted += 1;
+        onProgress({ kind: 'deleted', versionNumber: n, viaExperimental: res.viaExperimental });
+      } catch (error) {
+        const detail = error.response
+          ? `HTTP ${error.response.status} ${error.response.statusText || ''}`.trim()
+          : error.message;
+        errors.push({ versionNumber: n, message: detail });
+        onProgress({ kind: 'failed', versionNumber: n, message: detail });
+      }
+    }
+
+    return { id: pageId, kept: max, deleted, failed: errors.length, errors };
+  }
+
   /**
    * Search for a page by title and space
    */

package/lib/html-to-storage.js

@@ -344,10 +344,11 @@ function dispatchTag(node, ctx) {
     return `<img${renderAttrs(node.attribs)}>`;
   case 'ul':
   case 'ol':
-    return `<${node.name}>${walkChildren(node, ctx)}</${node.name}>`;
+    return `<${node.name}${renderAttrs(node.attribs)}>${walkChildren(node, ctx)}</${node.name}>`;
   case 'li': {
     const inner = walkChildren(node, ctx);
-    return shouldWrapInP(node) ? `<li><p>${inner}</p></li>` : `<li>${inner}</li>`;
+    const open = `<li${renderAttrs(node.attribs)}>`;
+    return shouldWrapInP(node) ? `${open}<p>${inner}</p></li>` : `${open}${inner}</li>`;
   }
   case 'pre':
     return convertCodeBlock(node, ctx);

package/npm-shrinkwrap.json

@@ -1,15 +1,15 @@
 {
   "name": "confluence-cli",
-  "version": "2.3.1",
+  "version": "2.5.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "confluence-cli",
-      "version": "2.3.1",
+      "version": "2.5.0",
       "license": "MIT",
       "dependencies": {
-        "axios": "^1.15.0",
+        "axios": "~1.15.2",
         "chalk": "^4.1.2",
         "commander": "^11.1.0",
         "entities": "^4.5.0",
@@ -129,9 +129,9 @@
       "license": "MIT"
     },
     "node_modules/axios": {
-      "version": "1.15.0",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-1.15.0.tgz",
-      "integrity": "sha512-wWyJDlAatxk30ZJer+GeCWS209sA42X+N5jU2jy6oHTp7ufw8uzUTVFBX9+wTfAlhiJXGS0Bq7X6efruWjuK9Q==",
+      "version": "1.15.2",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.15.2.tgz",
+      "integrity": "sha512-wLrXxPtcrPTsNlJmKjkPnNPK2Ihe0hn0wGSaTEiHRPxwjvJwT3hKmXF4dpqxmPO9SoNb2FsYXj/xEo0gHN+D5A==",
       "license": "MIT",
       "dependencies": {
         "follow-redirects": "^1.15.11",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "confluence-cli",
-  "version": "2.3.1",
+  "version": "2.5.0",
   "description": "A command-line interface for Atlassian Confluence with page creation and editing capabilities",
   "main": "index.js",
   "bin": {
@@ -23,7 +23,7 @@
   "author": "pchuri",
   "license": "MIT",
   "dependencies": {
-    "axios": "^1.15.0",
+    "axios": "~1.15.2",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "entities": "^4.5.0",