@kortix/sandbox 0.4.1

package/opencode/tools/scrape-webpage.ts

@@ -0,0 +1,115 @@
+import { tool } from "@opencode-ai/plugin";
+import FirecrawlApp from "@mendable/firecrawl-js";
+
+interface ScrapeResult {
+  url: string;
+  success: boolean;
+  title?: string;
+  content?: string;
+  content_length?: number;
+  html?: string;
+  metadata?: Record<string, unknown>;
+  error?: string;
+}
+
+async function scrapeOne(
+  client: FirecrawlApp,
+  url: string,
+  includeHtml: boolean,
+  retries = 3,
+): Promise<ScrapeResult> {
+  const formats: ("markdown" | "html")[] = includeHtml
+    ? ["markdown", "html"]
+    : ["markdown"];
+
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      const response = (await client.scrape(url, {
+        formats,
+        timeout: 30000,
+      })) as Record<string, unknown>;
+
+      const metadata = (response.metadata ?? {}) as Record<string, string>;
+      const markdown = (response.markdown ?? "") as string;
+      const html = (response.html ?? "") as string;
+
+      const result: ScrapeResult = {
+        url,
+        success: true,
+        title: metadata.title ?? "",
+        content: markdown,
+        content_length: markdown.length,
+      };
+
+      if (includeHtml && html) result.html = html;
+      if (Object.keys(metadata).length > 0) result.metadata = metadata;
+      return result;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      const isTimeout = msg.includes("timeout") || msg.includes("Timeout");
+
+      if (isTimeout && attempt < retries) {
+        await new Promise((r) => setTimeout(r, 2 ** attempt * 1000));
+        continue;
+      }
+      return { url, success: false, error: msg };
+    }
+  }
+  return { url, success: false, error: "max retries exceeded" };
+}
+
+export default tool({
+  description:
+    "Fetch and extract content from web pages using Firecrawl. " +
+    "Converts HTML to clean markdown. " +
+    "Supports multiple URLs separated by commas. " +
+    "Batch URLs in a single call for efficiency. " +
+    "For GitHub URLs, prefer gh CLI via Bash instead.",
+  args: {
+    urls: tool.schema
+      .string()
+      .describe(
+        "URLs to scrape, comma-separated (e.g. 'https://example.com/a,https://example.com/b')",
+      ),
+    include_html: tool.schema
+      .boolean()
+      .optional()
+      .describe("Include raw HTML alongside markdown. Default: false"),
+  },
+  async execute(args, _context) {
+    const apiKey = process.env.FIRECRAWL_API_KEY;
+    if (!apiKey) return "Error: FIRECRAWL_API_KEY not set.";
+
+    const client = new FirecrawlApp({
+      apiKey,
+      apiUrl: process.env.FIRECRAWL_URL ?? "https://api.firecrawl.dev",
+    });
+    const includeHtml = args.include_html ?? false;
+
+    const urlList = args.urls
+      .split(",")
+      .map((u) => u.trim())
+      .filter(Boolean);
+    if (urlList.length === 0) return "Error: no valid URLs provided.";
+
+    const results = await Promise.all(
+      urlList.map((u) => scrapeOne(client, u, includeHtml)),
+    );
+
+    const successful = results.filter((r) => r.success).length;
+    const failed = results.length - successful;
+
+    if (successful === 0) {
+      const errors = results.map((r) => `${r.url}: ${r.error}`).join("; ");
+      return `Error: Failed to scrape all ${results.length} URLs. ${errors}`;
+    }
+
+    if (urlList.length === 1) return JSON.stringify(results[0], null, 2);
+
+    return JSON.stringify(
+      { total: results.length, successful, failed, results },
+      null,
+      2,
+    );
+  },
+});

package/opencode/tools/scripts/.python-version

@@ -0,0 +1 @@
+3.12

package/opencode/tools/scripts/convert_pdf.py

@@ -0,0 +1,184 @@
+"""Convert HTML presentation slides to a single PDF.
+
+Usage: uv run convert_pdf.py <presentation_dir> <output_path>
+
+Reads metadata.json from <presentation_dir>, renders each slide HTML
+at 1920x1080 via Playwright Chromium, merges into a single PDF.
+"""
+
+import asyncio
+import json
+import sys
+import tempfile
+from pathlib import Path
+
+from playwright.async_api import async_playwright
+from PyPDF2 import PdfWriter, PdfReader
+
+
+async def render_slide_to_pdf(
+    browser, slide_info: dict, temp_dir: Path, max_retries: int = 3
+) -> Path:
+    """Render a single HTML slide to PDF with retry logic."""
+    html_path = slide_info["path"]
+    slide_num = slide_info["number"]
+    last_error = None
+
+    for attempt in range(max_retries):
+        page = None
+        try:
+            if attempt > 0:
+                await asyncio.sleep(2.0 * attempt)
+
+            page = await browser.new_page()
+            await page.set_viewport_size({"width": 1920, "height": 1080})
+            await page.emulate_media(media="screen")
+            await page.evaluate(
+                "() => { Object.defineProperty(window, 'devicePixelRatio', { get: () => 1 }); }"
+            )
+
+            file_url = f"file://{html_path.resolve()}"
+            await page.goto(file_url, wait_until="networkidle", timeout=30000)
+            await page.wait_for_timeout(3000)
+
+            await page.evaluate("""
+                () => {
+                    const sc = document.querySelector('.slide-container');
+                    if (sc) { sc.style.width='1920px'; sc.style.height='1080px'; sc.style.transform='none'; sc.style.maxWidth='none'; sc.style.maxHeight='none'; }
+                    document.body.style.margin='0'; document.body.style.padding='0';
+                    document.body.style.width='1920px'; document.body.style.height='1080px';
+                    document.body.style.overflow='hidden';
+                }
+            """)
+            await page.wait_for_timeout(1000)
+
+            temp_pdf = temp_dir / f"slide_{slide_num:02d}.pdf"
+            await page.pdf(
+                path=str(temp_pdf),
+                width="1920px",
+                height="1080px",
+                margin={"top": "0", "right": "0", "bottom": "0", "left": "0"},
+                print_background=True,
+                prefer_css_page_size=False,
+            )
+            return temp_pdf
+
+        except Exception as e:
+            last_error = e
+            err = str(e).lower()
+            retryable = any(
+                kw in err
+                for kw in [
+                    "target closed", "crashed", "protocol error",
+                    "printtopdf", "session closed", "timeout",
+                ]
+            )
+            if retryable and attempt < max_retries - 1:
+                continue
+            break
+        finally:
+            if page:
+                try:
+                    await page.close()
+                except Exception:
+                    pass
+
+    raise RuntimeError(
+        f"Slide {slide_num} failed after {max_retries} attempts: {last_error}"
+    )
+
+
+def combine_pdfs(pdf_paths: list[Path], output_path: Path) -> None:
+    """Merge multiple single-page PDFs into one."""
+    writer = PdfWriter()
+    for p in pdf_paths:
+        if p.exists():
+            reader = PdfReader(str(p))
+            for pg in reader.pages:
+                writer.add_page(pg)
+    with open(output_path, "wb") as f:
+        writer.write(f)
+
+
+async def convert(presentation_dir: str, output_path: str) -> dict:
+    """Main conversion entrypoint."""
+    pres_dir = Path(presentation_dir).resolve()
+    meta_path = pres_dir / "metadata.json"
+
+    if not pres_dir.exists():
+        return {"success": False, "error": f"Directory not found: {pres_dir}"}
+    if not meta_path.exists():
+        return {"success": False, "error": f"metadata.json not found in {pres_dir}"}
+
+    with open(meta_path, "r") as f:
+        metadata = json.load(f)
+
+    slides_info = []
+    for num_str, data in metadata.get("slides", {}).items():
+        file_path = data.get("file_path", "")
+        html_path = (pres_dir.parent.parent / file_path) if file_path else None
+        if html_path and html_path.exists():
+            slides_info.append({
+                "number": int(num_str),
+                "title": data.get("title", f"Slide {num_str}"),
+                "path": html_path,
+            })
+
+    if not slides_info:
+        return {"success": False, "error": "No valid slides found"}
+
+    slides_info.sort(key=lambda s: s["number"])
+
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp_path = Path(tmp)
+
+        async with async_playwright() as p:
+            browser = await p.chromium.launch(
+                executable_path="/Users/markokraemer/Library/Caches/ms-playwright/chromium-1208/chrome-mac-arm64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing",
+                headless=True,
+                args=[
+                    "--no-sandbox",
+                    "--disable-setuid-sandbox",
+                    "--disable-dev-shm-usage",
+                    "--disable-gpu",
+                    "--force-device-scale-factor=1",
+                ],
+            )
+
+            try:
+                sem = asyncio.Semaphore(5)
+
+                async def render_limited(si):
+                    async with sem:
+                        return await render_slide_to_pdf(browser, si, tmp_path)
+
+                pdf_paths = await asyncio.gather(
+                    *[render_limited(si) for si in slides_info]
+                )
+            finally:
+                await browser.close()
+
+        sorted_paths = sorted(pdf_paths, key=lambda p: int(p.stem.split("_")[1]))
+        out = Path(output_path)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        combine_pdfs(sorted_paths, out)
+
+    return {
+        "success": True,
+        "output_path": str(out),
+        "total_slides": len(slides_info),
+    }
+
+
+def main():
+    if len(sys.argv) != 3:
+        print(json.dumps({"success": False, "error": "Usage: convert_pdf.py <presentation_dir> <output_path>"}))
+        sys.exit(1)
+
+    result = asyncio.run(convert(sys.argv[1], sys.argv[2]))
+    print(json.dumps(result))
+    sys.exit(0 if result["success"] else 1)
+
+
+if __name__ == "__main__":
+    main()