@anna-ai/cli 0.1.11 → 0.1.14

package/dist/mascot-wlYTJqMs.js

@@ -0,0 +1,218 @@
+import kleur from "kleur";
+
+//#region src/mascot.ts
+const FACE = [
+	255,
+	227,
+	234
+];
+const EYE = [
+	122,
+	90,
+	101
+];
+const GEO = (() => {
+	const VX0 = 252, VY0 = 280, VW = 520;
+	const n = (x, y) => [(x - VX0) / VW, (y - VY0) / VW];
+	const r = (v) => v / VW;
+	const [fcx, fcy] = n(512, 540);
+	const [lex, ley] = n(462, 520);
+	const [rex, rey] = n(562, 520);
+	return {
+		face: {
+			cx: fcx,
+			cy: fcy,
+			r: r(260)
+		},
+		eyeL: {
+			cx: lex,
+			cy: ley,
+			r: r(34)
+		},
+		eyeR: {
+			cx: rex,
+			cy: rey,
+			r: r(34)
+		}
+	};
+})();
+/** Sample the SVG at normalized (x, y) ∈ [0, 1]². Returns null for empty. */
+function sampleSvg(x, y) {
+	const inCircle = (cx, cy, r) => {
+		const dx = x - cx, dy = y - cy;
+		return dx * dx + dy * dy <= r * r;
+	};
+	let c = null;
+	if (inCircle(GEO.face.cx, GEO.face.cy, GEO.face.r)) c = FACE;
+	return c;
+}
+/**
+* 2×2 supersampled pixel using **majority vote** (not averaging).
+* Anti-aliases silhouette edges (filled vs empty) while keeping every
+* pixel a pure palette color — no muddy blends between the pink face and
+* the dark eyes. Ties resolve in favor of the topmost layer encountered.
+*/
+function pixel(px, py, w, h) {
+	const counts = new Map();
+	let nulls = 0;
+	for (const oy of [.25, .75]) for (const ox of [.25, .75]) {
+		const s = sampleSvg((px + ox) / w, (py + oy) / h);
+		if (!s) {
+			nulls++;
+			continue;
+		}
+		const key = `${s[0]},${s[1]},${s[2]}`;
+		const entry = counts.get(key);
+		if (entry) entry.n++;
+		else counts.set(key, {
+			color: s,
+			n: 1
+		});
+	}
+	if (counts.size === 0) return null;
+	let best = null;
+	for (const e of counts.values()) if (!best || e.n > best.n) best = e;
+	if (nulls > (best?.n ?? 0)) return null;
+	return best.color;
+}
+const FG = (c) => `\x1b[38;2;${c[0]};${c[1]};${c[2]}m`;
+const BG = (c) => `\x1b[48;2;${c[0]};${c[1]};${c[2]}m`;
+const BG_DEFAULT = "\x1B[49m";
+const RESET = "\x1B[0m";
+function eq(a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+}
+/**
+* Rasterize the face into a list of half-block lines.
+* `cols` is character width; pixel rows are derived from the cell aspect
+* so each pixel covers an (approximately) square area on screen.
+*/
+function renderFace(cols, cellAspect) {
+	const W = cols;
+	const charRows = Math.max(1, Math.round(cols / cellAspect));
+	const H = charRows * 2;
+	const eyeRow = Math.round(GEO.eyeL.cy * charRows - .5);
+	const eyeColL = Math.max(0, Math.round(GEO.eyeL.cx * W) - 1);
+	const eyeColR = Math.max(0, Math.round(GEO.eyeR.cx * W) - 1);
+	const isEyeCell = (cx, cy) => cy === eyeRow && (cx >= eyeColL && cx < eyeColL + 2 || cx >= eyeColR && cx < eyeColR + 2);
+	const rows = [];
+	for (let cy = 0; cy < charRows; cy++) {
+		let line = "";
+		let lastFg = null;
+		let lastBg = null;
+		let lastBgDefault = true;
+		for (let cx = 0; cx < W; cx++) {
+			if (isEyeCell(cx, cy)) {
+				if (!eq(lastFg, EYE)) {
+					line += FG(EYE);
+					lastFg = EYE;
+				}
+				if (lastBgDefault || !eq(lastBg, FACE)) {
+					line += BG(FACE);
+					lastBg = FACE;
+					lastBgDefault = false;
+				}
+				line += "█";
+				continue;
+			}
+			const top = pixel(cx, cy * 2, W, H);
+			const bot = pixel(cx, cy * 2 + 1, W, H);
+			if (!top && !bot) {
+				if (!lastBgDefault) {
+					line += BG_DEFAULT;
+					lastBgDefault = true;
+					lastBg = null;
+				}
+				line += " ";
+				continue;
+			}
+			if (top && bot) {
+				if (!eq(lastFg, top)) {
+					line += FG(top);
+					lastFg = top;
+				}
+				if (lastBgDefault || !eq(lastBg, bot)) {
+					line += BG(bot);
+					lastBg = bot;
+					lastBgDefault = false;
+				}
+				line += "▀";
+			} else if (top) {
+				if (!eq(lastFg, top)) {
+					line += FG(top);
+					lastFg = top;
+				}
+				if (!lastBgDefault) {
+					line += BG_DEFAULT;
+					lastBgDefault = true;
+					lastBg = null;
+				}
+				line += "▀";
+			} else {
+				if (!eq(lastFg, bot)) {
+					line += FG(bot);
+					lastFg = bot;
+				}
+				if (!lastBgDefault) {
+					line += BG_DEFAULT;
+					lastBgDefault = true;
+					lastBg = null;
+				}
+				line += "▄";
+			}
+		}
+		rows.push(line + RESET);
+	}
+	return rows;
+}
+function mascotEnabled() {
+	if (process.env.ANNA_CLI_NO_MASCOT) return false;
+	if (process.env.NO_COLOR) return false;
+	if (process.env.ANNA_CLI_FORCE_MASCOT) return true;
+	return Boolean(process.stdout.isTTY);
+}
+function pickWidth() {
+	const override = Number.parseInt(process.env.ANNA_CLI_MASCOT_WIDTH ?? "", 10);
+	if (Number.isFinite(override) && override >= 10 && override <= 120) return override;
+	const cols = process.stdout.columns || 80;
+	if (cols < 60) return 10;
+	if (cols >= 120) return 16;
+	return 13;
+}
+function pickAspect() {
+	const v = Number.parseFloat(process.env.ANNA_CLI_MASCOT_ASPECT ?? "");
+	if (Number.isFinite(v) && v >= 1.2 && v <= 3) return v;
+	return 2.1;
+}
+/**
+* Render the mascot as a multi-line string. Always returns the colored art
+* (callers decide whether to print based on `mascotEnabled`).
+*/
+function renderMascot(message) {
+	const cols = pickWidth();
+	const aspect = pickAspect();
+	const face = renderFace(cols, aspect);
+	const pad = " ".repeat(2);
+	const label = kleur.magenta().bold("Anna");
+	const tagline = kleur.gray("Anna App developer CLI");
+	const textLines = [`${label}  ${tagline}`];
+	if (message) textLines.push(`${kleur.gray("›")} ${message}`);
+	const start = Math.max(0, Math.floor((face.length - textLines.length) / 2));
+	const lines = [];
+	for (let i = 0; i < face.length; i++) {
+		const tIdx = i - start;
+		const text = tIdx >= 0 && tIdx < textLines.length ? "  " + textLines[tIdx] : "";
+		lines.push(pad + face[i] + text);
+	}
+	return lines.join("\n");
+}
+/** Print the mascot to stderr if enabled. Stderr keeps stdout clean for piping. */
+function printMascot(message) {
+	if (!mascotEnabled()) return;
+	process.stderr.write(renderMascot(message) + "\n\n");
+}
+
+//#endregion
+export { printMascot };

package/dist/runner-Bral1LFW.js

@@ -0,0 +1,279 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+
+//#region src/executa/runner.ts
+/** Spec describing where the host advertises its capabilities. */
+const HOST_INITIALIZE_PARAMS = {
+	protocolVersion: "2.0",
+	client_capabilities: {
+		sampling: {},
+		agent: {},
+		storage: {}
+	},
+	client_info: {
+		name: "anna-app-cli",
+		version: "executa-dev"
+	}
+};
+var ExecutaRunner = class {
+	proc = null;
+	nextId = 1;
+	pending = new Map();
+	exitWaiters = [];
+	closed = false;
+	/** Resolved by start() after the v2 handshake (or v1 fallback) succeeds. */
+	initialized = null;
+	constructor(opts) {
+		this.opts = opts;
+	}
+	/** Spawn the subprocess and perform the initialize handshake. */
+	async start() {
+		if (this.proc) {
+			if (!this.initialized) throw new Error("executa already starting");
+			return this.initialized;
+		}
+		const [bin, ...args] = this.opts.command;
+		if (!bin) throw new Error("ExecutaRunner: empty command");
+		const env = {
+			...process.env,
+			...this.opts.env
+		};
+		env.ANNA_EXECUTA_DEV = "1";
+		this.proc = spawn(bin, args, {
+			cwd: this.opts.cwd,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			env
+		});
+		const stderrSink = this.opts.onStderr ?? ((l) => process.stderr.write(`[executa] ${l}\n`));
+		createInterface({ input: this.proc.stderr }).on("line", stderrSink);
+		this.proc.on("exit", (code) => {
+			this.closed = true;
+			const waiters = this.exitWaiters.splice(0);
+			for (const w of waiters) w(code);
+			const err = new Error(`executa exited (code=${code ?? "null"})`);
+			for (const p of this.pending.values()) p.reject(err);
+			this.pending.clear();
+		});
+		this.proc.on("error", (e) => {
+			this.closed = true;
+			for (const p of this.pending.values()) p.reject(e);
+			this.pending.clear();
+		});
+		createInterface({ input: this.proc.stdout }).on("line", (line) => {
+			this.handleLine(line, stderrSink);
+		});
+		const initTimeout = this.opts.initTimeoutMs ?? 8e3;
+		try {
+			const raw = await this.callWithTimeout("initialize", HOST_INITIALIZE_PARAMS, initTimeout);
+			const ver = String(raw.protocolVersion ?? "1.0");
+			this.initialized = {
+				protocolVersion: ver === "2.0" ? "2.0" : "1.0",
+				raw
+			};
+		} catch (e) {
+			const rpc = e.rpc;
+			if (rpc && rpc.code === -32601) this.initialized = {
+				protocolVersion: "1.0",
+				raw: {}
+			};
+			else {
+				await this.stop();
+				throw e;
+			}
+		}
+		return this.initialized;
+	}
+	/** Send a JSON-RPC request and await the response. */
+	call(method, params = {}) {
+		if (this.closed || !this.proc) return Promise.reject(new Error("executa not running"));
+		const id = this.nextId++;
+		const env = {
+			jsonrpc: "2.0",
+			id,
+			method,
+			params
+		};
+		return new Promise((resolve, reject) => {
+			this.pending.set(id, {
+				resolve: (v) => resolve(v),
+				reject
+			});
+			this.proc.stdin.write(`${JSON.stringify(env)}\n`);
+		});
+	}
+	/** Convenience: `describe → MANIFEST`. */
+	describe() {
+		return this.call("describe");
+	}
+	/** Convenience: `invoke {tool, arguments}`. */
+	invoke(tool, args) {
+		return this.call("invoke", {
+			tool,
+			arguments: args
+		});
+	}
+	/** Convenience: `health → {status}`. */
+	health() {
+		return this.call("health");
+	}
+	/** Close stdin (graceful EOF shutdown) then SIGTERM after a grace period. */
+	async stop(graceMs = 1500) {
+		if (!this.proc) return;
+		this.closed = true;
+		const p = this.proc;
+		try {
+			p.stdin.end();
+		} catch {}
+		const waitExit = new Promise((resolve) => {
+			this.exitWaiters.push(resolve);
+			if (p.exitCode != null) resolve(p.exitCode);
+		});
+		const timer = new Promise((resolve) => {
+			setTimeout(() => resolve("timeout"), graceMs);
+		});
+		const winner = await Promise.race([waitExit, timer]);
+		if (winner === "timeout") try {
+			p.kill("SIGTERM");
+		} catch {}
+		this.proc = null;
+	}
+	async callWithTimeout(method, params, ms) {
+		const id = this.nextId++;
+		const env = {
+			jsonrpc: "2.0",
+			id,
+			method,
+			params
+		};
+		return new Promise((resolve, reject) => {
+			const to = setTimeout(() => {
+				this.pending.delete(id);
+				reject(new Error(`executa ${method} timed out after ${ms}ms`));
+			}, ms);
+			this.pending.set(id, {
+				resolve: (v) => {
+					clearTimeout(to);
+					resolve(v);
+				},
+				reject: (e) => {
+					clearTimeout(to);
+					reject(e);
+				}
+			});
+			this.proc.stdin.write(`${JSON.stringify(env)}\n`);
+		});
+	}
+	handleLine(line, stderrSink) {
+		if (!line.trim()) return;
+		let env;
+		try {
+			env = JSON.parse(line);
+		} catch {
+			stderrSink(`non-json from executa stdout: ${line}`);
+			return;
+		}
+		if (typeof env.method === "string") {
+			this.handleReverse(env);
+			return;
+		}
+		const id = env.id;
+		if (typeof id !== "number") return;
+		const pending = this.pending.get(id);
+		if (!pending) return;
+		this.pending.delete(id);
+		if (env.error) {
+			const e = env.error;
+			const err = new Error(`[${e.code}] ${e.message}`);
+			err.rpc = e;
+			pending.reject(err);
+		} else pending.resolve(env.result);
+	}
+	async handleReverse(env) {
+		const id = env.id;
+		const method = env.method;
+		const params = env.params ?? {};
+		const respond = (body) => {
+			if (id === void 0 || id === null) return;
+			if (!this.proc) return;
+			const out = {
+				jsonrpc: "2.0",
+				id,
+				...body
+			};
+			try {
+				this.proc.stdin.write(`${JSON.stringify(out)}\n`);
+			} catch {}
+		};
+		if (method === "sampling/createMessage") {
+			if (!this.opts.sampling) {
+				respond({ error: {
+					code: -32008,
+					message: "sampling not configured (use `anna-app login` and rerun without `--no-sampling`, or pass `--mock-sampling`)"
+				} });
+				return;
+			}
+			try {
+				const result = await this.opts.sampling.createMessage(params);
+				respond({ result });
+			} catch (e) {
+				const code = e.rpcCode ?? -32e3;
+				respond({ error: {
+					code,
+					message: e.message
+				} });
+			}
+			return;
+		}
+		if (method.startsWith("agent/")) {
+			if (!this.opts.agent) {
+				respond({ error: {
+					code: -32041,
+					message: "agent reverse-RPC not configured (rerun without `--no-agent`, or pass `--mock-agent <fixture>`)"
+				} });
+				return;
+			}
+			try {
+				const result = await this.opts.agent.call(method, params);
+				respond({ result });
+			} catch (e) {
+				const code = e.rpcCode ?? -32e3;
+				respond({ error: {
+					code,
+					message: e.message
+				} });
+			}
+			return;
+		}
+		if (method.startsWith("storage/") || method.startsWith("files/")) {
+			if (!this.opts.storage) {
+				respond({ error: {
+					code: -32021,
+					message: "storage not configured (rerun with `--storage memory|mock|real`)"
+				} });
+				return;
+			}
+			try {
+				const result = await this.opts.storage.call(method, params);
+				respond({ result });
+			} catch (e) {
+				const code = e.rpcCode ?? -32e3;
+				respond({ error: {
+					code,
+					message: e.message
+				} });
+			}
+			return;
+		}
+		respond({ error: {
+			code: -32601,
+			message: `unknown reverse method: ${method}`
+		} });
+	}
+};
+
+//#endregion
+export { ExecutaRunner };

package/dist/sampling-3EfSlDHM.js

@@ -0,0 +1,155 @@
+import { canonicalHost, getAccount } from "./credentials-BTv2IfUZ.js";
+import { resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+
+//#region src/executa/sampling.ts
+var SamplingBridge = class {
+	mocks = [];
+	cachedSession = null;
+	constructor(opts) {
+		this.opts = opts;
+		if (opts.mode === "mock" && opts.mockFile) {
+			const path = resolve(opts.mockFile);
+			if (existsSync(path)) for (const line of readFileSync(path, "utf8").split(/\r?\n/)) {
+				if (!line.trim() || line.startsWith("#")) continue;
+				try {
+					this.mocks.push(JSON.parse(line));
+				} catch {}
+			}
+		}
+	}
+	async createMessage(req) {
+		if (this.opts.mode === "off") throw withCode(new Error("sampling disabled — rerun without `--no-sampling`"), -32008);
+		if (this.opts.mode === "mock") return this.mockMessage(req);
+		return this.realMessage(req);
+	}
+	mockMessage(req) {
+		const content = collectContent(req);
+		const entry = this.mocks.find((m) => m.ns === "sampling" && m.method === "createMessage" || m.ns === "llm" && m.method === "complete") ?? null;
+		const matched = entry && (!entry.match?.contentIncludes || content.includes(entry.match.contentIncludes)) ? entry : this.mocks.find((m) => m.ns === "sampling" && m.method === "createMessage" || m.ns === "llm" && m.method === "complete");
+		if (matched && matched.result) return normaliseSamplingResult(matched.result, "mock-model");
+		return {
+			role: "assistant",
+			content: {
+				type: "text",
+				text: "(mock) no fixture matched"
+			},
+			model: "mock-model",
+			stopReason: "endTurn"
+		};
+	}
+	account() {
+		const acc = getAccount(this.opts.account);
+		if (!acc) throw withCode(new Error("no PAT on disk — run `anna-app login --host <nexus-url>` first (or pass `--mock-sampling <fixture>` / `--no-sampling`)"), -32001);
+		if (acc.expires_at && acc.expires_at < Math.floor(Date.now() / 1e3)) throw withCode(new Error("PAT expired — run `anna-app login` again"), -32001);
+		return acc;
+	}
+	async mint() {
+		if (this.cachedSession && this.cachedSession.expiresAt - 30 > Math.floor(Date.now() / 1e3)) return this.cachedSession;
+		const acc = this.account();
+		if (!this.opts.appSlug) throw withCode(new Error("sampling bridge has no app_slug — pass `--app-slug <slug>` to `anna-app executa dev` so nexus can attribute the spend"), -32602);
+		const url = `${canonicalHost(acc.host)}/api/v1/anna-apps/dev/session/mint`;
+		const res = await fetch(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				pat: acc.pat,
+				kind: "complete",
+				app_slug: this.opts.appSlug
+			})
+		});
+		if (!res.ok) {
+			const text = await res.text().catch(() => "");
+			throw withCode(new Error(`session.mint failed: HTTP ${res.status} ${text}`), -32e3);
+		}
+		const body = await res.json();
+		this.cachedSession = {
+			appSessionToken: body.app_session_token,
+			expiresAt: Math.floor(Date.now() / 1e3) + (body.expires_in || 600)
+		};
+		return this.cachedSession;
+	}
+	async realMessage(req) {
+		const acc = this.account();
+		const session = await this.mint();
+		const body = mcpToCompleteBody(req);
+		const res = await fetch(`${canonicalHost(acc.host)}/api/v1/copilot/app/complete`, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				authorization: `Bearer ${session.appSessionToken}`
+			},
+			body: JSON.stringify(body)
+		});
+		if (!res.ok) {
+			const text = await res.text().catch(() => "");
+			throw withCode(new Error(`HTTP ${res.status}: ${text}`), -32e3);
+		}
+		const out = await res.json();
+		return normaliseSamplingResult(out, out.model ?? "unknown");
+	}
+};
+function withCode(err, code) {
+	err.rpcCode = code;
+	return err;
+}
+/** Collect a single string view of a sampling request — used for mock matching. */
+function collectContent(req) {
+	const parts = [];
+	if (req.systemPrompt) parts.push(req.systemPrompt);
+	for (const m of req.messages ?? []) {
+		const c = m.content;
+		if (typeof c === "string") parts.push(c);
+		else if (c && typeof c === "object" && "text" in c) parts.push(c.text);
+	}
+	return parts.join("\n");
+}
+/**
+* Translate an MCP `sampling/createMessage` request to the nexus
+* `/api/v1/copilot/app/complete` body. Mapping is intentionally lossy —
+* we forward only the fields nexus understands.
+*/
+function mcpToCompleteBody(req) {
+	const messages = (req.messages ?? []).map((m) => ({
+		role: m.role,
+		content: typeof m.content === "string" ? m.content : m.content.text
+	}));
+	const out = { messages };
+	if (req.systemPrompt) out.system = req.systemPrompt;
+	if (req.maxTokens != null) out.max_tokens = req.maxTokens;
+	if (req.temperature != null) out.temperature = req.temperature;
+	if (req.stopSequences) out.stop = req.stopSequences;
+	const hint = req.modelPreferences?.hints?.[0]?.name;
+	if (hint) out.model_hint = hint;
+	if (req.metadata) out.metadata = req.metadata;
+	return out;
+}
+/** Coerce arbitrary nexus / fixture output into a `SamplingResult`. */
+function normaliseSamplingResult(raw, fallbackModel) {
+	if (!raw || typeof raw !== "object") return {
+		role: "assistant",
+		content: {
+			type: "text",
+			text: String(raw ?? "")
+		},
+		model: fallbackModel,
+		stopReason: "endTurn"
+	};
+	const r = raw;
+	if (r.role === "assistant" && r.content && typeof r.content === "object") return r;
+	const text = typeof r.text === "string" && r.text || (typeof r.content === "string" ? r.content : "") || (typeof r.message === "string" ? r.message : "") || "";
+	return {
+		role: "assistant",
+		content: {
+			type: "text",
+			text
+		},
+		model: r.model ?? fallbackModel,
+		stopReason: r.stop_reason ?? r.stopReason ?? "endTurn",
+		usage: r.usage ?? void 0,
+		_meta: { source: "nexus" }
+	};
+}
+
+//#endregion
+export { SamplingBridge };

package/dist/{server-Cd5Lo-2v.js → server-q6nKCeEV.js}

@@ -1,4 +1,4 @@
-import { canonicalHost, getAccount } from "./credentials-ggdaz_-7.js";
+import { canonicalHost, getAccount } from "./credentials-BTv2IfUZ.js";
 import { dirname, join, normalize, resolve } from "node:path";
 import { createRequire } from "node:module";
 import { createReadStream, existsSync, readFileSync, statSync, watch } from "node:fs";
@@ -48,12 +48,12 @@ var LlmBridge = class {
 		const cached = this.mintedAuto.get(windowUuid);
 		if (cached && cached.expiresAt - 30 > Math.floor(Date.now() / 1e3)) return cached;
 		const acc = this.account();
+		const slug = this.requireAppSlug();
 		const body = {
 			pat: acc.pat,
 			kind: "complete",
-			app_id: this.opts.appId ?? null
+			app_slug: slug
 		};
-		if (!body.app_id) body.app_id = 1;
 		const minted = await this.callMint(acc.host, body);
 		const ms = {
 			appSessionToken: minted.app_session_token,
@@ -68,13 +68,14 @@ var LlmBridge = class {
 	/** Mint a kind=agent session — called from `agent.session.create`. */
 	async mintAgent(args) {
 		const acc = this.account();
+		const slug = this.requireAppSlug();
 		const submode = args.submode ?? "auto";
 		const body = {
 			pat: acc.pat,
 			kind: "agent",
 			submode,
 			fixed_client_id: args.fixed_client_id ?? args.fixedClientId ?? null,
-			app_id: this.opts.appId ?? 1,
+			app_slug: slug,
 			label: args.label ?? "anna-app dev",
 			quota_caps: args.quotaCaps ?? null
 		};
@@ -89,6 +90,11 @@ var LlmBridge = class {
 		this.mintedAgent.set(ms.appSessionUuid, ms);
 		return ms;
 	}
+	/** Throws a friendly error if no appSlug was wired into the bridge. */
+	requireAppSlug() {
+		if (!this.opts.appSlug) throw new Error("llm bridge has no app_slug — the harness must register the dev app via POST /api/v1/anna-apps/dev/apps/register before minting sessions. (Run `anna-app login` once, then `anna-app dev` will auto-register the manifest slug.)");
+		return this.opts.appSlug;
+	}
 	async callMint(host, body) {
 		const url = `${canonicalHost(host)}/api/v1/anna-apps/dev/session/mint`;
 		const res = await fetch(url, {