confluence-cli 2.3.0 → 2.4.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>` |

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}`);
       });

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;
   }
 
   /**

package/lib/macro-converter.js

@@ -9,6 +9,25 @@ const CALLOUT_MARKERS = ['info', 'warning', 'note'];
 // and survives editor / formatter / lint passes that strip invisible chars.
 const STASH_DELIM = '\uE000';
 
+// Inline HTML tags that markdown has no native syntax for. The walker emits
+// them as raw HTML on storage\u2192markdown, so they must round-trip back through
+// markdownToStorage; without this whitelist, MarkdownIt (html: false) escapes
+// them to literal `<...>` and the formatting is lost.
+//
+// The lookahead `(?=[\s/>])` after the tag name rejects strings that look
+// like markdown autolinks (e.g. `<u@example.com>`, `<sub:foo>`) \u2014 a plain
+// `\b` word boundary would let these through and break linkify.
+//
+// The body alternation `"[^"]*"|'[^']*'|[^>]` makes the match quote-aware
+// so a literal `>` inside a quoted attribute value (e.g.
+// `<mark title="1>0">`) does not terminate the tag prematurely.
+const PASSTHROUGH_TAG_RE = /<\/?(?:u|sub|sup|mark)(?=[\s/>])(?:"[^"]*"|'[^']*'|[^>])*>/gi;
+// Single-backtick inline code spans. Block-level code (fenced + indented) is
+// detected via MarkdownIt's tokenizer in `_findCodeRanges` because a regex
+// can't reliably distinguish a 4-space-indented code block from a list-item
+// continuation that happens to align to four spaces.
+const INLINE_CODE_RE = /`[^`\n]+`/g;
+
 class MacroConverter {
   constructor({ isCloud = false, webUrlPrefix = '', buildUrl = null, linkStyle = null } = {}) {
     this._isCloud = isCloud;
@@ -57,13 +76,79 @@ class MacroConverter {
   }
 
   markdownToStorage(markdown) {
-    const html = this.markdown.render(markdown);
-    return this.htmlToConfluenceStorage(html);
+    return this.htmlToConfluenceStorage(this._renderMarkdownToHtml(markdown));
   }
 
   markdownToNativeStorage(markdown) {
-    const html = this.markdown.render(markdown);
-    return this.htmlToConfluenceStorage(html);
+    return this.htmlToConfluenceStorage(this._renderMarkdownToHtml(markdown));
+  }
+
+  // Pre-stashes whitelisted inline HTML so MarkdownIt won't escape it, renders,
+  // then restores. Code regions (fenced, indented, and inline) are skipped so a
+  // literal `<u>` typed inside a code block survives MarkdownIt's escape and
+  // round-trips as text rather than as a real tag — which would otherwise be
+  // smuggled past the escape and dropped by `convertCodeBlock`'s text-only
+  // child collection in html-to-storage.
+  _renderMarkdownToHtml(markdown) {
+    const codeRanges = this._findCodeRanges(markdown);
+    const htmlStash = [];
+    const stashHtml = (text) => text.replace(PASSTHROUGH_TAG_RE, (m) => {
+      htmlStash.push(m);
+      return `${STASH_DELIM}H${htmlStash.length - 1}${STASH_DELIM}`;
+    });
+
+    let src = '';
+    let pos = 0;
+    for (const [start, end] of codeRanges) {
+      src += stashHtml(markdown.slice(pos, start));
+      src += markdown.slice(start, end);
+      pos = end;
+    }
+    src += stashHtml(markdown.slice(pos));
+
+    const html = this.markdown.render(src);
+    return html.replace(
+      new RegExp(`${STASH_DELIM}H(\\d+)${STASH_DELIM}`, 'g'),
+      (m, i) => htmlStash[+i] ?? m,
+    );
+  }
+
+  // Returns merged, sorted character ranges covering all code regions in the
+  // markdown source — fenced and indented blocks via MarkdownIt's tokenizer
+  // (which correctly distinguishes them from list-item continuations) and
+  // single-backtick inline spans via regex (MarkdownIt parses these into
+  // `code_inline` tokens but does not expose source positions for them).
+  _findCodeRanges(markdown) {
+    const tokens = this.markdown.parse(markdown, {});
+    const lineStarts = [0];
+    for (let i = 0; i < markdown.length; i++) {
+      if (markdown[i] === '\n') lineStarts.push(i + 1);
+    }
+    const lineToChar = (n) => (n < lineStarts.length ? lineStarts[n] : markdown.length);
+
+    const ranges = [];
+    for (const tok of tokens) {
+      if ((tok.type === 'code_block' || tok.type === 'fence') && tok.map) {
+        ranges.push([lineToChar(tok.map[0]), lineToChar(tok.map[1])]);
+      }
+    }
+    INLINE_CODE_RE.lastIndex = 0;
+    let m;
+    while ((m = INLINE_CODE_RE.exec(markdown)) !== null) {
+      ranges.push([m.index, m.index + m[0].length]);
+    }
+
+    ranges.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+    const merged = [];
+    for (const r of ranges) {
+      const last = merged[merged.length - 1];
+      if (last && r[0] <= last[1]) {
+        last[1] = Math.max(last[1], r[1]);
+      } else {
+        merged.push([r[0], r[1]]);
+      }
+    }
+    return merged;
   }
 
   htmlToConfluenceStorage(html) {

package/lib/storage-walker.js

@@ -200,6 +200,7 @@ class StorageWalker {
     case 'blockquote':
       return this.handleBlockquote(node);
     case 'details': case 'summary':
+    case 'u': case 'sub': case 'sup': case 'mark':
       return `<${tag}>` + this.walkNodes(node.children) + `</${tag}>`;
     case 'ac:structured-macro':
       return this.handleMacro(node);

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "confluence-cli",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "confluence-cli",
-      "version": "2.3.0",
+      "version": "2.4.0",
       "license": "MIT",
       "dependencies": {
         "axios": "^1.15.0",

package/package.json

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