@sideboard-ai/core 0.1.323 → 0.1.325

package/dist/{chunk-MZIZTSR2.js → chunk-F65JMKUR.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-YBTSZ2SW.js";
 import {
   resolveAgentExecutable
-} from "./chunk-OIHRC2ZJ.js";
+} from "./chunk-CI4M54LS.js";
 
 // src/agents/install.ts
 import { existsSync } from "fs";
@@ -267,7 +267,7 @@ async function loginAgent(agent) {
   };
 }
 async function loginManagedAccount(accountId) {
-  const { loadAppSettings } = await import("./app-settings-I5HM5RMP.js");
+  const { loadAppSettings } = await import("./app-settings-E7DMMEKC.js");
   const { loginEnvPrefix } = await import("./managed-accounts-PITLFLKU.js");
   const account = loadAppSettings().accounts.accounts.find((a) => a.id === accountId);
   if (!account) {

package/dist/chunk-F6GE7V3Q.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+
+import {
+  ATTACHMENTS_DIR,
+  attachmentsGitignoreBody
+} from "./chunk-N2WW62LF.js";
+import {
+  httpFetch
+} from "./chunk-2GPQZZLY.js";
+
+// src/integrations/issue-attachments.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { basename, extname, join } from "path";
+import { randomUUID } from "crypto";
+var ISSUE_ATTACHMENT_MAX_BYTES = 25 * 1024 * 1024;
+var MARKDOWN_IMAGE_RE = /!\[[^\]]*]\(\s*<?(https?:\/\/[^)\s>]+)>?/gi;
+var MARKDOWN_LINK_RE = /(?<!!)\[[^\]]*]\(\s*<?(https?:\/\/[^)\s>]+)>?/gi;
+var HTML_SRC_RE = /\b(?:src|href)\s*=\s*["'](https?:\/\/[^"']+)["']/gi;
+var BARE_URL_RE = /https?:\/\/[^\s<>"'`)]+/gi;
+var EXT_BY_MIME = {
+  "image/png": ".png",
+  "image/jpeg": ".jpg",
+  "image/jpg": ".jpg",
+  "image/gif": ".gif",
+  "image/webp": ".webp",
+  "image/svg+xml": ".svg",
+  "application/pdf": ".pdf",
+  "text/plain": ".txt",
+  "text/markdown": ".md",
+  "application/json": ".json",
+  "application/zip": ".zip"
+};
+function issueAttachmentWorktreePath(repoPath) {
+  const raw = (repoPath ?? "").trim();
+  return raw || process.cwd();
+}
+function ensureIssueAttachmentsDir(worktreePath) {
+  const dir = join(worktreePath, ATTACHMENTS_DIR);
+  mkdirSync(dir, { recursive: true });
+  const gi = join(dir, ".gitignore");
+  if (!existsSync(gi)) {
+    writeFileSync(gi, attachmentsGitignoreBody(), "utf8");
+  }
+  return dir;
+}
+function hostnameOf(url) {
+  try {
+    return new URL(url).hostname.toLowerCase();
+  } catch {
+    return "";
+  }
+}
+function hostMatches(url, suffixes) {
+  const host = hostnameOf(url);
+  if (!host) return false;
+  return suffixes.some((suffix) => host === suffix || host.endsWith(`.${suffix}`));
+}
+function looksLikeHttpUrl(value) {
+  return /^https?:\/\//i.test(value.trim());
+}
+function looksLikeFileUrl(url) {
+  try {
+    const path = new URL(url).pathname;
+    return /\.[a-z0-9]{2,8}$/i.test(path);
+  } catch {
+    return false;
+  }
+}
+function filenameFromUrl(url, fallback = "attachment") {
+  try {
+    const parsed = new URL(url);
+    const last = decodeURIComponent(basename(parsed.pathname)).replace(/[/\\]/g, "_");
+    if (last && last !== "/" && last !== ".") return last;
+  } catch {
+  }
+  return fallback;
+}
+function filenameFromContentDisposition(header) {
+  if (!header) return void 0;
+  const star = header.match(/filename\*\s*=\s*(?:UTF-8''|utf-8'')([^;]+)/i);
+  if (star?.[1]) {
+    try {
+      return decodeURIComponent(star[1].trim().replace(/^["']|["']$/g, ""));
+    } catch {
+      return star[1].trim().replace(/^["']|["']$/g, "");
+    }
+  }
+  const plain = header.match(/filename\s*=\s*("(?:\\.|[^"])*"|[^;]+)/i);
+  if (!plain?.[1]) return void 0;
+  return plain[1].trim().replace(/^["']|["']$/g, "").replace(/\\"/g, '"');
+}
+function uniqueAttachmentFileName(dir, originalName) {
+  const safe = originalName.replace(/[/\\]/g, "_").replace(/^\.+/, "") || "file";
+  if (!existsSync(join(dir, safe))) return safe;
+  const ext = extname(safe);
+  const stem = ext ? safe.slice(0, -ext.length) : safe;
+  for (let i = 1; i < 1e4; i++) {
+    const candidate = `${stem}-${i}${ext}`;
+    if (!existsSync(join(dir, candidate))) return candidate;
+  }
+  return `${stem}-${randomUUID()}${ext}`;
+}
+function extractHttpUrls(markdown) {
+  const text = markdown ?? "";
+  if (!text.trim()) return [];
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (raw) => {
+    const url = raw.replace(/[).,;]+$/, "");
+    if (!looksLikeHttpUrl(url) || seen.has(url)) return;
+    seen.add(url);
+    found.push(url);
+  };
+  for (const re of [MARKDOWN_IMAGE_RE, MARKDOWN_LINK_RE, HTML_SRC_RE, BARE_URL_RE]) {
+    re.lastIndex = 0;
+    let match;
+    while (match = re.exec(text)) {
+      if (match[1]) push(match[1]);
+      else if (re === BARE_URL_RE) push(match[0]);
+    }
+  }
+  return found;
+}
+function mergeIssueAttachments(items) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    if (!item) continue;
+    const url = item.url.trim();
+    const id = item.id.trim() || url;
+    if (!id && !url) continue;
+    const key = url || id;
+    if (seen.has(key) || seen.has(id)) continue;
+    seen.add(key);
+    if (id !== key) seen.add(id);
+    out.push({
+      id: id || url,
+      name: item.name.trim() || filenameFromUrl(url),
+      url,
+      ...item.contentType ? { contentType: item.contentType } : {},
+      ...item.sourceType ? { sourceType: item.sourceType } : {}
+    });
+  }
+  return out;
+}
+function extensionForContentType(contentType, name) {
+  if (extname(name)) return name;
+  const mime = (contentType ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
+  const ext = EXT_BY_MIME[mime];
+  return ext ? `${name}${ext}` : name;
+}
+function assertNotHtml(contentType, url) {
+  const mime = (contentType ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
+  if (mime === "text/html" || mime === "application/xhtml+xml") {
+    throw new Error(
+      `Attachment at ${url} returned HTML, not a file. Use the listed file URL (uploads / user-attachments), not a ticket or PR page.`
+    );
+  }
+}
+async function downloadAuthenticatedFile(opts) {
+  const url = opts.url.trim();
+  if (!looksLikeHttpUrl(url)) {
+    throw new Error(`Attachment URL must be http(s) (got ${url || "empty"})`);
+  }
+  const res = await httpFetch(url, {
+    method: "GET",
+    redirect: "follow",
+    headers: {
+      Accept: "*/*",
+      ...opts.headers ?? {}
+    }
+  });
+  if (!res.ok) {
+    const detail = await res.text().catch(() => "");
+    throw new Error(
+      `Attachment download failed ${res.status}${detail ? `: ${detail.slice(0, 200)}` : ""} (${url})`
+    );
+  }
+  const contentType = res.headers.get("content-type") ?? void 0;
+  assertNotHtml(contentType, url);
+  const lengthHeader = res.headers.get("content-length");
+  if (lengthHeader) {
+    const length = Number(lengthHeader);
+    if (Number.isFinite(length) && length > ISSUE_ATTACHMENT_MAX_BYTES) {
+      throw new Error(
+        `Attachment is ${length} bytes; max is ${ISSUE_ATTACHMENT_MAX_BYTES} (${url})`
+      );
+    }
+  }
+  const buf = Buffer.from(await res.arrayBuffer());
+  if (buf.length > ISSUE_ATTACHMENT_MAX_BYTES) {
+    throw new Error(
+      `Attachment is ${buf.length} bytes; max is ${ISSUE_ATTACHMENT_MAX_BYTES} (${url})`
+    );
+  }
+  const dir = ensureIssueAttachmentsDir(opts.worktreePath);
+  const hinted = opts.name?.trim() || filenameFromContentDisposition(res.headers.get("content-disposition")) || filenameFromUrl(url);
+  const name = uniqueAttachmentFileName(dir, extensionForContentType(contentType, hinted));
+  writeFileSync(join(dir, name), buf);
+  return {
+    name,
+    path: `${ATTACHMENTS_DIR}/${name}`,
+    bytes: buf.length,
+    ...contentType ? { contentType } : {}
+  };
+}
+
+export {
+  issueAttachmentWorktreePath,
+  hostMatches,
+  looksLikeHttpUrl,
+  looksLikeFileUrl,
+  extractHttpUrls,
+  mergeIssueAttachments,
+  downloadAuthenticatedFile
+};