@chenguangyao/devflow-kit 0.1.43

package/src/providers/drivers/intake-confluence.js

@@ -0,0 +1,544 @@
+'use strict';
+/**
+ * Confluence intake driver — zero external dependencies (Node built-in https/http).
+ *
+ * Supported auth:
+ *   PAT  (default)  → Authorization: Bearer <token>
+ *   Basic           → Authorization: Basic base64(user:token)   (set config.user)
+ *
+ * Supported URL formats:
+ *   Server / Data Center:
+ *     https://confluence.corp.com/display/SPACE/Page+Title
+ *     https://confluence.corp.com/pages/viewpage.action?pageId=12345
+ *   Cloud:
+ *     https://myorg.atlassian.net/wiki/spaces/SPACE/pages/12345/Page+Title
+ *
+ * config shape:
+ *   {
+ *     baseUrl:   string   (required) base URL of your Confluence instance
+ *     token:     string   (required) PAT or API token; prefer ${env:CONFLUENCE_TOKEN}
+ *     user:      string   (optional) email/username → Basic Auth; omit → Bearer/PAT
+ *     timeoutMs: number   (optional, default 15000)
+ *   }
+ */
+
+const { Provider, AuthExpiredError } = require('../base.js');
+const log = require('../../utils/log.js');
+
+class ConfluenceIntakeProvider extends Provider {
+  constructor({ name, type, driver, config }) {
+    super({ name, type, driver, config });
+    this.baseUrl = (config.baseUrl || '').replace(/\/+$/, '');
+    this.token   = config.token || '';
+    this.user    = config.user  || '';
+    this.timeoutMs = toInt(config.timeoutMs, 15000);
+  }
+
+  // Match any URL that starts with our configured baseUrl.
+  supports(input) {
+    if (!this.baseUrl) return false;
+    return typeof input === 'string' && input.startsWith(this.baseUrl);
+  }
+
+  /**
+   * Open the browser to the PAT generation page, then prompt for the token
+   * and save it back to providers.json via the rotate flow.
+   *
+   * Called by `devflow provider relogin intake.confluence`.
+   */
+  async login({ interactive = true } = {}) {
+    const base = this.baseUrl;
+    log.raw('');
+    if (base.includes('.atlassian.net')) {
+      const url = 'https://id.atlassian.com/manage/api-tokens';
+      log.info(`Confluence Cloud — 正在打开 API Token 生成页面:`);
+      log.dim(`  ${url}`);
+      openBrowser(url);
+    } else {
+      // Server/DC: PAT 路径因版本和插件而异，列出几种常见路径供用户选择
+      log.info(`Confluence Server/DC — 请在浏览器里按以下顺序尝试找到 Personal Access Tokens：`);
+      log.raw(`  1) 右上角头像 → Profile → Personal Access Tokens`);
+      log.raw(`  2) ${base}/plugins/servlet/de.resolution.apitokenauth/token`);
+      log.raw(`  3) 若以上都找不到，说明 Confluence 版本较旧，请使用 Basic Auth：`);
+      log.raw(`     在 devflow provider rotate intake.confluence 时`);
+      log.raw(`     token 填登录密码，并额外设置 user 为你的用户名`);
+      log.raw('');
+      openBrowser(`${base}/plugins/servlet/de.resolution.apitokenauth/token`);
+    }
+    if (interactive) {
+      log.dim('配置完成后运行：devflow provider rotate intake.confluence');
+    }
+    log.raw('');
+  }
+
+  async validate() {
+    if (!this.baseUrl) return { ok: false, reason: 'baseUrl not configured' };
+    if (!this.token)   return { ok: false, reason: 'token not configured' };
+    try {
+      // Lightweight probe — list 1 space. Works on both Server and Cloud.
+      await this._get('/rest/api/space?limit=1');
+      return { ok: true };
+    } catch (e) {
+      if (e.statusCode === 401) return { ok: false, reason: 'auth failed (401)', needsLogin: true };
+      if (e.statusCode === 403) return { ok: false, reason: 'permission denied (403)' };
+      return { ok: false, reason: e.message };
+    }
+  }
+
+  async fetch(url) {
+    const pageId = extractPageId(url);
+    let data;
+
+    if (pageId) {
+      data = await this._get(`/rest/api/content/${pageId}?expand=body.storage,version,space`);
+    } else {
+      // Fall back: derive space key + title from URL path and search
+      const { spaceKey, title } = extractSpaceTitle(url);
+      if (!spaceKey || !title) {
+        throw new Error(`Cannot extract page ID or space/title from URL: ${url}`);
+      }
+      const cql = `title="${encodeURIComponent(title)}" AND space="${spaceKey}" AND type=page`;
+      const res = await this._get(
+        `/rest/api/content?cql=${encodeURIComponent(cql)}&expand=body.storage,version,space&limit=1`,
+      );
+      if (!res.results || !res.results.length) {
+        // Retry with /rest/api/content?title=...&spaceKey=...
+        const res2 = await this._get(
+          `/rest/api/content?title=${encodeURIComponent(title)}&spaceKey=${encodeURIComponent(spaceKey)}&expand=body.storage,version,space&limit=1`,
+        );
+        if (!res2.results || !res2.results.length) {
+          throw new Error(`Page not found in space ${spaceKey}: "${title}"`);
+        }
+        data = res2.results[0];
+      } else {
+        data = res.results[0];
+      }
+    }
+
+    const title  = data.title || url;
+    const contentId = data.id || pageId;
+    const stored = (data.body && data.body.storage && data.body.storage.value) || '';
+    const body_md = confluenceStorageToMd(stored);
+    const attachments = contentId ? await this._fetchImageAttachments(contentId) : [];
+    return { title, body_md, attachments, source: { type: 'url', ref: url } };
+  }
+
+  async search(q) {
+    try {
+      const cql = `text~"${q}" AND type=page`;
+      const res  = await this._get(
+        `/rest/api/content/search?cql=${encodeURIComponent(cql)}&limit=10&expand=space`,
+      );
+      return (res.results || []).map((r) => ({
+        title:   r.title,
+        url:     this.baseUrl + ((r._links && r._links.webui) || ''),
+        snippet: (r.excerpt || '').replace(/<[^>]+>/g, '').slice(0, 200),
+      }));
+    } catch { return []; }
+  }
+
+  // ── internal helpers ──────────────────────────────────────────────────────
+
+  _authHeader() {
+    if (this.user) {
+      return 'Basic ' + Buffer.from(`${this.user}:${this.token}`).toString('base64');
+    }
+    return `Bearer ${this.token}`;
+  }
+
+  _get(apiPath) {
+    return new Promise((resolve, reject) => {
+      let urlStr = this.baseUrl + apiPath;
+      // Cloud Confluence REST path lives under /wiki/
+      if (this.baseUrl.includes('.atlassian.net') && !apiPath.startsWith('/wiki')) {
+        urlStr = this.baseUrl + '/wiki' + apiPath;
+      }
+
+      let parsed;
+      try { parsed = new URL(urlStr); }
+      catch (e) { return reject(new Error(`Invalid Confluence URL: ${urlStr}`)); }
+
+      const mod  = parsed.protocol === 'https:' ? require('https') : require('http');
+      const opts = {
+        hostname: parsed.hostname,
+        port:     parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+        path:     parsed.pathname + parsed.search,
+        method:   'GET',
+        headers:  {
+          Authorization: this._authHeader(),
+          Accept:        'application/json',
+          'User-Agent':  'devflow-kit/1.0',
+        },
+        timeout: this.timeoutMs,
+      };
+
+      const req = mod.request(opts, (res) => {
+        const chunks = [];
+        res.on('data',  (c) => chunks.push(c));
+        res.on('end', () => {
+          const body = Buffer.concat(chunks).toString('utf8');
+          if (res.statusCode === 401) {
+            const err = new Error('Confluence auth failed (401) — check token/user');
+            err.statusCode = 401;
+            return reject(err);
+          }
+          if (res.statusCode >= 400) {
+            const err = new Error(`Confluence API error ${res.statusCode}: ${body.slice(0, 300)}`);
+            err.statusCode = res.statusCode;
+            return reject(err);
+          }
+          try { resolve(JSON.parse(body)); }
+          catch (e) { reject(new Error(`Non-JSON Confluence response: ${body.slice(0, 200)}`)); }
+        });
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error(`Confluence request timed out (${this.timeoutMs}ms): ${urlStr}`));
+      });
+      req.on('error', reject);
+      req.end();
+    });
+  }
+
+  async _fetchImageAttachments(contentId) {
+    let res;
+    try {
+      res = await this._get(`/rest/api/content/${contentId}/child/attachment?limit=100&expand=metadata`);
+    } catch {
+      return [];
+    }
+    const out = [];
+    for (const att of res.results || []) {
+      const filename = att.title || '';
+      const mediaType = (att.metadata && att.metadata.mediaType) || '';
+      if (!isImageAttachment(filename, mediaType)) continue;
+      const download = att._links && att._links.download;
+      if (!download) continue;
+      try {
+        const data = await this._getBinary(download);
+        out.push({ filename, mediaType, data });
+      } catch {
+        // Keep ingest resilient: missing image permissions should not block text intake.
+      }
+    }
+    return out;
+  }
+
+  _getBinary(downloadPathOrUrl, redirects = 3) {
+    return new Promise((resolve, reject) => {
+      let urlStr = downloadPathOrUrl;
+      if (!/^https?:\/\//i.test(urlStr)) {
+        urlStr = this.baseUrl + (urlStr.startsWith('/') ? urlStr : '/' + urlStr);
+      }
+      if (this.baseUrl.includes('.atlassian.net') && !new URL(urlStr).pathname.startsWith('/wiki/')) {
+        const u = new URL(urlStr);
+        u.pathname = '/wiki' + u.pathname;
+        urlStr = u.toString();
+      }
+
+      let parsed;
+      try { parsed = new URL(urlStr); }
+      catch { return reject(new Error(`Invalid Confluence download URL: ${urlStr}`)); }
+
+      const mod = parsed.protocol === 'https:' ? require('https') : require('http');
+      const opts = {
+        hostname: parsed.hostname,
+        port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+        path: parsed.pathname + parsed.search,
+        method: 'GET',
+        headers: {
+          Authorization: this._authHeader(),
+          Accept: '*/*',
+          'User-Agent': 'devflow-kit/1.0',
+        },
+        timeout: this.timeoutMs,
+      };
+
+      const req = mod.request(opts, (res) => {
+        const chunks = [];
+        res.on('data', (c) => chunks.push(c));
+        res.on('end', () => {
+          if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location && redirects > 0) {
+            return this._getBinary(res.headers.location, redirects - 1).then(resolve, reject);
+          }
+          if (res.statusCode >= 400) {
+            return reject(new Error(`Confluence attachment download failed ${res.statusCode}`));
+          }
+          resolve(Buffer.concat(chunks));
+        });
+      });
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error(`Confluence attachment download timed out (${this.timeoutMs}ms): ${urlStr}`));
+      });
+      req.on('error', reject);
+      req.end();
+    });
+  }
+}
+
+function isImageAttachment(filename, mediaType) {
+  if (mediaType && /^image\//i.test(mediaType)) return true;
+  return /\.(png|jpe?g|gif|webp|svg|bmp)$/i.test(filename || '');
+}
+
+// ── URL parsing ──────────────────────────────────────────────────────────────
+
+function extractPageId(url) {
+  // ?pageId=12345  or  &pageId=12345
+  const m1 = /[?&]pageId=(\d+)/.exec(url);
+  if (m1) return m1[1];
+  // /pages/12345[/] — Cloud and modern Server style
+  const m2 = /\/pages\/(\d+)/.exec(url);
+  if (m2) return m2[1];
+  return null;
+}
+
+function extractSpaceTitle(url) {
+  // /display/SPACE/Title or /display/SPACE/Title+With+Spaces
+  const m1 = /\/display\/([^/?#]+)\/([^?#]+)/.exec(url);
+  if (m1) {
+    return {
+      spaceKey: m1[1],
+      title:    decodeURIComponent(m1[2].replace(/\+/g, ' ')),
+    };
+  }
+  // /wiki/spaces/SPACE/pages/ID/Title
+  const m2 = /\/spaces\/([^/?#]+)\/pages\/\d+\/([^?#]+)/.exec(url);
+  if (m2) {
+    return {
+      spaceKey: m2[1],
+      title:    decodeURIComponent(m2[2].replace(/\+/g, ' ')),
+    };
+  }
+  return {};
+}
+
+// ── Confluence Storage Format → Markdown ─────────────────────────────────────
+//
+// Confluence Storage Format is XHTML + <ac:*> / <ri:*> macros.
+// This converter handles common elements with zero external deps.
+// Unknown elements are stripped (tags removed, content kept).
+
+function confluenceStorageToMd(html) {
+  if (!html) return '';
+
+  let s = html;
+
+  // ── 1. Confluence macros ──────────────────────────────────────────────────
+
+  // Code blocks: <ac:structured-macro ac:name="code">...<ac:plain-text-body><![CDATA[...]]></ac:plain-text-body>
+  s = s.replace(
+    /<ac:structured-macro[^>]*ac:name="code"[^>]*>[\s\S]*?<ac:parameter[^>]*ac:name="language"[^>]*>([^<]*)<\/ac:parameter>[\s\S]*?<!\[CDATA\[([\s\S]*?)\]\]>[\s\S]*?<\/ac:structured-macro>/gi,
+    (_, lang, code) => `\n\`\`\`${lang.trim()}\n${code}\`\`\`\n`,
+  );
+  // Code blocks without language parameter
+  s = s.replace(
+    /<ac:structured-macro[^>]*ac:name="code"[^>]*>[\s\S]*?<!\[CDATA\[([\s\S]*?)\]\]>[\s\S]*?<\/ac:structured-macro>/gi,
+    (_, code) => `\n\`\`\`\n${code}\`\`\`\n`,
+  );
+
+  // Info/warning/note panels: keep content, add a > blockquote prefix
+  s = s.replace(
+    /<ac:structured-macro[^>]*ac:name="(info|note|warning|tip)"[^>]*>([\s\S]*?)<\/ac:structured-macro>/gi,
+    (_, type, inner) => `\n> **${type.toUpperCase()}**\n>\n${stripTags(inner).split('\n').map((l) => `> ${l}`).join('\n')}\n`,
+  );
+
+  // JIRA macro → render as inline reference
+  s = s.replace(
+    /<ac:structured-macro[^>]*ac:name="jira"[^>]*>([\s\S]*?)<\/ac:structured-macro>/gi,
+    (_, inner) => {
+      const keyMatch = inner.match(/<ac:parameter[^>]*ac:name="key"[^>]*>([^<]+)<\/ac:parameter>/i);
+      return keyMatch ? `[JIRA: ${keyMatch[1]}]` : '';
+    },
+  );
+
+  // Status macro → keep label text
+  s = s.replace(
+    /<ac:structured-macro[^>]*ac:name="status"[^>]*>([\s\S]*?)<\/ac:structured-macro>/gi,
+    (_, inner) => {
+      const titleMatch = inner.match(/<ac:parameter[^>]*ac:name="title"[^>]*>([^<]+)<\/ac:parameter>/i);
+      return titleMatch ? `**[${titleMatch[1]}]**` : '';
+    },
+  );
+
+  // Strip all remaining ac:structured-macro blocks (keep plain-text-body / rich-text-body content)
+  s = s.replace(/<ac:plain-text-body[^>]*><!\[CDATA\[([\s\S]*?)\]\]><\/ac:plain-text-body>/gi, '$1');
+  s = s.replace(/<ac:rich-text-body[^>]*>([\s\S]*?)<\/ac:rich-text-body>/gi, '$1');
+  s = s.replace(/<ac:structured-macro[\s\S]*?<\/ac:structured-macro>/gi, '');
+
+  // ac:image → render attachment name as image reference
+  s = s.replace(
+    /<ac:image[^>]*>([\s\S]*?)<\/ac:image>/gi,
+    (_, inner) => {
+      const filenameMatch = inner.match(/ri:filename="([^"]+)"/i);
+      const urlMatch = inner.match(/ri:value="([^"]+)"/i);
+      const src = urlMatch ? urlMatch[1] : (filenameMatch ? filenameMatch[1] : '');
+      const alt = filenameMatch ? filenameMatch[1] : '';
+      return src ? `![${alt}](${src})` : '';
+    },
+  );
+
+  // Confluence links: <ac:link><ri:page ri:content-title="Title"/><ac:plain-text-link-body><![CDATA[label]]></ac:plain-text-link-body></ac:link>
+  s = s.replace(
+    /<ac:link[^>]*>[\s\S]*?<ri:page[^>]*ri:content-title="([^"]+)"[^>]*\/?>[\s\S]*?<!\[CDATA\[([\s\S]*?)\]\]>[\s\S]*?<\/ac:link>/gi,
+    (_, title, label) => `[${label || title}](${title})`,
+  );
+  s = s.replace(/<ac:link[^>]*>[\s\S]*?<\/ac:link>/gi, '');
+
+  // Strip remaining ac:* and ri:* tags
+  s = s.replace(/<\/?ac:[^>]*>/gi, '');
+  s = s.replace(/<\/?ri:[^>]*>/gi, '');
+
+  // ── 2. Standard HTML → Markdown ──────────────────────────────────────────
+
+  // Headings
+  for (let i = 6; i >= 1; i--) {
+    const hashes = '#'.repeat(i);
+    s = s.replace(new RegExp(`<h${i}[^>]*>([\\s\\S]*?)<\\/h${i}>`, 'gi'),
+      (_, inner) => `\n${hashes} ${stripTags(inner).trim()}\n`);
+  }
+
+  // Horizontal rules
+  s = s.replace(/<hr[^>]*\/?>/gi, '\n---\n');
+
+  // Line breaks
+  s = s.replace(/<br[^>]*\/?>/gi, '\n');
+
+  // Bold
+  s = s.replace(/<(strong|b)[^>]*>([\s\S]*?)<\/\1>/gi, (_, __, inner) => `**${stripTags(inner).trim()}**`);
+
+  // Italic
+  s = s.replace(/<(em|i)[^>]*>([\s\S]*?)<\/\1>/gi, (_, __, inner) => `*${stripTags(inner).trim()}*`);
+
+  // Strikethrough
+  s = s.replace(/<(s|del|strike)[^>]*>([\s\S]*?)<\/\1>/gi, (_, __, inner) => `~~${stripTags(inner).trim()}~~`);
+
+  // Inline code
+  s = s.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, (_, inner) => `\`${inner}\``);
+
+  // Pre blocks (without inner code already replaced)
+  s = s.replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, (_, inner) => `\n\`\`\`\n${stripTags(inner)}\`\`\`\n`);
+
+  // Links
+  s = s.replace(/<a[^>]+href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi,
+    (_, href, inner) => `[${stripTags(inner).trim()}](${href})`);
+
+  // Images
+  s = s.replace(/<img[^>]+src="([^"]*)"[^>]*(?:alt="([^"]*)")?[^>]*\/?>/gi,
+    (_, src, alt) => `![${alt || ''}](${src})`);
+
+  // Tables
+  s = convertTables(s);
+
+  // Lists (must come after table to avoid interference)
+  s = convertLists(s);
+
+  // Paragraphs
+  s = s.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi,
+    (_, inner) => `\n${stripTags(inner).trim()}\n`);
+
+  // Blockquotes
+  s = s.replace(/<blockquote[^>]*>([\s\S]*?)<\/blockquote>/gi,
+    (_, inner) => inner.split('\n').map((l) => `> ${l.trim()}`).join('\n') + '\n');
+
+  // ── 3. Strip remaining HTML tags ─────────────────────────────────────────
+  s = s.replace(/<[^>]+>/g, '');
+
+  // ── 4. Decode common HTML entities ───────────────────────────────────────
+  s = decodeEntities(s);
+
+  // ── 5. Normalize whitespace ───────────────────────────────────────────────
+  // Collapse 3+ blank lines to 2
+  s = s.replace(/\n{3,}/g, '\n\n');
+  return s.trim();
+}
+
+function convertTables(s) {
+  return s.replace(/<table[^>]*>([\s\S]*?)<\/table>/gi, (_, body) => {
+    const rows = [];
+    const rowMatches = body.matchAll(/<tr[^>]*>([\s\S]*?)<\/tr>/gi);
+    for (const rm of rowMatches) {
+      const cells = [];
+      const cellRe = /<t[dh][^>]*>([\s\S]*?)<\/t[dh]>/gi;
+      let cm;
+      while ((cm = cellRe.exec(rm[1])) !== null) {
+        cells.push(stripTags(cm[1]).trim().replace(/\|/g, '\\|'));
+      }
+      rows.push(cells);
+    }
+    if (!rows.length) return '';
+    const lines = [];
+    lines.push('| ' + rows[0].join(' | ') + ' |');
+    lines.push('| ' + rows[0].map(() => '---').join(' | ') + ' |');
+    for (const row of rows.slice(1)) {
+      lines.push('| ' + row.join(' | ') + ' |');
+    }
+    return '\n' + lines.join('\n') + '\n';
+  });
+}
+
+function convertLists(s) {
+  // Handle nested lists by iterating outer → inner.
+  // We do a simple approach: convert <li> inside <ul>/<ol>.
+  function convertList(html, ordered) {
+    let idx = 1;
+    return html.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_, inner) => {
+      const content = stripTags(inner).trim();
+      const prefix  = ordered ? `${idx++}. ` : '- ';
+      return `\n${prefix}${content}`;
+    });
+  }
+
+  // Unordered
+  s = s.replace(/<ul[^>]*>([\s\S]*?)<\/ul>/gi, (_, inner) => `\n${convertList(inner, false)}\n`);
+  // Ordered
+  s = s.replace(/<ol[^>]*>([\s\S]*?)<\/ol>/gi, (_, inner) => `\n${convertList(inner, true)}\n`);
+  return s;
+}
+
+function stripTags(s) {
+  return (s || '').replace(/<[^>]+>/g, '');
+}
+
+function decodeEntities(s) {
+  return s
+    .replace(/&amp;/g,   '&')
+    .replace(/&lt;/g,    '<')
+    .replace(/&gt;/g,    '>')
+    .replace(/&quot;/g,  '"')
+    .replace(/&#39;/g,   "'")
+    .replace(/&nbsp;/g,  ' ')
+    .replace(/&#(\d+);/g, (_, n) => String.fromCharCode(Number(n)))
+    .replace(/&[a-z]+;/g, '');
+}
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+function openBrowser(url) {
+  const { spawnSync } = require('child_process');
+  try {
+    if (process.platform === 'darwin') {
+      spawnSync('open', [url], { stdio: 'ignore' });
+    } else if (process.platform === 'win32') {
+      spawnSync('cmd', ['/c', 'start', '', url], { stdio: 'ignore', shell: true });
+    } else {
+      spawnSync('xdg-open', [url], { stdio: 'ignore' });
+    }
+  } catch { /* ignore if browser can't be opened */ }
+}
+
+function toInt(v, def) {
+  if (v === undefined || v === null || v === '') return def;
+  const n = typeof v === 'number' ? v : parseInt(String(v), 10);
+  return Number.isFinite(n) && n >= 0 ? n : def;
+}
+
+module.exports = {
+  default: ConfluenceIntakeProvider,
+  ConfluenceIntakeProvider,
+  confluenceStorageToMd,
+  extractPageId,
+  extractSpaceTitle,
+};