chore: import upstream snapshot with attribution

tests/unit/jina-reader-executor.test.ts

@@ -0,0 +1,174 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+const { jinaReaderFetch } = await import("../../open-sse/executors/jina-reader-fetch.ts");
+
+// ── jinaReaderFetch tests ─────────────────────────────────────────────────────
+
+test("jinaReaderFetch calls r.jina.ai/{url} with Bearer auth", async () => {
+  const originalFetch = globalThis.fetch;
+  let captured: { url: string; headers: Record<string, string> } = { url: "", headers: {} };
+
+  globalThis.fetch = async (url, init = {}) => {
+    captured = {
+      url: String(url),
+      headers: (init as RequestInit).headers as Record<string, string>,
+    };
+    return new Response("# Hello from Jina", {
+      status: 200,
+      headers: { "content-type": "text/plain" },
+    });
+  };
+
+  try {
+    const result = await jinaReaderFetch({
+      url: "https://example.com",
+      format: "markdown",
+      includeMetadata: false,
+      credentials: { apiKey: "jina-test-key" },
+    });
+
+    assert.equal(result.success, true);
+    assert.ok(
+      captured.url.startsWith("https://r.jina.ai/"),
+      `URL should start with https://r.jina.ai/, got: ${captured.url}`
+    );
+    assert.ok(
+      captured.url.includes(encodeURIComponent("https://example.com")),
+      "URL should include encoded target URL"
+    );
+    assert.equal(captured.headers["Authorization"], "Bearer jina-test-key");
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test("jinaReaderFetch returns 401 error when no API key", async () => {
+  const result = await jinaReaderFetch({
+    url: "https://example.com",
+    format: "markdown",
+    includeMetadata: false,
+    credentials: {},
+  });
+
+  assert.equal(result.success, false);
+  assert.equal(result.status, 401);
+  assert.ok(!result.error?.includes("at /"), "error must not contain stack trace");
+});
+
+test("jinaReaderFetch propagates non-200 status without stack trace", async () => {
+  const originalFetch = globalThis.fetch;
+
+  globalThis.fetch = async () => {
+    return new Response("Forbidden", {
+      status: 403,
+      headers: { "content-type": "text/plain" },
+    });
+  };
+
+  try {
+    const result = await jinaReaderFetch({
+      url: "https://example.com",
+      format: "markdown",
+      includeMetadata: false,
+      credentials: { apiKey: "bad-key" },
+    });
+
+    assert.equal(result.success, false);
+    assert.equal(result.status, 403);
+    assert.ok(result.error, "should have error message");
+    assert.ok(!result.error.includes("at /"), "error must not contain stack trace");
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test("jinaReaderFetch parses JSON response with data.content", async () => {
+  const originalFetch = globalThis.fetch;
+
+  globalThis.fetch = async () => {
+    return new Response(
+      JSON.stringify({
+        data: {
+          content: "# Parsed content",
+          title: "Title from JSON",
+          description: "A description",
+          links: ["https://example.com/a", "https://example.com/b"],
+        },
+      }),
+      { status: 200, headers: { "content-type": "application/json" } }
+    );
+  };
+
+  try {
+    const result = await jinaReaderFetch({
+      url: "https://example.com",
+      format: "markdown",
+      includeMetadata: true,
+      credentials: { apiKey: "jina-key" },
+    });
+
+    assert.equal(result.success, true);
+    assert.ok(result.data, "should have data");
+    assert.equal(result.data.provider, "jina-reader");
+    assert.ok(result.data.content.includes("Parsed content"), "content should be parsed");
+    assert.ok(result.data.metadata?.title === "Title from JSON", "metadata title should be set");
+    assert.equal(result.data.screenshot_url, null);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test("jinaReaderFetch falls back to plain text when response is not JSON", async () => {
+  const originalFetch = globalThis.fetch;
+
+  globalThis.fetch = async () => {
+    return new Response("Plain text content from Jina", {
+      status: 200,
+      headers: { "content-type": "text/plain; charset=utf-8" },
+    });
+  };
+
+  try {
+    const result = await jinaReaderFetch({
+      url: "https://example.com",
+      format: "markdown",
+      includeMetadata: false,
+      credentials: { apiKey: "jina-key" },
+    });
+
+    assert.equal(result.success, true);
+    assert.ok(
+      result.data?.content.includes("Plain text content"),
+      "should include plain text content"
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test("jinaReaderFetch sets X-Return-Format header to html for html format", async () => {
+  const originalFetch = globalThis.fetch;
+  let capturedHeaders: Record<string, string> = {};
+
+  globalThis.fetch = async (_url, init = {}) => {
+    capturedHeaders = (init as RequestInit).headers as Record<string, string>;
+    return new Response("<html>content</html>", {
+      status: 200,
+      headers: { "content-type": "text/html" },
+    });
+  };
+
+  try {
+    await jinaReaderFetch({
+      url: "https://example.com",
+      format: "html",
+      includeMetadata: false,
+      credentials: { apiKey: "jina-key" },
+    });
+
+    assert.equal(capturedHeaders["X-Return-Format"], "html");
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});