@repo-toolkit/confluence 0.8.0

package/cli.js

@@ -0,0 +1,870 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { parseFlags as parseFlags2, resolveCliOptions as resolveCliOptions2, INTERACTIVE_FLAG } from "@repo-toolkit/publish-package";
+
+// src/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname, isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
+import { parseFlags, resolveCliOptions, isPlainObject } from "@repo-toolkit/publish-package";
+
+// src/confluence-client.ts
+import { Buffer } from "buffer";
+import { readFileSync } from "fs";
+import { basename } from "path";
+var V2_PATH = "/api/v2";
+var V1_PATH = "/rest/api";
+var DEFAULT_USER_AGENT = "repo-toolkit-confluence/1.0 (+node)";
+var MAX_LIMIT = 250;
+var STATUS_CODES = {
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  CONFLICT: 409
+};
+var ConfluenceApiError = class extends Error {
+  constructor(message, status, endpoint, responseBody) {
+    super(`${message} (status=${status}, endpoint=${endpoint})`);
+    this.name = "ConfluenceApiError";
+    this.status = status;
+    this.endpoint = endpoint;
+    this.responseBody = responseBody;
+  }
+};
+var ConfluenceClient = class {
+  constructor(options) {
+    if (!options.baseUrl) {
+      throw new Error("ConfluenceClient: baseUrl is required");
+    }
+    if (!options.username || !options.apiToken) {
+      throw new Error("ConfluenceClient: username and apiToken are required");
+    }
+    this.baseUrl = normalizeBaseUrl(options.baseUrl);
+    this.authHeader = "Basic " + Buffer.from(`${options.username}:${options.apiToken}`, "utf8").toString("base64");
+    this.fetchFn = options.fetch ?? globalThis.fetch;
+    this.userAgent = options.userAgent ?? DEFAULT_USER_AGENT;
+  }
+  async getSpaceIdByKey(spaceKey) {
+    const query = new URLSearchParams({ keys: spaceKey, limit: "1" });
+    const data = await this.requestJson(
+      this.v2Url(`/spaces?${query.toString()}`),
+      { method: "GET" }
+    );
+    const result = data.results[0];
+    if (!result) {
+      throw new Error(`Confluence space not found for key: ${spaceKey}`);
+    }
+    return result.id;
+  }
+  async getPageByTitle(spaceId, title) {
+    const query = new URLSearchParams({
+      "space-id": spaceId,
+      title,
+      limit: "1",
+      "body-format": "storage"
+    });
+    const data = await this.requestJson(this.v2Url(`/pages?${query.toString()}`), {
+      method: "GET"
+    });
+    return data.results[0];
+  }
+  async getPage(pageId) {
+    return this.requestJson(this.v2Url(`/pages/${encodeURIComponent(pageId)}?body-format=storage`), {
+      method: "GET"
+    });
+  }
+  async createPage(input) {
+    const body = {
+      spaceId: input.spaceId,
+      status: input.status ?? "current",
+      title: input.title,
+      parentId: input.parentId,
+      body: {
+        representation: input.body.representation,
+        value: input.body.value
+      }
+    };
+    return this.requestJson(this.v2Url("/pages"), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  }
+  async updatePage(input) {
+    const body = {
+      id: input.id,
+      status: input.status ?? "current",
+      title: input.title,
+      body: {
+        representation: input.body.representation,
+        value: input.body.value
+      },
+      version: { number: input.version.number, message: input.version.message }
+    };
+    return this.requestJson(this.v2Url(`/pages/${encodeURIComponent(input.id)}`), {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  }
+  async getAttachments(pageId) {
+    const results = [];
+    let cursor;
+    do {
+      const query = new URLSearchParams({ limit: String(MAX_LIMIT) });
+      if (cursor) {
+        query.set("cursor", cursor);
+      }
+      const data = await this.requestJson(
+        this.v2Url(`/pages/${encodeURIComponent(pageId)}/attachments?${query.toString()}`),
+        { method: "GET" }
+      );
+      for (const item of data.results) {
+        results.push(item);
+      }
+      cursor = data._links?.next;
+    } while (cursor);
+    return results;
+  }
+  async uploadAttachment(pageId, filePath, comment) {
+    return this.sendAttachmentMultipart(pageId, void 0, filePath, comment);
+  }
+  async updateAttachmentData(pageId, attachmentId, filePath, comment) {
+    return this.sendAttachmentMultipart(pageId, attachmentId, filePath, comment);
+  }
+  async sendAttachmentMultipart(pageId, attachmentId, filePath, comment) {
+    const fileBuffer = readFileSync(filePath);
+    const filename = basename(filePath);
+    const boundary = "----repo-toolkit-confluence-" + Math.random().toString(16).slice(2);
+    const parts = [];
+    parts.push(multipartField(boundary, "file", filename, fileBuffer));
+    if (comment) {
+      parts.push(multipartField(boundary, "comment", void 0, Buffer.from(comment, "utf8")));
+    }
+    parts.push(Buffer.from(`--${boundary}--\r
+`));
+    const endpoint = attachmentId ? this.v1Url(`/content/${encodeURIComponent(pageId)}/child/attachment/${encodeURIComponent(attachmentId)}/data`) : this.v1Url(`/content/${encodeURIComponent(pageId)}/child/attachment`);
+    const data = await this.requestJson(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": `multipart/form-data; boundary=${boundary}`,
+        "X-Atlassian-Token": "no-check"
+      },
+      body: Buffer.concat(parts)
+    });
+    return normalizeAttachmentResult(data);
+  }
+  async requestJson(endpoint, init) {
+    const headers = {
+      Authorization: this.authHeader,
+      Accept: "application/json",
+      "User-Agent": this.userAgent
+    };
+    if (init.headers) {
+      for (const [k, v] of Object.entries(init.headers)) {
+        headers[k] = v;
+      }
+    }
+    let response;
+    try {
+      response = await this.fetchFn(endpoint, {
+        method: init.method,
+        headers,
+        body: init.body
+      });
+    } catch (cause) {
+      throw new ConfluenceApiError(
+        cause instanceof Error ? `Network error: ${cause.message}` : "Network error",
+        0,
+        endpoint,
+        ""
+      );
+    }
+    const text = await response.text();
+    if (!response.ok) {
+      throw new ConfluenceApiError(describeStatus(response.status), response.status, endpoint, text);
+    }
+    if (text.length === 0) {
+      return {};
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new ConfluenceApiError("Response was not valid JSON", response.status, endpoint, text);
+    }
+  }
+  v2Url(path) {
+    return this.baseUrl + V2_PATH + path;
+  }
+  v1Url(path) {
+    return this.baseUrl + V1_PATH + path;
+  }
+};
+function multipartField(boundary, name, filename, value) {
+  const headerLines = [`--${boundary}\r
+`];
+  if (filename) {
+    headerLines.push(
+      `Content-Disposition: form-data; name="${name}"; filename="${filename}"\r
+`,
+      "Content-Type: application/octet-stream\r\n"
+    );
+  } else {
+    headerLines.push(`Content-Disposition: form-data; name="${name}"\r
+`);
+  }
+  headerLines.push("\r\n");
+  return Buffer.concat([Buffer.from(headerLines.join(""), "utf8"), value, Buffer.from("\r\n", "utf8")]);
+}
+function normalizeAttachmentResult(data) {
+  if (data.results) {
+    const first = data.results[0];
+    if (!first) {
+      throw new ConfluenceApiError("Attachment upload returned no results", 0, "attachment", JSON.stringify(data));
+    }
+    return first;
+  }
+  return data;
+}
+function normalizeBaseUrl(baseUrl) {
+  const trimmed = baseUrl.trim();
+  if (trimmed.length === 0) {
+    throw new Error("baseUrl must not be empty");
+  }
+  let url = trimmed;
+  while (url.endsWith("/")) {
+    url = url.slice(0, -1);
+  }
+  return url;
+}
+function describeStatus(status) {
+  switch (status) {
+    case STATUS_CODES.UNAUTHORIZED:
+      return "Authentication failed (check username/apiToken)";
+    case STATUS_CODES.FORBIDDEN:
+      return "Permission denied";
+    case STATUS_CODES.NOT_FOUND:
+      return "Resource not found";
+    case STATUS_CODES.CONFLICT:
+      return "Version conflict (page was updated concurrently)";
+    default:
+      if (status >= STATUS_CODES.BAD_REQUEST && status < 500) {
+        return `Client error (${status})`;
+      }
+      if (status >= 500) {
+        return `Server error (${status})`;
+      }
+      return `Unexpected status (${status})`;
+  }
+}
+
+// src/files.ts
+import { readdir, stat } from "fs/promises";
+import { join, relative, sep, normalize } from "path";
+var MARKDOWN_EXT = ".md";
+var MAX_DEPTH = 32;
+async function readDocTree(root, depth = 0) {
+  const normalizedRoot = normalize(root);
+  const info = await stat(normalizedRoot);
+  if (!info.isDirectory()) {
+    throw new Error(`Not a directory: ${normalizedRoot}`);
+  }
+  if (depth > MAX_DEPTH) {
+    throw new Error(`Max directory depth exceeded under ${normalizedRoot}`);
+  }
+  const entries = [];
+  await walk(normalizedRoot, normalizedRoot, entries, depth);
+  entries.sort((a, b) => a.segments.join("/").localeCompare(b.segments.join("/")));
+  return { entries };
+}
+async function walk(dir, root, out, depth) {
+  if (depth > MAX_DEPTH) {
+    throw new Error(`Max directory depth exceeded under ${root}`);
+  }
+  const names = await readdir(dir, { withFileTypes: true });
+  for (const entry of names) {
+    if (entry.name.startsWith(".")) {
+      continue;
+    }
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walk(full, root, out, depth + 1);
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(MARKDOWN_EXT)) {
+      const rel = relative(root, full).split(sep).join("/");
+      out.push({ segments: rel.split("/"), absolute: full });
+    }
+  }
+}
+function isMarkdownName(name) {
+  const lower = name.toLowerCase();
+  return lower.length > MARKDOWN_EXT.length && lower.endsWith(MARKDOWN_EXT);
+}
+function titleFromSegment(segment) {
+  const dot = segment.lastIndexOf(".");
+  if (dot > 0) {
+    return segment.slice(0, dot);
+  }
+  return segment;
+}
+
+// src/markdown.ts
+var STORAGE_LINE_BREAK = "<br />";
+var LINE_BREAK_SENTINEL = "
BR
";
+var PROTOCOL_BLOCKLIST = /^(?:javascript|data|file|vbscript):/i;
+var AMP = "&amp;";
+var LT = "&lt;";
+var GT = "&gt;";
+var QUOT = "&quot;";
+var APOS = "&#39;";
+function markdownToStorage(markdown) {
+  const lines = markdown.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line === void 0 || line === "") {
+      i += 1;
+      continue;
+    }
+    if (/^\s{0,3}#{1,6}\s/.test(line)) {
+      out.push(renderHeading(line));
+      i += 1;
+      continue;
+    }
+    if (/^\s{0,3}```/.test(line)) {
+      const fence = line;
+      const lang = fence.trim().slice(3).trim();
+      const buf = [];
+      i += 1;
+      while (i < lines.length && !/^\s{0,3}```/.test(lines[i] ?? "")) {
+        buf.push(lines[i] ?? "");
+        i += 1;
+      }
+      i += 1;
+      out.push(renderCodeBlock(buf.join("\n"), lang));
+      continue;
+    }
+    if (/^\s{0,3}(?:-|\*|\+)\s+/.test(line) || /^\s{0,3}\d+\.\s+/.test(line)) {
+      const listLines = [];
+      while (i < lines.length && typeof lines[i] === "string" && (/^\s{0,3}(?:-|\*|\+)\s+/.test(lines[i]) || /^\s{0,3}\d+\.\s+/.test(lines[i]) || lines[i].trim() === "")) {
+        if (lines[i].trim() === "" && isLikelyListTerminator(lines, i)) {
+          break;
+        }
+        listLines.push(lines[i]);
+        i += 1;
+      }
+      out.push(renderList(listLines));
+      continue;
+    }
+    if (/^\s{0,3}>/.test(line)) {
+      const quoteLines = [];
+      while (i < lines.length && typeof lines[i] === "string" && /^\s{0,3}>/.test(lines[i])) {
+        quoteLines.push(lines[i].replace(/^\s{0,3}>\s?/, ""));
+        i += 1;
+      }
+      out.push(`<blockquote>${renderInline(quoteLines.join("\n"))}</blockquote>`);
+      continue;
+    }
+    if (/^\s{0,3}---+\s*$/.test(line) || /^\s{0,3}\*\*\*+\s*$/.test(line)) {
+      out.push("<hr />");
+      i += 1;
+      continue;
+    }
+    const para = [];
+    while (i < lines.length && typeof lines[i] === "string" && lines[i].trim() !== "" && !/^\s{0,3}#{1,6}\s/.test(lines[i]) && !/^\s{0,3}```/.test(lines[i]) && !/^\s{0,3}(?:-|\*|\+)\s+/.test(lines[i]) && !/^\s{0,3}\d+\.\s+/.test(lines[i]) && !/^\s{0,3}>/.test(lines[i]) && !/^\s{0,3}---+\s*$/.test(lines[i]) && !/^\s{0,3}\*\*\*+\s*$/.test(lines[i])) {
+      para.push(lines[i]);
+      i += 1;
+    }
+    const renderedPara = renderInline(para.join(LINE_BREAK_SENTINEL));
+    out.push(`<p>${renderedPara.split(LINE_BREAK_SENTINEL).join(STORAGE_LINE_BREAK)}</p>`);
+  }
+  return { html: out.join("\n") };
+}
+function isLikelyListTerminator(lines, currentIndex) {
+  for (let k = currentIndex + 1; k < lines.length; k += 1) {
+    const next = lines[k];
+    if (next === void 0 || next.trim() === "") {
+      continue;
+    }
+    return !/^\s{0,3}(?:-|\*|\+)\s+/.test(next) && !/^\s{0,3}\d+\.\s+/.test(next);
+  }
+  return true;
+}
+function renderHeading(line) {
+  const match = /^(\s{0,3})(#{1,6})\s+(.*)$/.exec(line);
+  if (!match) {
+    return "";
+  }
+  const hashes = match[2];
+  const level = hashes ? hashes.length : 1;
+  const text = match[3];
+  return `<h${level}>${renderInline(text)}</h${level}>`;
+}
+function renderCodeBlock(code, _lang) {
+  const lang = _lang && /^[a-zA-Z0-9+-]+$/.test(_lang) ? _lang : "none";
+  const titleAttr = escapeXmlAttribute(lang);
+  return `<ac:structured-macro ac:name="code"><ac:parameter ac:name="language">${titleAttr}</ac:parameter><ac:plain-text-body><![CDATA[${escapeCdataTerminator(code)}]]></ac:plain-text-body></ac:structured-macro>`;
+}
+function escapeCdataTerminator(text) {
+  return text.replace(/]]>/g, "]]]]><![CDATA[>");
+}
+function renderList(listLines) {
+  const items = [];
+  let ordered = false;
+  for (const raw of listLines) {
+    if (raw.trim() === "") {
+      continue;
+    }
+    const ulMatch = /^(\s{0,3})(?:-|\*|\+)\s+(.*)$/.exec(raw);
+    const olMatch = /^(\s{0,3})(\d+)\.\s+(.*)$/.exec(raw);
+    if (olMatch) {
+      ordered = true;
+      items.push(olMatch[3] ?? "");
+    } else if (ulMatch) {
+      items.push(ulMatch[2] ?? "");
+    }
+  }
+  const tag = ordered ? "ol" : "ul";
+  const body = items.map((item) => `<li>${renderInline(item)}</li>`).join("");
+  return `<${tag}>${body}</${tag}>`;
+}
+function renderInline(text) {
+  let s = text;
+  s = escapeHtml(s);
+  s = applyImages(s);
+  s = applyLinks(s);
+  s = applyStrong(s);
+  s = applyInlineCode(s);
+  return s;
+}
+function applyLinks(text) {
+  return replaceBalancedSyntax(text, /\[([^\]]+)\]\(/g, (label, url) => {
+    if (PROTOCOL_BLOCKLIST.test(url)) {
+      return label;
+    }
+    return '<a href="' + escapeXmlAttribute(url) + '">' + label + "</a>";
+  });
+}
+function applyImages(text) {
+  return replaceBalancedSyntax(text, /!\[([^\]]*)\]\(/g, (alt, src) => {
+    if (PROTOCOL_BLOCKLIST.test(src)) {
+      return alt;
+    }
+    if (isRemoteUrl(src)) {
+      return '<ac:image><ri:url ri:value="' + escapeXmlAttribute(src) + '" /></ac:image>';
+    }
+    return '<ac:image data-local-src="' + escapeXmlAttribute(src) + '"></ac:image>';
+  });
+}
+function replaceBalancedSyntax(text, openerRe, render) {
+  let out = "";
+  let cursor = 0;
+  let m;
+  const re = new RegExp(openerRe.source, "g");
+  while ((m = re.exec(text)) !== null) {
+    out += text.slice(cursor, m.index);
+    const captured = m[1] ?? "";
+    const after = text.slice(m.index + m[0].length);
+    const scan = scanBalancedUrl(after);
+    if (scan === null) {
+      out += m[0];
+      cursor = m.index + m[0].length;
+      continue;
+    }
+    out += render(captured, scan.url);
+    cursor = m.index + m[0].length + scan.consumed;
+  }
+  out += text.slice(cursor);
+  return out;
+}
+function scanBalancedUrl(rest) {
+  let depth = 0;
+  let i = 0;
+  for (; i < rest.length; i += 1) {
+    const ch = rest[i];
+    if (ch === "(") {
+      depth += 1;
+    } else if (ch === ")") {
+      if (depth === 0) {
+        const url = rest.slice(0, i);
+        if (url.length === 0) {
+          return null;
+        }
+        return { url, consumed: i + 1 };
+      }
+      depth -= 1;
+    } else if (ch === " " || ch === "	" || ch === "\n") {
+      return null;
+    }
+  }
+  return null;
+}
+var LOCAL_IMAGE_PLACEHOLDER_RE = /<ac:image\s+data-local-src="([^"]*)"\s*><\/ac:image>/g;
+function applyStrong(text) {
+  let s = text.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+  s = s.replace(/\*([^*]+)\*/g, "<em>$1</em>");
+  s = s.replace(/__([^_]+)__/g, "<strong>$1</strong>");
+  return s.replace(/_([^_]+)_/g, "<em>$1</em>");
+}
+function applyInlineCode(text) {
+  return text.replace(/`([^`]+)`/g, (_m, code) => `<code>${code}</code>`);
+}
+function isRemoteUrl(src) {
+  return /^(https?:)?\/\//i.test(src) || /^\/\//.test(src);
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, AMP).replace(/</g, LT).replace(/>/g, GT).replace(/"/g, QUOT).replace(/'/g, APOS);
+}
+function escapeXmlAttribute(text) {
+  return text.replace(/&/g, AMP).replace(/"/g, QUOT).replace(/</g, LT).replace(/>/g, GT);
+}
+function escapeAttachmentFilename(filename) {
+  if (filename === "" || filename === "." || filename === "..") {
+    throw new Error("Invalid attachment filename");
+  }
+  const cleaned = filename.replace(/[/\\]/g, "_");
+  if (cleaned === "" || cleaned === "." || cleaned === "..") {
+    throw new Error("Invalid attachment filename");
+  }
+  return cleaned;
+}
+
+// src/attachments.ts
+import { existsSync } from "fs";
+import { normalize as normalize2, isAbsolute, resolve } from "path";
+async function rewriteImagesToAttachments(html, pageId, client, options) {
+  const uploaded = [];
+  const resolved = await resolvePlaceholders(html, pageId, client, options, uploaded);
+  return { html: resolved, uploaded };
+}
+async function resolvePlaceholders(html, pageId, client, options, uploaded) {
+  const existing = await client.getAttachments(pageId);
+  const existingByName = /* @__PURE__ */ new Map();
+  for (const a of existing) {
+    const name = a.filename ?? a.title;
+    if (name) {
+      existingByName.set(name, a);
+    }
+  }
+  const collected = [];
+  const seen = /* @__PURE__ */ new Set();
+  let m;
+  LOCAL_IMAGE_PLACEHOLDER_RE.lastIndex = 0;
+  while ((m = LOCAL_IMAGE_PLACEHOLDER_RE.exec(html)) !== null) {
+    const rawSrc = decodePlaceholder(m[1] ?? "");
+    if (seen.has(rawSrc)) {
+      continue;
+    }
+    seen.add(rawSrc);
+    const abs = resolveImageForUpload(options.markdownDir, rawSrc);
+    if (!existsSync(abs)) {
+      continue;
+    }
+    collected.push({ src: rawSrc, abs });
+  }
+  const srcToFilename = /* @__PURE__ */ new Map();
+  for (const { src, abs } of collected) {
+    const filename = escapeAttachmentFilename(basenameLocal(abs));
+    let attachment = existingByName.get(filename);
+    if (attachment && attachment.id) {
+      attachment = await client.updateAttachmentData(pageId, attachment.id, abs, `Updated via repo-toolkit-confluence`);
+    } else {
+      attachment = await client.uploadAttachment(pageId, abs, `Uploaded via repo-toolkit-confluence`);
+    }
+    uploaded.push({ src, attachment });
+    srcToFilename.set(src, filename);
+  }
+  return html.replace(LOCAL_IMAGE_PLACEHOLDER_RE, (full, encodedSrc) => {
+    const src = decodePlaceholder(encodedSrc);
+    const filename = srcToFilename.get(src);
+    if (!filename) {
+      return full;
+    }
+    return renderAttachmentMacro(filename);
+  });
+}
+function renderAttachmentMacro(filename) {
+  const safe = escapeAttachmentFilename(filename);
+  return `<ac:image><ri:attachment ri:filename="${escapeXmlAttribute(safe)}" /></ac:image>`;
+}
+function resolveImageForUpload(markdownDir, src) {
+  if (isRemoteUrl(src)) {
+    throw new Error(`Remote image should not be uploaded: ${src}`);
+  }
+  if (isAbsolute(src)) {
+    return normalize2(src);
+  }
+  return normalize2(resolve(markdownDir, src));
+}
+function basenameLocal(absPath) {
+  const norm = normalize2(absPath);
+  const sep2 = norm.includes("\\") ? "\\" : "/";
+  const parts = norm.split(sep2);
+  const last = parts[parts.length - 1];
+  return last ?? norm;
+}
+function decodePlaceholder(value) {
+  const AMP2 = "&amp;";
+  const QUOT2 = "&quot;";
+  const LT2 = "&lt;";
+  const GT2 = "&gt;";
+  return value.replace(new RegExp(AMP2, "g"), "&").replace(new RegExp(QUOT2, "g"), '"').replace(new RegExp(LT2, "g"), "<").replace(new RegExp(GT2, "g"), ">");
+}
+
+// src/index.ts
+function resolveConfluenceSyncPlan(options = {}) {
+  const cwd = resolve2(options.cwd ?? process.cwd());
+  const folder = resolveInputPath(cwd, options.folder ?? "");
+  if (!options.folder) {
+    throw new Error("folder is required");
+  }
+  if (!options.dryRun) {
+    if (!options.username) {
+      throw new Error("username is required");
+    }
+    if (!options.apiToken) {
+      throw new Error("apiToken is required");
+    }
+    if (!options.baseUrl) {
+      throw new Error("baseUrl is required");
+    }
+    if (!options.spaceKey) {
+      throw new Error("spaceKey is required");
+    }
+    if (!options.parentPageId) {
+      throw new Error("parentPageId is required");
+    }
+    if (!/^[0-9]+$/.test(options.parentPageId)) {
+      throw new Error(`parentPageId must be numeric, got: ${options.parentPageId}`);
+    }
+  }
+  return {
+    cwd,
+    folder,
+    username: options.username ?? "",
+    apiToken: options.apiToken ?? "",
+    baseUrl: options.baseUrl ?? "",
+    spaceKey: options.spaceKey ?? "",
+    parentPageId: options.parentPageId ?? "",
+    versionMessage: options.versionMessage ?? "Synced via repo-toolkit-confluence",
+    skipUnchanged: options.skipUnchanged ?? true,
+    dryRun: options.dryRun ?? false
+  };
+}
+async function syncConfluenceToDocs(options = {}) {
+  const plan = resolveConfluenceSyncPlan(options);
+  const log = options.log ?? ((msg) => console.log(msg));
+  if (plan.dryRun) {
+    log("[dry-run] Walking documentation tree only.");
+  }
+  const tree = await readDocTree(plan.folder);
+  if (tree.entries.length === 0) {
+    log(`No markdown files found under ${plan.folder}`);
+    return;
+  }
+  if (plan.dryRun) {
+    for (const entry of tree.entries) {
+      log(`[dry-run] would sync ${entry.segments.join("/")}`);
+    }
+    return;
+  }
+  const client = options.client ?? new ConfluenceClient({
+    baseUrl: plan.baseUrl,
+    username: plan.username,
+    apiToken: plan.apiToken
+  });
+  const spaceId = await client.getSpaceIdByKey(plan.spaceKey);
+  const cache = new PageTitleCache(spaceId, client);
+  for (const entry of tree.entries) {
+    await syncEntry(entry, plan, client, cache, log);
+  }
+}
+async function syncEntry(entry, plan, client, cache, log) {
+  const segments = entry.segments;
+  if (segments.length === 0) {
+    return;
+  }
+  let currentParentId = plan.parentPageId;
+  for (let idx = 0; idx < segments.length; idx += 1) {
+    const isLast = idx === segments.length - 1;
+    const segment = segments[idx] ?? "";
+    if (isLast && isMarkdownName(segment)) {
+      const title = titleFromSegment(segment);
+      const page2 = await cache.findOrCreate(title, currentParentId);
+      const pageId = page2.id;
+      const markdown = readFileSync2(entry.absolute, "utf8");
+      const { html } = markdownToStorage(markdown);
+      const markdownDir = dirname(entry.absolute);
+      let body = html;
+      LOCAL_IMAGE_PLACEHOLDER_RE.lastIndex = 0;
+      if (LOCAL_IMAGE_PLACEHOLDER_RE.test(body)) {
+        const result = await rewriteImagesToAttachments(body, pageId, client, { markdownDir });
+        body = result.html;
+      }
+      const current = await client.getPage(pageId);
+      const currentBody = current.body?.storage?.value ?? "";
+      const nextVersion = (current.version?.number ?? 0) + 1;
+      if (plan.skipUnchanged && currentBody === body) {
+        log(`unchanged: ${segments.join("/")} (page ${pageId})`);
+        return;
+      }
+      await client.updatePage({
+        id: pageId,
+        title,
+        body: { representation: "storage", value: body },
+        version: { number: nextVersion, message: plan.versionMessage }
+      });
+      log(`updated: ${segments.join("/")} (page ${pageId}, v${nextVersion})`);
+      return;
+    }
+    if (isMarkdownName(segment)) {
+      const title = titleFromSegment(segment);
+      const page2 = await cache.findOrCreate(title, currentParentId);
+      currentParentId = page2.id;
+      continue;
+    }
+    const page = await cache.findOrCreate(segment, currentParentId);
+    currentParentId = page.id;
+  }
+}
+var PageTitleCache = class {
+  constructor(spaceId, client) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.spaceId = spaceId;
+    this.client = client;
+  }
+  async findOrCreate(title, parentId) {
+    const key = `${parentId}::${title}`;
+    const existing = this.cache.get(key);
+    if (existing) {
+      return existing;
+    }
+    let page = await this.client.getPageByTitle(this.spaceId, title);
+    if (!page) {
+      page = await this.client.createPage({
+        spaceId: this.spaceId,
+        title,
+        parentId,
+        body: { representation: "storage", value: "" }
+      });
+    }
+    const result = { id: page.id };
+    this.cache.set(key, result);
+    return result;
+  }
+};
+function resolveInputPath(baseDir, inputPath) {
+  if (isAbsolute2(inputPath)) {
+    return inputPath;
+  }
+  return resolve2(baseDir, inputPath);
+}
+
+// src/cli.ts
+var SPECS = [
+  { name: "config" },
+  { name: "cwd" },
+  { name: "folder" },
+  { name: "username" },
+  { name: "api-token", aliases: ["password"] },
+  { name: "confluence-base-url", aliases: ["base-url"] },
+  { name: "space-key" },
+  { name: "parent-page-id" },
+  { name: "version-message" },
+  { name: "skip-unchanged", boolean: true, negatable: true },
+  { name: "dry-run", boolean: true },
+  INTERACTIVE_FLAG
+];
+function printHelp() {
+  console.log(`repo-toolkit-confluence
+
+Usage:
+  repo-toolkit-confluence [options]
+
+Synchronizes a folder of markdown documentation to Confluence pages and
+attachments. When run with no flags, reads configuration from the GitHub
+Action INPUT_* environment variables (folder, username, api-token,
+confluence-base-url, space-key, parent-page-id).
+
+Options:
+  --config <path>               Config file (JSON, .mjs, or .cjs default export)
+  --cwd <path>                  Working directory (default: process.cwd())
+  --folder <path>               Folder containing the documentation to publish (required)
+  --username <value>            Confluence username or email (required)
+  --api-token <value>           Confluence API token (required). Alias: --password
+  --confluence-base-url <url>   Confluence URL with /wiki (required). Alias: --base-url
+  --space-key <key>             Confluence space key (required). Resolved to a spaceId via the API
+  --parent-page-id <id>         Numeric page id under which docs will be published (required)
+  --version-message <text>      Commit message appended to every page/attachment PUT
+  --skip-unchanged               Skip pages whose body is unchanged (default: true)
+  --no-skip-unchanged           Re-upload every page even when unchanged
+  --dry-run                     Walk the doc tree and print the plan without API calls
+  -i, --interactive             (reserved; not currently interactive)
+  -h, --help                    Show this help message
+`);
+}
+var ENV_INPUT_MAP = [
+  ["INPUT_FOLDER", "folder"],
+  ["INPUT_USERNAME", "username"],
+  ["INPUT_API-TOKEN", "apiToken"],
+  ["INPUT_PASSWORD", "apiToken"],
+  ["INPUT_CONFLUENCE-BASE-URL", "baseUrl"],
+  ["INPUT_SPACE-KEY", "spaceKey"],
+  ["INPUT_PARENT-PAGE-ID", "parentPageId"],
+  ["INPUT_VERSION-MESSAGE", "versionMessage"]
+];
+function buildOptions(result) {
+  if (!result) {
+    return {};
+  }
+  const { values, repeat: _repeat } = result;
+  void _repeat;
+  const options = {};
+  if (values.cwd) options.cwd = values.cwd;
+  if (values.folder) options.folder = values.folder;
+  if (values.username) options.username = values.username;
+  if (values["api-token"]) options.apiToken = values["api-token"];
+  if (values["password"]) options.apiToken = values["password"];
+  if (values["confluence-base-url"]) options.baseUrl = values["confluence-base-url"];
+  if (values["base-url"]) options.baseUrl = values["base-url"];
+  if (values["space-key"]) options.spaceKey = values["space-key"];
+  if (values["parent-page-id"]) options.parentPageId = values["parent-page-id"];
+  if (values["version-message"]) options.versionMessage = values["version-message"];
+  if (values["skip-unchanged"] !== void 0) options.skipUnchanged = values["skip-unchanged"] === "true";
+  if (values["dry-run"] !== void 0) options.dryRun = true;
+  return options;
+}
+function optionsFromEnv() {
+  const options = {};
+  for (const [envName, key] of ENV_INPUT_MAP) {
+    const value = process.env[envName];
+    if (typeof value === "string" && value.length > 0) {
+      options[key] = value;
+    }
+  }
+  return options;
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const hasFlags = argv.length > 0;
+  const result = parseFlags2(argv, SPECS);
+  if (!result) {
+    printHelp();
+    return;
+  }
+  const cliOptions = await resolveCliOptions2({
+    result,
+    buildOptions
+  });
+  const envOptions = hasFlags ? {} : optionsFromEnv();
+  const merged = { ...envOptions, ...cliOptions };
+  await syncConfluenceToDocs(merged);
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(message);
+  process.exitCode = 1;
+});