@lpm-registry/mcp-server 0.1.1 → 0.3.0

package/lib/auth.js

@@ -1,36 +1,90 @@
+import { createHash } from "node:crypto"
+import { isIP } from "node:net"
 import {
 	DEFAULT_REGISTRY_URL,
-	KEYTAR_ACCOUNT_NAME,
+	KEYTAR_ACCOUNT_PREFIX,
 	KEYTAR_SERVICE_NAME,
 } from "./constants.js"
 
+const KEYCHAIN_READ_ERROR =
+	"Unable to read LPM credentials from the OS keychain. Set LPM_TOKEN or run `lpm login` and retry."
+
 /**
  * Resolve the LPM auth token.
  * Priority: LPM_TOKEN env var → OS keychain (via keytar) → null
  *
+ * @param {() => Promise<unknown>} [loadKeytar]
  * @returns {Promise<string | null>}
  */
-export async function getToken() {
-	// 1. Environment variable (recommended for MCP configs)
+export async function getToken(loadKeytar = () => import("keytar")) {
 	if (process.env.LPM_TOKEN) {
 		return process.env.LPM_TOKEN
 	}
 
-	// 2. OS keychain (reads from same store as `lpm login`)
+	let keytarModule
 	try {
-		const keytar = await import("keytar")
-		const token = await keytar.default.getPassword(
-			KEYTAR_SERVICE_NAME,
-			KEYTAR_ACCOUNT_NAME,
-		)
-		if (token) return token
+		keytarModule = await loadKeytar()
+	} catch (error) {
+		if (
+			error &&
+			typeof error === "object" &&
+			"code" in error &&
+			(error.code === "ERR_MODULE_NOT_FOUND" ||
+				error.code === "MODULE_NOT_FOUND")
+		) {
+			return null
+		}
+		throw new Error(KEYCHAIN_READ_ERROR)
+	}
+
+	try {
+		const keytar = keytarModule.default ?? keytarModule
+		for (const account of keychainAccountsToTry(getBaseUrl())) {
+			const token = await keytar.getPassword(KEYTAR_SERVICE_NAME, account)
+			if (token) return token
+		}
 	} catch {
-		// keytar not available — this is expected in many environments
+		throw new Error(KEYCHAIN_READ_ERROR)
 	}
 
 	return null
 }
 
+/**
+ * The accounts that may hold the login for `registryUrl`, whichever way it
+ * ends: the one LPM CLI uses now, then the one CLI releases before 0.86 used
+ * for a login made with the registry spelled with a trailing slash.
+ *
+ * @param {string} registryUrl
+ * @returns {string[]}
+ */
+function keychainAccountsToTry(registryUrl) {
+	const canonical = registryUrl.replace(/\/+$/, "")
+	return [accountForKey(canonical), accountForKey(`${canonical}/`)]
+}
+
+/**
+ * Apply the LPM CLI's default registry transport contract: HTTPS, or HTTP
+ * only for loopback. The MCP server has no `--insecure` remote-HTTP escape hatch.
+ *
+ * @param {string | undefined} raw
+ * @returns {string}
+ */
+export function resolveRegistryUrl(raw = process.env.LPM_REGISTRY_URL) {
+	if (!raw) return DEFAULT_REGISTRY_URL
+
+	let parsed
+	try {
+		parsed = new URL(raw)
+	} catch {
+		return DEFAULT_REGISTRY_URL
+	}
+
+	if (parsed.protocol === "https:") return raw
+	if (parsed.protocol === "http:" && isLoopbackHost(parsed.hostname)) return raw
+	return DEFAULT_REGISTRY_URL
+}
+
 /**
  * Resolve the LPM registry base URL.
  * Priority: LPM_REGISTRY_URL env var → default
@@ -38,5 +92,43 @@ export async function getToken() {
  * @returns {string}
  */
 export function getBaseUrl() {
-	return process.env.LPM_REGISTRY_URL || DEFAULT_REGISTRY_URL
+	return resolveRegistryUrl()
+}
+
+/**
+ * Derive the keychain account used by LPM CLI for one effective registry URL.
+ * LPM CLI keys logins by the registry without trailing slashes, so both
+ * spellings name one account.
+ *
+ * @param {string} [registryUrl]
+ * @returns {string}
+ */
+export function getKeychainAccount(registryUrl = getBaseUrl()) {
+	return accountForKey(registryUrl.replace(/\/+$/, ""))
+}
+
+/** @param {string} key */
+function accountForKey(key) {
+	const digest = createHash("sha256").update(key, "utf8").digest("hex")
+	return `${KEYTAR_ACCOUNT_PREFIX}:${digest.slice(0, 16)}`
+}
+
+function isLoopbackHost(host) {
+	const unbracketed =
+		host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host
+	if (unbracketed.toLowerCase() === "localhost") return true
+
+	const version = isIP(unbracketed)
+	if (version === 4) return unbracketed.split(".", 1)[0] === "127"
+	if (version !== 6) return false
+
+	const normalized = new URL(`http://[${unbracketed}]/`).hostname
+		.slice(1, -1)
+		.toLowerCase()
+	if (normalized === "::1") return true
+
+	const mapped = normalized.match(/^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/)
+	if (!mapped) return false
+	const high = Number.parseInt(mapped[1], 16)
+	return high >> 8 === 127
 }

package/lib/cli.js

@@ -1,41 +1,83 @@
-import { execFile, execSync } from "node:child_process"
+import { execFile } from "node:child_process"
+import { accessSync, constants, realpathSync, statSync } from "node:fs"
+import { createRequire } from "node:module"
+import path from "node:path"
 
 const CLI_TIMEOUT_MS = 60_000
 
-/**
- * Resolve the path to the `lpm` CLI binary.
- *
- * Resolution order:
- * 1. LPM_CLI_PATH env var (explicit override)
- * 2. `which lpm` (global install)
- * 3. null (caller should handle fallback)
- *
- * @returns {string|null}
- */
-export function resolveCli() {
-	// 1. Explicit override
+/** Resolve an explicit CLI path or a global installation outside the caller's project. */
+export function resolveCli(platform = process.platform) {
 	const envPath = process.env.LPM_CLI_PATH
-	if (envPath) return envPath
+	if (envPath) {
+		const syntax = platform === "win32" ? path.win32 : path.posix
+		const qualified =
+			syntax.isAbsolute(envPath) &&
+			(platform !== "win32" || syntax.parse(envPath).root.length > 1)
+		return qualified ? envPath : null
+	}
+
+	const workspace = realpathSync(process.cwd())
+	for (const directory of (process.env.PATH || "").split(path.delimiter)) {
+		if (!path.isAbsolute(directory)) continue
+		const executable = globalExecutable(
+			path.join(directory, platform === "win32" ? "lpm.exe" : "lpm"),
+			workspace,
+			platform,
+		)
+		if (executable) return executable
+		if (platform !== "win32") continue
+
+		// npm exposes a .cmd shim. Resolve its native dependency without a shell.
+		try {
+			const wrapper = path.join(
+				directory,
+				"node_modules",
+				"@lpm-registry",
+				"cli",
+				"package.json",
+			)
+			if (!globalExecutable(wrapper, workspace, platform)) continue
+			const require = createRequire(wrapper)
+			const nativePackage = require.resolve(
+				"@lpm-registry/cli-win32-x64/package.json",
+			)
+			const native = globalExecutable(
+				path.join(path.dirname(nativePackage), "lpm.exe"),
+				workspace,
+				platform,
+			)
+			if (native) return native
+		} catch {
+			// Continue to the next PATH directory if optional native dependencies are absent.
+		}
+	}
+	return null
+}
 
-	// 2. Global install
+function globalExecutable(candidate, workspace, platform) {
 	try {
-		const result = execSync("which lpm", {
-			encoding: "utf-8",
-			timeout: 5_000,
-		}).trim()
-		if (result) return result
+		const resolved = realpathSync(candidate)
+		const relative = path.relative(workspace, resolved)
+		if (
+			relative === "" ||
+			(!relative.startsWith(`..${path.sep}`) &&
+				relative !== ".." &&
+				!path.isAbsolute(relative))
+		)
+			return null
+		if (!statSync(resolved).isFile()) return null
+		accessSync(resolved, platform === "win32" ? constants.F_OK : constants.X_OK)
+		return resolved
 	} catch {
-		// not found
+		return null
 	}
-
-	return null
 }
 
 /**
  * Run an LPM CLI command and return parsed JSON output.
  *
  * @param {string[]} args - CLI arguments (e.g., ['add', '@lpm.dev/owner.pkg', '--json'])
- * @param {{ timeout?: number }} options
+ * @param {{ timeout?: number, cwd?: string }} options
  * @returns {Promise<{ success: boolean, data: object|null, error: string|null }>}
  */
 export async function runCli(args, options = {}) {
@@ -58,6 +100,7 @@ export async function runCli(args, options = {}) {
 			args,
 			{
 				timeout,
+				cwd: options.cwd,
 				maxBuffer: 10 * 1024 * 1024,
 				env: { ...process.env },
 			},
@@ -74,13 +117,23 @@ export async function runCli(args, options = {}) {
 				// Try to parse JSON from stdout
 				try {
 					const data = JSON.parse(stdout)
+					if (!data || typeof data !== "object" || Array.isArray(data)) {
+						throw new Error("CLI returned an invalid result")
+					}
+					const success = !err && data.success !== false
+					const reason =
+						typeof data.error === "string" ? data.error : data.error?.message
 					resolve({
-						success: data.success !== false,
+						success,
 						data,
-						error:
-							data.success === false
-								? data.errors?.[0] || "Command failed"
-								: null,
+						error: success
+							? null
+							: reason ||
+								data.errors?.[0] ||
+								(err?.killed
+									? `CLI command timed out after ${timeout / 1000}s`
+									: err?.message) ||
+								"Command failed",
 					})
 				} catch {
 					// CLI produced output but not valid JSON

package/lib/constants.js

@@ -3,7 +3,7 @@
 export const DEFAULT_REGISTRY_URL = "https://lpm.dev"
 
 export const KEYTAR_SERVICE_NAME = "lpm-cli"
-export const KEYTAR_ACCOUNT_NAME = "auth-token"
+export const KEYTAR_ACCOUNT_PREFIX = "auth-token"
 
 export const REQUEST_TIMEOUT_MS = 30_000
 export const MAX_RETRIES = 2
@@ -31,5 +31,5 @@ export const ERROR_MESSAGES = {
 	timeout: "Request timed out. Try again later.",
 	invalidName:
 		"Invalid package name format. Expected: owner.package-name or @lpm.dev/owner.package-name",
-	searchNoParams: 'At least one of "query" or "category" is required.',
+	searchNoParams: "A search query or structured filter is required.",
 }

package/lib/format.js

@@ -65,3 +65,11 @@ export function parseName(input) {
 
 	return { owner, name }
 }
+
+/** Preserve CLI reports and mark failed process results as MCP tool errors. */
+export function cliResponse(result) {
+	if (!result.data) return errorResponse(result.error || "Command failed")
+	const response = jsonResponse(result.data)
+	if (!result.success) response.isError = true
+	return response
+}

package/lib/server.js

@@ -1,13 +1,16 @@
+import { createRequire } from "node:module"
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"
 import { z } from "zod"
 import { getBaseUrl, getToken } from "./auth.js"
 import { MemoryCache } from "./cache.js"
 import { add } from "./tools/add.js"
 import { apiDocs } from "./tools/api-docs.js"
+import { audit } from "./tools/audit.js"
 import { browseSource } from "./tools/browse-source.js"
-import { getInstallCommand } from "./tools/get-install-command.js"
+import { docs } from "./tools/docs.js"
 import { install } from "./tools/install.js"
 import { llmContext } from "./tools/llm-context.js"
+import { marketplaceInfo } from "./tools/marketplace-info.js"
 import { packageContext } from "./tools/package-context.js"
 import { packageInfo } from "./tools/package-info.js"
 import { packageSkills } from "./tools/package-skills.js"
@@ -18,6 +21,8 @@ import { search } from "./tools/search.js"
 import { searchOwners } from "./tools/search-owners.js"
 import { userInfo } from "./tools/user-info.js"
 
+const { version } = createRequire(import.meta.url)("../package.json")
+
 /**
  * Create and configure the MCP server with all LPM tools.
  * @returns {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer}
@@ -25,7 +30,7 @@ import { userInfo } from "./tools/user-info.js"
 export function createServer() {
 	const server = new McpServer({
 		name: "lpm-registry",
-		version: "0.1.0",
+		version,
 	})
 
 	const cache = new MemoryCache()
@@ -46,7 +51,7 @@ export function createServer() {
 
 	server.tool(
 		"lpm_quality_report",
-		"Get the quality score and detailed check breakdown for an LPM package (27 checks across documentation, code, testing, health)",
+		"Get the quality score and detailed, ecosystem-specific check breakdown for a package on the LPM.dev Registry across documentation, code quality, testing, and health.",
 		{
 			name: z.string().describe("Package name in owner.package-name format"),
 		},
@@ -89,7 +94,7 @@ export function createServer() {
 
 	server.tool(
 		"lpm_package_context",
-		"Get complete context for an LPM package in a single call — combines condensed package metadata (name, version, description, install method, dependencies), structured API docs (functions, classes, types), and LLM usage guide (quickStart, patterns, gotchas). Use this as the primary tool when you need to understand and use a package.",
+		"Get complete context for an LPM package in a single call — combines condensed package metadata (name, version, description, install method, dependencies), structured API docs (functions, classes, types), and LLM usage guide (quickStart, patterns, gotchas). Use this BEFORE installing to evaluate and understand a package. If the package is already installed locally, prefer reading local files directly and use lpm_package_skills for usage patterns instead.",
 		{
 			name: z
 				.string()
@@ -106,7 +111,7 @@ export function createServer() {
 
 	server.tool(
 		"lpm_package_skills",
-		"Get author-written Agent Skills for an LPM package - usage patterns, anti-patterns, gotchas, and best practices. Skills are version-specific and automatically resolve from local package.json if no version is specified.",
+		"Get author-written Agent Skills for an LPM package — usage patterns, anti-patterns, gotchas, and best practices for code generation. Use this when BUILDING with an already-installed package. Skills are version-specific and automatically resolve from local package.json if no version is specified.",
 		{
 			name: z
 				.string()
@@ -170,25 +175,33 @@ export function createServer() {
 	)
 
 	server.tool(
-		"lpm_get_install_command",
-		"Get the correct CLI command to install an LPM package. Returns either `lpm add` (extracts source files for customization — components, blocks, Swift packages) or `lpm install` (installs to node_modules as a dependency — libraries, utilities).",
+		"lpm_audit",
+		"Run a security audit on the project's LPM dependencies. Returns behavioral tags (eval, childProcess, shell, dynamicRequire), AI security findings, quality scores, and lifecycle scripts. Requires LPM CLI installed; registry access follows CLI authentication and policy.",
+		{
+			path: z
+				.string()
+				.optional()
+				.describe("Project directory to audit (defaults to current directory)"),
+		},
+		params => audit(params, context),
+	)
+
+	server.tool(
+		"lpm_marketplace_info",
+		"Get marketplace information for an LPM package — pricing, licensing model, seat management, and purchase status. Use this before recommending a paid package to check cost and access.",
 		{
 			name: z
 				.string()
 				.describe(
 					"Package name in owner.package-name or @lpm.dev/owner.package-name format",
 				),
-			version: z
-				.string()
-				.optional()
-				.describe("Specific version to install (defaults to latest)"),
 		},
-		params => getInstallCommand(params, context),
+		params => marketplaceInfo(params, context),
 	)
 
 	server.tool(
 		"lpm_add",
-		"Add an LPM package to the project by extracting source files for customization. Use for UI components, blocks, templates, Swift packages, and MCP servers. Requires LPM CLI installed.",
+		"Add an LPM package to the project by extracting source files for customization. Use for UI components, blocks, templates, and MCP servers. Requires LPM CLI installed.",
 		{
 			name: z
 				.string()
@@ -235,7 +248,7 @@ export function createServer() {
 
 	server.tool(
 		"lpm_install",
-		"Install an LPM package as a dependency to node_modules (like npm install). Use for JS libraries, utilities, and SDKs. Requires LPM CLI installed.",
+		"Install an LPM package as a managed dependency. JS packages go to node_modules (like npm install), Swift packages edit Package.swift via SE-0292. Use for libraries, utilities, and SDKs. Requires LPM CLI installed.",
 		{
 			name: z
 				.string()
@@ -252,9 +265,11 @@ export function createServer() {
 
 	server.tool(
 		"lpm_browse_source",
-		`Browse source code of an LPM package you have access to. Use without \`path\` to see the file tree first, then request specific files or directories with \`path\`. Requires authentication. Pool packages require Pool subscription, marketplace packages require a license.
+		`LAST RESORT: Browse source code of an LPM package remotely. Only use this when you cannot install the package (e.g., evaluating before purchase, checking capabilities without access). If you can install the package, prefer lpm_add or lpm_install first, then read the local files directly — it is faster.
+
+Requires authentication. Pool packages require Pool subscription, marketplace packages require a license.
 
-IMPORTANT: Prefer fetching directory paths (e.g., "src", "components") to get all files under that directory in a single request, rather than requesting individual files one by one. To get ALL source files at once, pass an empty string "" as path.`,
+If you must use this tool: fetch directory paths (e.g., "src") to get multiple files in one request rather than individual files.`,
 		{
 			name: z
 				.string()
@@ -296,7 +311,7 @@ IMPORTANT: Prefer fetching directory paths (e.g., "src", "components") to get al
 					'Filter by package ecosystem (e.g., "swift" for iOS/macOS packages)',
 				),
 			distribution: z
-				.enum(["marketplace", "pool", "private"])
+				.enum(["free", "marketplace", "pool", "private"])
 				.optional()
 				.describe("Filter by distribution mode"),
 			packageType: z
@@ -353,5 +368,25 @@ IMPORTANT: Prefer fetching directory paths (e.g., "src", "components") to get al
 		params => search(params, context),
 	)
 
+	server.tool(
+		"lpm_docs",
+		"Search or read LPM documentation. Use this when the user asks how to use LPM itself — setup, CLI commands, publishing, CI/CD, Swift registry, organizations, billing, etc. Without parameters: returns the docs index. With `page`: returns that specific page. With `query`: searches page titles and returns matching content.",
+		{
+			page: z
+				.string()
+				.optional()
+				.describe(
+					'Documentation page slug (e.g., "cli/commands", "packages/swift-registry", "getting-started/installation")',
+				),
+			query: z
+				.string()
+				.optional()
+				.describe(
+					'Search query to find relevant docs (e.g., "npmrc", "swift", "CI deployment")',
+				),
+		},
+		params => docs(params, context),
+	)
+
 	return server
 }

package/lib/tools/add.js

@@ -1,17 +1,22 @@
 import { runCli } from "../cli.js"
-import { errorResponse, parseName, textResponse } from "../format.js"
+import { cliResponse, errorResponse, parseName } from "../format.js"
 
 /**
  * Add an LPM package to the user's project via the CLI.
  * Extracts source files into the project for customization.
  *
  * @param {{ name: string, version?: string, path?: string, alias?: string, target?: string, force?: boolean, installDeps?: boolean, config?: Record<string, string> }} params
- * @param {{ getToken: () => Promise<string|null> }} ctx
  */
-export async function add(
-	{ name, version, path, alias, target, force, installDeps, config },
-	ctx,
-) {
+export async function add({
+	name,
+	version,
+	path,
+	alias,
+	target,
+	force,
+	installDeps,
+	config,
+}) {
 	let owner, pkgName
 	try {
 		const parsed = parseName(name)
@@ -21,13 +26,6 @@ export async function add(
 		return errorResponse(err.message)
 	}
 
-	const token = await ctx.getToken()
-	if (!token) {
-		return errorResponse(
-			"Authentication required. Set LPM_TOKEN environment variable or run `lpm login`.",
-		)
-	}
-
 	// Build package reference with optional config params as URL query string
 	let pkgRef = `@lpm.dev/${owner}.${pkgName}`
 	if (version) pkgRef += `@${version}`
@@ -49,31 +47,5 @@ export async function add(
 
 	const result = await runCli(args)
 
-	if (!result.success) {
-		return errorResponse(result.error || "Failed to add package.")
-	}
-
-	// Format the result for the AI
-	const data = result.data
-	const summary = {
-		success: true,
-		package: data.package,
-		installPath: data.installPath,
-		alias: data.alias || null,
-		files: (data.files || []).map(f => ({
-			dest: f.dest,
-			action: f.action,
-		})),
-		dependencies: data.dependencies || { npm: [], lpm: [] },
-	}
-
-	if (data.config && Object.keys(data.config).length > 0) {
-		summary.config = data.config
-	}
-
-	if (data.warnings?.length > 0) {
-		summary.warnings = data.warnings
-	}
-
-	return textResponse(JSON.stringify(summary, null, 2))
+	return cliResponse(result)
 }

package/lib/tools/audit.js

@@ -0,0 +1,19 @@
+import { runCli } from "../cli.js"
+import { cliResponse } from "../format.js"
+
+/**
+ * Run a security audit on the project's LPM dependencies.
+ * Returns behavioral tags, AI security findings, quality scores, and lifecycle scripts.
+ *
+ * @param {{ path?: string }} params
+ */
+export async function audit({ path }) {
+	const args = ["audit", "--json"]
+
+	const result = await runCli(args, {
+		timeout: 30_000,
+		...(path && { cwd: path }),
+	})
+
+	return cliResponse(result)
+}

package/lib/tools/docs.js

@@ -0,0 +1,101 @@
+import { CACHE_TTL } from "../constants.js"
+import { errorResponse, textResponse } from "../format.js"
+
+const DOCS_BASE_URL = "https://lpm.dev/api/docs"
+
+/**
+ * Search or read LPM documentation.
+ *
+ * - Without `page`: returns the full docs index (page titles and slugs).
+ * - With `page`: returns the content of that specific documentation page.
+ * - With `query`: searches page titles for matches and returns their content.
+ *
+ * @param {{ page?: string, query?: string }} params
+ * @param {{ cache: import('../cache.js').MemoryCache }} ctx
+ */
+export async function docs({ page, query }, ctx) {
+	// Mode 1: Fetch a specific page
+	if (page) {
+		const slug = page.replace(/^\//, "").replace(/\/$/, "")
+		const cacheKey = `docs:page:${slug}`
+
+		const cached = ctx.cache.get(cacheKey)
+		if (cached) return cached
+
+		const response = await fetchText(`${DOCS_BASE_URL}/${slug}`)
+		if (!response.ok) {
+			if (response.status === 404) {
+				return errorResponse(
+					`Documentation page "${slug}" not found. Use this tool without a page parameter to see all available pages.`,
+				)
+			}
+			return errorResponse(`Failed to fetch docs (${response.status})`)
+		}
+
+		const content = await response.text()
+		const result = textResponse(content)
+		ctx.cache.set(cacheKey, result, CACHE_TTL.LONG)
+		return result
+	}
+
+	// Mode 2: Search or list index
+	const cacheKey = "docs:index"
+	let indexText = ctx.cache.get(cacheKey)
+
+	if (!indexText) {
+		const response = await fetchText(DOCS_BASE_URL)
+		if (!response.ok) {
+			return errorResponse(`Failed to fetch docs index (${response.status})`)
+		}
+		indexText = await response.text()
+		ctx.cache.set(cacheKey, indexText, CACHE_TTL.LONG)
+	} else {
+		// Cache stores the textResponse wrapper, extract the text
+		indexText =
+			typeof indexText === "string"
+				? indexText
+				: indexText?.content?.[0]?.text || indexText
+	}
+
+	// If query is provided, filter the index and fetch matching pages
+	if (query) {
+		const queryLower = query.toLowerCase()
+		const lines =
+			typeof indexText === "string"
+				? indexText.split("\n")
+				: String(indexText).split("\n")
+		const matches = lines.filter(
+			line => line.includes(" — ") && line.toLowerCase().includes(queryLower),
+		)
+
+		if (matches.length === 0) {
+			return textResponse(
+				`No documentation pages found matching "${query}".\n\nAvailable pages:\n${indexText}`,
+			)
+		}
+
+		// Fetch content of matching pages (up to 3)
+		const results = []
+		for (const match of matches.slice(0, 3)) {
+			const slug = match.split(" — ")[0].trim()
+			const response = await fetchText(`${DOCS_BASE_URL}/${slug}`)
+			if (response.ok) {
+				const content = await response.text()
+				results.push(`--- ${slug} ---\n${content}`)
+			}
+		}
+
+		return textResponse(results.join("\n\n"))
+	}
+
+	// No query, no page — return the full index
+	return textResponse(
+		typeof indexText === "string" ? indexText : String(indexText),
+	)
+}
+
+async function fetchText(url) {
+	return fetch(url, {
+		headers: { Accept: "text/plain" },
+	})
+}