@benjypng/logseq-request 1.0.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 benjypng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,198 @@
+# @benjypng/logseq-request
+
+CORS-free HTTP requests for Logseq plugins.
+
+Since the Electron update that ships a stricter CORS policy, direct `fetch`
+(and fetch-based libraries like wretch or axios) from a plugin's
+`lsp://logseq.com` origin to external APIs is blocked at the preflight stage.
+Logseq's experimental request API (`exper_request`) proxies the call through
+the main process, which is not subject to CORS. This package wraps that proxy
+in a small, typed, wretch-like API.
+
+## Install
+
+```bash
+npm install @benjypng/logseq-request
+# or
+bun add @benjypng/logseq-request
+```
+
+Zero dependencies. Requires running inside a Logseq plugin (it uses the
+`logseq` global that `@logseq/libs` sets up in your plugin's entry), so it
+works anywhere after `logseq.ready()` with no extra setup.
+
+## Quick start
+
+```ts
+import { proxy } from '@benjypng/logseq-request'
+
+const data = await proxy('https://api.anthropic.com/v1/messages')
+  .headers({
+    'x-api-key': apiKey,
+    'anthropic-version': '2023-06-01',
+    'content-type': 'application/json',
+  })
+  .post({ model, max_tokens: 1024, messages })
+  .json<ChatResponse>()
+```
+
+## Full plugin example
+
+```ts
+// main.ts — your plugin entry
+import '@logseq/libs'
+import {
+  HttpError,
+  proxy,
+  ProxyUnavailableError,
+} from '@benjypng/logseq-request'
+
+const main = async () => {
+  logseq.Editor.registerSlashCommand('Ask Claude', async () => {
+    try {
+      const data = await proxy('https://api.anthropic.com/v1/messages')
+        .headers({
+          'x-api-key': logseq.settings?.apiKey as string,
+          'anthropic-version': '2023-06-01',
+          'content-type': 'application/json',
+        })
+        .post({
+          model: 'claude-sonnet-4-6',
+          max_tokens: 1024,
+          messages: [{ role: 'user', content: 'Hello' }],
+        })
+        .json<{ content: { text: string }[] }>()
+
+      await logseq.Editor.insertAtEditingCursor(data.content[0].text)
+    } catch (e) {
+      if (e instanceof HttpError) {
+        // Real HTTP failure (4xx/5xx) — status and body available on DB builds
+        logseq.UI.showMsg(`API error ${e.status}: ${e.body}`, 'error')
+      } else if (e instanceof ProxyUnavailableError) {
+        // Endpoint unreachable / IPC dead — message starts "Failed to fetch:"
+        logseq.UI.showMsg('Could not reach the API. Network up?', 'error')
+      }
+    }
+  })
+}
+
+logseq.ready(main).catch(console.error)
+```
+
+## API
+
+All methods:
+
+```ts
+proxy(url).get().json<T>()
+proxy(url).headers(h).post(body).json<T>()
+proxy(url).headers(h).put(body).text()
+proxy(url).headers(h).patch(body).json<T>()
+proxy(url).headers(h).delete().json<T>()
+```
+
+- `.headers()` merges across calls (later wins). Builders are immutable —
+  each call returns a new one, so you can branch safely:
+
+  ```ts
+  const api = proxy('https://api.example.com/v1').headers(authHeaders)
+  await api.get().json<Status>() // base unchanged
+  await api.headers({ 'x-extra': '1' }).post(body).json<Result>()
+  ```
+
+- Nothing is sent until you call `.json<T>()` or `.text()` — a method call
+  returns a lazy response handle.
+- `.json<T>()` parses the response body as JSON; `.text()` returns the raw
+  body string.
+- `.timeout(ms)` (opt-in, no default) fails the request if the proxy never
+  responds — useful against dead IPC. LLM calls can run for minutes, so no
+  timeout is applied unless you ask for one.
+
+### Error handling
+
+```ts
+import { HttpError, ProxyUnavailableError } from '@benjypng/logseq-request'
+
+try {
+  await proxy(url).post(body).json()
+} catch (e) {
+  if (e instanceof HttpError) {
+    // HTTP-level failure (DB builds only — see Limitations)
+    console.error(e.status, e.statusText, e.body, e.json())
+  } else if (e instanceof ProxyUnavailableError) {
+    // Unreachable endpoint, dead IPC, or timeout.
+    // e.message always starts with "Failed to fetch:".
+  }
+}
+```
+
+- **`HttpError`** — thrown when the response reports `ok: false`. Carries
+  `status: number`, `statusText?: string`, `body: string`, and a lazy
+  `json<T>()` that returns `undefined` if the body isn't valid JSON.
+- **`ProxyUnavailableError`** — thrown when the proxy yields no response
+  (unreachable endpoint, dead IPC) or the opt-in timeout elapses. Its message
+  always starts with `Failed to fetch:` so existing connection-error handling
+  that pattern-matches on that prefix keeps working.
+
+### Low-level escape hatch
+
+```ts
+import { proxyRequest } from '@benjypng/logseq-request'
+
+const data = await proxyRequest<MyResponse>({
+  url,
+  method: 'POST',
+  headers,
+  body,
+  timeoutMs: 30_000,
+})
+```
+
+`proxyRequestRaw()` goes one level lower still: it returns the normalized
+response body without JSON parsing (a string in the typical case).
+
+## Limitations
+
+- **No streaming.** `exper_request` buffers the full response; SSE/streaming
+  APIs are not supported. Request non-streaming variants from providers.
+- **HTTP errors are invisible on markdown builds (0.10.x).** Those builds
+  ignore `includeResponse` and return the bare body, so there is no status
+  code to inspect; `HttpError` is only thrown on DB builds (2.x). Error
+  bodies on markdown builds surface as JSON parse results instead.
+- **No abort/cancellation.** The underlying IPC offers none; `.timeout(ms)`
+  abandons the wait but cannot cancel the in-flight request.
+
+## How it works
+
+`exper_request` is invoked via Logseq's internal
+`_execCallableAPIAsync('exper_request', pluginId, options)`, which returns a
+request id; the response arrives on a `task_callback_<id>` event. Responses
+are normalized across Logseq builds: DB (2.x) honours `includeResponse` and
+returns `{ status, ok, body }`; markdown (0.10.x) returns the bare body;
+`null`/`undefined` (unreachable endpoint) becomes `ProxyUnavailableError`.
+
+The package deliberately has no dependency on `@logseq/libs`: there is no
+instance to import from it (the `logseq` global is created as a side effect
+of the consumer's own import), and the IPC members used here are
+undocumented internals that its public types don't cover. Minimal types for
+exactly the members used are defined in-package instead.
+
+## Local development
+
+To consume the package from another project before it's published:
+
+```bash
+# in this repo
+bun install && bun run build
+
+# in your plugin
+bun add file:../logseq-request
+# or: `bun link` here, then `bun link @benjypng/logseq-request` in the plugin
+```
+
+Scripts: `bun run test` (vitest), `bun run typecheck`, `bun run build`
+(tsdown → ESM + CJS + d.ts), `bun run lint` (Biome).
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,137 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/errors.ts
+/** Thrown when a DB-build response wrapper reports ok: false. */
+var HttpError = class extends Error {
+	constructor(status, statusText, body) {
+		super(statusText || `HTTP ${status}`);
+		this.name = "HttpError";
+		this.status = status;
+		this.statusText = statusText;
+		this.body = body;
+	}
+	/** Parse the error body as JSON; undefined if it isn't valid JSON. */
+	json() {
+		try {
+			return JSON.parse(this.body);
+		} catch {
+			return;
+		}
+	}
+};
+/**
+* Thrown when the proxy yields no response: unreachable endpoint, dead IPC,
+* or the opt-in timeout elapsing. The "Failed to fetch" prefix is part of the
+* contract — consumers pattern-match it for connection-error guidance.
+*/
+var ProxyUnavailableError = class extends Error {
+	constructor(detail) {
+		super(`Failed to fetch: ${detail}`);
+		this.name = "ProxyUnavailableError";
+	}
+};
+//#endregion
+//#region src/core.ts
+/**
+* Send a request through Logseq's CORS-free `exper_request` proxy and return
+* the response body, normalized across Logseq builds:
+*  - DB (2.x): honours includeResponse -> { status, ok, body, ... }; we
+*    unwrap to the body string, throwing HttpError when ok is false.
+*  - markdown (0.10.x): ignores includeResponse -> the bare body (a string,
+*    or an object/array the host already parsed). Note: HTTP errors cannot
+*    be detected on these builds — there is no status to inspect.
+*  - unreachable endpoint / dead IPC: null/undefined -> ProxyUnavailableError.
+*
+* Returns a string in the typical case; an object/array when an older build
+* pre-parsed the body.
+*/
+const proxyRequestRaw = async (input) => {
+	const options = {
+		url: input.url,
+		method: input.method,
+		headers: input.headers ?? {},
+		returnType: "text",
+		includeResponse: true
+	};
+	if (input.body !== void 0) options.data = input.body;
+	const host = logseq;
+	const reqID = await host._execCallableAPIAsync("exper_request", host.baseInfo.id, options);
+	const callback = new Promise((resolve) => {
+		host.Request.once(`task_callback_${reqID}`, resolve);
+	});
+	let res;
+	if (input.timeoutMs === void 0) res = await callback;
+	else {
+		let timer;
+		try {
+			res = await Promise.race([callback, new Promise((_, reject) => {
+				timer = setTimeout(() => reject(new ProxyUnavailableError(`no response from the request proxy within ${input.timeoutMs}ms`)), input.timeoutMs);
+			})]);
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	if (res == null) throw new ProxyUnavailableError("no response from the request proxy. Is the endpoint reachable (local model running / network up)?");
+	if (typeof res === "object" && typeof res.status === "number") {
+		const wrapped = res;
+		if (!wrapped.ok) throw new HttpError(wrapped.status, wrapped.statusText, wrapped.body);
+		return wrapped.body;
+	}
+	return res;
+};
+/** Low-level escape hatch: proxy a request and parse the response as JSON. */
+const proxyRequest = async (input) => {
+	const body = await proxyRequestRaw(input);
+	if (typeof body === "string") return JSON.parse(body);
+	return body;
+};
+//#endregion
+//#region src/builder.ts
+/**
+* Wretch-like builder over Logseq's CORS-free request proxy. Each call
+* returns a new immutable builder; nothing is sent until `.json()` or
+* `.text()` is called on the response handle.
+*/
+const proxy = (url) => {
+	const make = (headers, timeoutMs) => {
+		const dispatch = (method, body) => {
+			const input = {
+				url,
+				method,
+				headers
+			};
+			if (body !== void 0) input.body = body;
+			if (timeoutMs !== void 0) input.timeoutMs = timeoutMs;
+			return {
+				json: async () => {
+					const res = await proxyRequestRaw(input);
+					if (typeof res === "string") return JSON.parse(res);
+					return res;
+				},
+				text: async () => {
+					const res = await proxyRequestRaw(input);
+					if (typeof res === "string") return res;
+					return JSON.stringify(res);
+				}
+			};
+		};
+		return {
+			headers: (h) => make({
+				...headers,
+				...h
+			}, timeoutMs),
+			timeout: (ms) => make(headers, ms),
+			get: () => dispatch("GET"),
+			post: (body) => dispatch("POST", body),
+			put: (body) => dispatch("PUT", body),
+			patch: (body) => dispatch("PATCH", body),
+			delete: () => dispatch("DELETE")
+		};
+	};
+	return make({}, void 0);
+};
+//#endregion
+exports.HttpError = HttpError;
+exports.ProxyUnavailableError = ProxyUnavailableError;
+exports.proxy = proxy;
+exports.proxyRequest = proxyRequest;
+exports.proxyRequestRaw = proxyRequestRaw;

package/dist/index.d.cts

@@ -0,0 +1,86 @@
+//#region src/builder.d.ts
+interface ResponseHandle {
+  /** Send the request and parse the response body as JSON. */
+  json: <T = unknown>() => Promise<T>;
+  /** Send the request and return the raw body text. */
+  text: () => Promise<string>;
+}
+interface ProxyBuilder {
+  /** Merge headers into the request; later calls win on conflicts. */
+  headers: (headers: Record<string, string>) => ProxyBuilder;
+  /** Fail with ProxyUnavailableError if no response arrives within ms. */
+  timeout: (ms: number) => ProxyBuilder;
+  get: () => ResponseHandle;
+  post: (body?: object) => ResponseHandle;
+  put: (body?: object) => ResponseHandle;
+  patch: (body?: object) => ResponseHandle;
+  delete: () => ResponseHandle;
+}
+/**
+ * Wretch-like builder over Logseq's CORS-free request proxy. Each call
+ * returns a new immutable builder; nothing is sent until `.json()` or
+ * `.text()` is called on the response handle.
+ */
+declare const proxy: (url: string) => ProxyBuilder;
+//#endregion
+//#region src/types.d.ts
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+/** Input to the low-level proxyRequest / proxyRequestRaw functions. */
+interface ProxyRequestInput {
+  url: string;
+  method: HttpMethod;
+  headers?: Record<string, string>;
+  /** JSON-serialisable request body. Omitted from the wire when undefined. */
+  body?: object;
+  /**
+   * Milliseconds to wait for the proxy callback before throwing
+   * ProxyUnavailableError. Default: no timeout (LLM calls can run minutes).
+   */
+  timeoutMs?: number;
+}
+/** Wrapper shape returned by DB (2.x) builds. */
+interface ProxyResponse {
+  status: number;
+  statusText?: string;
+  ok: boolean;
+  body: string;
+}
+//#endregion
+//#region src/core.d.ts
+/**
+ * Send a request through Logseq's CORS-free `exper_request` proxy and return
+ * the response body, normalized across Logseq builds:
+ *  - DB (2.x): honours includeResponse -> { status, ok, body, ... }; we
+ *    unwrap to the body string, throwing HttpError when ok is false.
+ *  - markdown (0.10.x): ignores includeResponse -> the bare body (a string,
+ *    or an object/array the host already parsed). Note: HTTP errors cannot
+ *    be detected on these builds — there is no status to inspect.
+ *  - unreachable endpoint / dead IPC: null/undefined -> ProxyUnavailableError.
+ *
+ * Returns a string in the typical case; an object/array when an older build
+ * pre-parsed the body.
+ */
+declare const proxyRequestRaw: (input: ProxyRequestInput) => Promise<unknown>;
+/** Low-level escape hatch: proxy a request and parse the response as JSON. */
+declare const proxyRequest: <T>(input: ProxyRequestInput) => Promise<T>;
+//#endregion
+//#region src/errors.d.ts
+/** Thrown when a DB-build response wrapper reports ok: false. */
+declare class HttpError extends Error {
+  readonly status: number;
+  readonly statusText?: string;
+  readonly body: string;
+  constructor(status: number, statusText: string | undefined, body: string);
+  /** Parse the error body as JSON; undefined if it isn't valid JSON. */
+  json<T = unknown>(): T | undefined;
+}
+/**
+ * Thrown when the proxy yields no response: unreachable endpoint, dead IPC,
+ * or the opt-in timeout elapsing. The "Failed to fetch" prefix is part of the
+ * contract — consumers pattern-match it for connection-error guidance.
+ */
+declare class ProxyUnavailableError extends Error {
+  constructor(detail: string);
+}
+//#endregion
+export { HttpError, type HttpMethod, type ProxyBuilder, type ProxyRequestInput, type ProxyResponse, ProxyUnavailableError, type ResponseHandle, proxy, proxyRequest, proxyRequestRaw };

package/dist/index.d.mts

@@ -0,0 +1,86 @@
+//#region src/builder.d.ts
+interface ResponseHandle {
+  /** Send the request and parse the response body as JSON. */
+  json: <T = unknown>() => Promise<T>;
+  /** Send the request and return the raw body text. */
+  text: () => Promise<string>;
+}
+interface ProxyBuilder {
+  /** Merge headers into the request; later calls win on conflicts. */
+  headers: (headers: Record<string, string>) => ProxyBuilder;
+  /** Fail with ProxyUnavailableError if no response arrives within ms. */
+  timeout: (ms: number) => ProxyBuilder;
+  get: () => ResponseHandle;
+  post: (body?: object) => ResponseHandle;
+  put: (body?: object) => ResponseHandle;
+  patch: (body?: object) => ResponseHandle;
+  delete: () => ResponseHandle;
+}
+/**
+ * Wretch-like builder over Logseq's CORS-free request proxy. Each call
+ * returns a new immutable builder; nothing is sent until `.json()` or
+ * `.text()` is called on the response handle.
+ */
+declare const proxy: (url: string) => ProxyBuilder;
+//#endregion
+//#region src/types.d.ts
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+/** Input to the low-level proxyRequest / proxyRequestRaw functions. */
+interface ProxyRequestInput {
+  url: string;
+  method: HttpMethod;
+  headers?: Record<string, string>;
+  /** JSON-serialisable request body. Omitted from the wire when undefined. */
+  body?: object;
+  /**
+   * Milliseconds to wait for the proxy callback before throwing
+   * ProxyUnavailableError. Default: no timeout (LLM calls can run minutes).
+   */
+  timeoutMs?: number;
+}
+/** Wrapper shape returned by DB (2.x) builds. */
+interface ProxyResponse {
+  status: number;
+  statusText?: string;
+  ok: boolean;
+  body: string;
+}
+//#endregion
+//#region src/core.d.ts
+/**
+ * Send a request through Logseq's CORS-free `exper_request` proxy and return
+ * the response body, normalized across Logseq builds:
+ *  - DB (2.x): honours includeResponse -> { status, ok, body, ... }; we
+ *    unwrap to the body string, throwing HttpError when ok is false.
+ *  - markdown (0.10.x): ignores includeResponse -> the bare body (a string,
+ *    or an object/array the host already parsed). Note: HTTP errors cannot
+ *    be detected on these builds — there is no status to inspect.
+ *  - unreachable endpoint / dead IPC: null/undefined -> ProxyUnavailableError.
+ *
+ * Returns a string in the typical case; an object/array when an older build
+ * pre-parsed the body.
+ */
+declare const proxyRequestRaw: (input: ProxyRequestInput) => Promise<unknown>;
+/** Low-level escape hatch: proxy a request and parse the response as JSON. */
+declare const proxyRequest: <T>(input: ProxyRequestInput) => Promise<T>;
+//#endregion
+//#region src/errors.d.ts
+/** Thrown when a DB-build response wrapper reports ok: false. */
+declare class HttpError extends Error {
+  readonly status: number;
+  readonly statusText?: string;
+  readonly body: string;
+  constructor(status: number, statusText: string | undefined, body: string);
+  /** Parse the error body as JSON; undefined if it isn't valid JSON. */
+  json<T = unknown>(): T | undefined;
+}
+/**
+ * Thrown when the proxy yields no response: unreachable endpoint, dead IPC,
+ * or the opt-in timeout elapsing. The "Failed to fetch" prefix is part of the
+ * contract — consumers pattern-match it for connection-error guidance.
+ */
+declare class ProxyUnavailableError extends Error {
+  constructor(detail: string);
+}
+//#endregion
+export { HttpError, type HttpMethod, type ProxyBuilder, type ProxyRequestInput, type ProxyResponse, ProxyUnavailableError, type ResponseHandle, proxy, proxyRequest, proxyRequestRaw };

package/dist/index.mjs

@@ -0,0 +1,132 @@
+//#region src/errors.ts
+/** Thrown when a DB-build response wrapper reports ok: false. */
+var HttpError = class extends Error {
+	constructor(status, statusText, body) {
+		super(statusText || `HTTP ${status}`);
+		this.name = "HttpError";
+		this.status = status;
+		this.statusText = statusText;
+		this.body = body;
+	}
+	/** Parse the error body as JSON; undefined if it isn't valid JSON. */
+	json() {
+		try {
+			return JSON.parse(this.body);
+		} catch {
+			return;
+		}
+	}
+};
+/**
+* Thrown when the proxy yields no response: unreachable endpoint, dead IPC,
+* or the opt-in timeout elapsing. The "Failed to fetch" prefix is part of the
+* contract — consumers pattern-match it for connection-error guidance.
+*/
+var ProxyUnavailableError = class extends Error {
+	constructor(detail) {
+		super(`Failed to fetch: ${detail}`);
+		this.name = "ProxyUnavailableError";
+	}
+};
+//#endregion
+//#region src/core.ts
+/**
+* Send a request through Logseq's CORS-free `exper_request` proxy and return
+* the response body, normalized across Logseq builds:
+*  - DB (2.x): honours includeResponse -> { status, ok, body, ... }; we
+*    unwrap to the body string, throwing HttpError when ok is false.
+*  - markdown (0.10.x): ignores includeResponse -> the bare body (a string,
+*    or an object/array the host already parsed). Note: HTTP errors cannot
+*    be detected on these builds — there is no status to inspect.
+*  - unreachable endpoint / dead IPC: null/undefined -> ProxyUnavailableError.
+*
+* Returns a string in the typical case; an object/array when an older build
+* pre-parsed the body.
+*/
+const proxyRequestRaw = async (input) => {
+	const options = {
+		url: input.url,
+		method: input.method,
+		headers: input.headers ?? {},
+		returnType: "text",
+		includeResponse: true
+	};
+	if (input.body !== void 0) options.data = input.body;
+	const host = logseq;
+	const reqID = await host._execCallableAPIAsync("exper_request", host.baseInfo.id, options);
+	const callback = new Promise((resolve) => {
+		host.Request.once(`task_callback_${reqID}`, resolve);
+	});
+	let res;
+	if (input.timeoutMs === void 0) res = await callback;
+	else {
+		let timer;
+		try {
+			res = await Promise.race([callback, new Promise((_, reject) => {
+				timer = setTimeout(() => reject(new ProxyUnavailableError(`no response from the request proxy within ${input.timeoutMs}ms`)), input.timeoutMs);
+			})]);
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	if (res == null) throw new ProxyUnavailableError("no response from the request proxy. Is the endpoint reachable (local model running / network up)?");
+	if (typeof res === "object" && typeof res.status === "number") {
+		const wrapped = res;
+		if (!wrapped.ok) throw new HttpError(wrapped.status, wrapped.statusText, wrapped.body);
+		return wrapped.body;
+	}
+	return res;
+};
+/** Low-level escape hatch: proxy a request and parse the response as JSON. */
+const proxyRequest = async (input) => {
+	const body = await proxyRequestRaw(input);
+	if (typeof body === "string") return JSON.parse(body);
+	return body;
+};
+//#endregion
+//#region src/builder.ts
+/**
+* Wretch-like builder over Logseq's CORS-free request proxy. Each call
+* returns a new immutable builder; nothing is sent until `.json()` or
+* `.text()` is called on the response handle.
+*/
+const proxy = (url) => {
+	const make = (headers, timeoutMs) => {
+		const dispatch = (method, body) => {
+			const input = {
+				url,
+				method,
+				headers
+			};
+			if (body !== void 0) input.body = body;
+			if (timeoutMs !== void 0) input.timeoutMs = timeoutMs;
+			return {
+				json: async () => {
+					const res = await proxyRequestRaw(input);
+					if (typeof res === "string") return JSON.parse(res);
+					return res;
+				},
+				text: async () => {
+					const res = await proxyRequestRaw(input);
+					if (typeof res === "string") return res;
+					return JSON.stringify(res);
+				}
+			};
+		};
+		return {
+			headers: (h) => make({
+				...headers,
+				...h
+			}, timeoutMs),
+			timeout: (ms) => make(headers, ms),
+			get: () => dispatch("GET"),
+			post: (body) => dispatch("POST", body),
+			put: (body) => dispatch("PUT", body),
+			patch: (body) => dispatch("PATCH", body),
+			delete: () => dispatch("DELETE")
+		};
+	};
+	return make({}, void 0);
+};
+//#endregion
+export { HttpError, ProxyUnavailableError, proxy, proxyRequest, proxyRequestRaw };

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@benjypng/logseq-request",
+  "version": "1.0.0",
+  "description": "CORS-free HTTP requests for Logseq plugins, via Logseq's exper_request proxy",
+  "author": "benjypng",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/benjypng/logseq-request.git"
+  },
+  "keywords": [
+    "logseq",
+    "logseq-plugin",
+    "cors",
+    "http",
+    "request",
+    "fetch"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts --format esm,cjs --dts --clean",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check --write .",
+    "prepare": "husky"
+  },
+  "release": {
+    "branches": [
+      "main"
+    ]
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.11",
+    "husky": "^9.1.7",
+    "tsdown": "^0.22.2",
+    "typescript": "^5.5.4",
+    "vitest": "^3.2.4"
+  }
+}