pockcode 0.0.1

package/dist/assets/api.server-D6ONM6ZJ.js

@@ -0,0 +1,1736 @@
+import { c as readWorkspaceTree, d as readRecordField, f as readStringField, l as HttpError, o as listWorkspaceDirectory, s as readWorkspaceResource, u as readBooleanField } from "./socket.server-7dC-9Fnw.js";
+import { A as listProviderAdapters, B as readNumber, C as createAccount, D as readConnectedAccountLimits, E as listAccounts, F as resolveCodexAccountHome, H as ensureDatabase, I as startCodexMcpOauthLogin, L as updateCodexInstructions, N as readCodexInstructions, P as reloadCodexMcpServerConfig, R as asJsonObject, S as authenticateAccount, T as listAccountModels, U as prisma, V as readString, a as executeMessage, b as updateChat, c as interruptChatRun, f as refreshChat, g as reviewChat, h as respondToServerRequest, i as deleteQueuedChatRun, j as listCodexMcpServerStatuses, k as updateAccount, l as listChats, m as reorderQueuedChatRuns, n as compactChat, o as forkChat, r as createChat, t as archiveChat, u as listMessages, v as steerQueuedChatRun, w as deleteAccount, x as updateQueuedChatRun, z as readBoolean } from "./chats.service-H6m23Fna.js";
+import { a as listMessageSchedules, c as updateMessageSchedule, i as listMessageScheduleRuns, n as createMessageSchedule, r as getMessageSchedule, t as archiveMessageSchedule } from "./message-schedules.service-Be9t4LDg.js";
+import { a as readPluginSetting, c as listPluginRegistrations, d as deleteWorkspaceHistory, f as listWorkspaceHistory, i as restartPlugin, l as readPluginRegistration, n as getPluginStatus, o as readPluginState, p as saveWorkspaceHistory, s as writePluginSetting, t as createPluginContext, u as verifyTelegramBotToken } from "./manager.server-Cru4ZxHo.js";
+import { realpathSync } from "node:fs";
+import { mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
+import path, { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { Prisma } from "@prisma/client";
+import { homedir } from "node:os";
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import { parse, stringify } from "smol-toml";
+//#region app/server/cloudflared.service.ts
+var execFileAsync$1 = promisify(execFile);
+var temporaryTunnelReadyTimeoutMs = 35e3;
+var maxLogLines = 80;
+var tryCloudflareUrlPattern = /https:\/\/[a-z0-9-]+(?:\.[a-z0-9-]+)*\.trycloudflare\.com/iu;
+var temporaryTunnels = /* @__PURE__ */ new Map();
+async function readCloudflaredStatus() {
+	const installation = await readCloudflaredInstallation();
+	if (!installation.installed) return {
+		installed: false,
+		message: installation.message,
+		namedTunnels: [],
+		temporaryTunnels: listTemporaryTunnels()
+	};
+	try {
+		return {
+			installed: true,
+			namedTunnels: await listNamedTunnels(),
+			temporaryTunnels: listTemporaryTunnels(),
+			version: installation.version
+		};
+	} catch (error) {
+		const namedTunnelsAuthRequired = isMissingOriginCertError(error);
+		return {
+			installed: true,
+			namedTunnels: [],
+			namedTunnelsAuthRequired,
+			namedTunnelsError: namedTunnelsAuthRequired ? "Named tunnels require a cloudflared origin certificate. Run `cloudflared tunnel login` or set TUNNEL_ORIGIN_CERT, then refresh. Temporary tunnels still work without named-tunnel login." : cleanCommandError(error, "Unable to list cloudflared tunnels."),
+			temporaryTunnels: listTemporaryTunnels(),
+			version: installation.version
+		};
+	}
+}
+async function startTemporaryCloudflaredTunnel(originUrl) {
+	const normalizedOriginUrl = normalizeOriginUrl(originUrl);
+	await ensureCloudflaredInstalled();
+	const record = {
+		child: null,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		id: randomUUID(),
+		logs: [],
+		originUrl: normalizedOriginUrl,
+		status: "starting",
+		stopRequested: false
+	};
+	temporaryTunnels.set(record.id, record);
+	const child = spawn("cloudflared", [
+		"tunnel",
+		"--url",
+		normalizedOriginUrl
+	], { stdio: [
+		"ignore",
+		"pipe",
+		"pipe"
+	] });
+	record.child = child;
+	attachTemporaryTunnelListeners(record, child);
+	await waitForTemporaryTunnelUrl(record);
+	return readCloudflaredStatus();
+}
+async function stopTemporaryCloudflaredTunnel(id) {
+	const record = temporaryTunnels.get(id);
+	if (!record) throw new HttpError(404, "Temporary tunnel was not found.");
+	record.stopRequested = true;
+	record.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
+	record.status = "stopped";
+	appendLog(record, "Stopped by Pockcode.");
+	if (record.child && !record.child.killed) {
+		record.child.kill("SIGTERM");
+		setTimeout(() => {
+			if (record.child && !record.child.killed) record.child.kill("SIGKILL");
+		}, 2e3).unref();
+	} else {
+		record.status = "stopped";
+		record.child = null;
+	}
+	return readCloudflaredStatus();
+}
+async function deleteNamedCloudflaredTunnel(identifier) {
+	const tunnelIdentifier = normalizeTunnelIdentifier(identifier);
+	await ensureCloudflaredInstalled();
+	await runCloudflared([
+		"tunnel",
+		"delete",
+		"-f",
+		tunnelIdentifier
+	], 6e4);
+	return readCloudflaredStatus();
+}
+async function readCloudflaredInstallation() {
+	try {
+		return {
+			installed: true,
+			version: parseCloudflaredVersion((await runCloudflared(["--version"], 1e4)).stdout)
+		};
+	} catch (error) {
+		return {
+			installed: false,
+			message: cleanCommandError(error, "cloudflared is not installed or not available on PATH.")
+		};
+	}
+}
+async function ensureCloudflaredInstalled() {
+	const installation = await readCloudflaredInstallation();
+	if (!installation.installed) throw new HttpError(400, installation.message);
+}
+async function listNamedTunnels() {
+	const result = await runCloudflared([
+		"tunnel",
+		"list",
+		"--output",
+		"json"
+	], 3e4);
+	const parsed = JSON.parse(result.stdout.trim() || "[]");
+	return (Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" && Array.isArray(parsed.tunnels) ? parsed.tunnels : []).map(readNamedTunnel).filter((tunnel) => Boolean(tunnel));
+}
+function readNamedTunnel(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value;
+	const id = readRecordString(record, "id") ?? readRecordString(record, "uuid");
+	if (!id) return null;
+	const name = readRecordString(record, "name") ?? id;
+	const createdAt = readRecordString(record, "createdAt") ?? readRecordString(record, "created_at");
+	const connections = Array.isArray(record.connections) ? record.connections : [];
+	const rawStatus = readRecordString(record, "status");
+	const status = rawStatus === "active" || rawStatus === "inactive" ? rawStatus : connections.length ? "active" : "inactive";
+	return {
+		connectionCount: connections.length,
+		createdAt,
+		id,
+		name,
+		status
+	};
+}
+function attachTemporaryTunnelListeners(record, child) {
+	const handleOutput = (chunk) => {
+		const text = chunk.toString("utf8");
+		appendLog(record, text);
+		const match = text.match(tryCloudflareUrlPattern) ?? record.logs.join("\n").match(tryCloudflareUrlPattern);
+		if (match?.[0] && !record.publicUrl) {
+			record.publicUrl = match[0];
+			record.status = "running";
+		}
+	};
+	child.stdout.on("data", handleOutput);
+	child.stderr.on("data", handleOutput);
+	child.once("error", (error) => {
+		appendLog(record, cleanCommandError(error, "cloudflared failed to start."));
+		record.child = null;
+		record.exitCode = null;
+		record.status = "exited";
+		record.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
+	});
+	child.once("exit", (code, signal) => {
+		record.child = null;
+		record.exitCode = code;
+		record.signal = signal;
+		record.status = record.stopRequested ? "stopped" : "exited";
+		record.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
+	});
+}
+async function waitForTemporaryTunnelUrl(record) {
+	const startedAt = Date.now();
+	while (Date.now() - startedAt < temporaryTunnelReadyTimeoutMs) {
+		if (record.publicUrl) return;
+		if (record.status === "exited" || record.status === "stopped") throw new HttpError(400, lastMeaningfulLog(record) ?? "cloudflared exited before creating a temporary tunnel.");
+		await delay(100);
+	}
+	await stopTemporaryCloudflaredTunnel(record.id);
+	throw new HttpError(504, "Timed out waiting for cloudflared to publish the temporary tunnel URL.");
+}
+async function runCloudflared(args, timeout) {
+	try {
+		return await execFileAsync$1("cloudflared", args, {
+			maxBuffer: 2 * 1024 * 1024,
+			timeout
+		});
+	} catch (error) {
+		throw new HttpError(400, cleanCommandError(error, "cloudflared command failed."));
+	}
+}
+function listTemporaryTunnels() {
+	return Array.from(temporaryTunnels.values()).map(serializeTemporaryTunnel).sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt));
+}
+function serializeTemporaryTunnel(record) {
+	return {
+		createdAt: record.createdAt,
+		exitCode: record.exitCode,
+		id: record.id,
+		logs: record.logs.slice(-12),
+		originUrl: record.originUrl,
+		publicUrl: record.publicUrl,
+		signal: record.signal,
+		status: record.status,
+		stoppedAt: record.stoppedAt
+	};
+}
+function appendLog(record, text) {
+	const lines = text.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+	record.logs.push(...lines);
+	if (record.logs.length > maxLogLines) record.logs.splice(0, record.logs.length - maxLogLines);
+}
+function lastMeaningfulLog(record) {
+	return record.logs.slice().reverse().find((line) => line.trim()) ?? null;
+}
+function normalizeOriginUrl(value) {
+	let parsed;
+	try {
+		parsed = new URL(value.trim());
+	} catch {
+		throw new HttpError(400, "url must be a valid http or https URL.");
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new HttpError(400, "url must use http or https.");
+	if (!parsed.hostname) throw new HttpError(400, "url must include a host.");
+	return parsed.toString();
+}
+function normalizeTunnelIdentifier(value) {
+	const identifier = value.trim();
+	if (!identifier) throw new HttpError(400, "Tunnel id is required.");
+	if (identifier.length > 200 || /[\r\n]/u.test(identifier)) throw new HttpError(400, "Tunnel id is invalid.");
+	return identifier;
+}
+function parseCloudflaredVersion(output) {
+	return output.trim().replace(/^cloudflared\s+version\s+/iu, "") || "cloudflared";
+}
+function readRecordString(record, key) {
+	const value = record[key];
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function cleanCommandError(error, fallback) {
+	if ((error && typeof error === "object" ? error : {}).code === "ENOENT") return "cloudflared is not installed or not available on PATH.";
+	return formatCommandMessage(commandErrorText(error).replace(/^Command failed: cloudflared[^\n]*\n?/iu, "").trim()) || fallback;
+}
+function isMissingOriginCertError(error) {
+	const text = commandErrorText(error).toLowerCase();
+	return text.includes("origin certificate") || text.includes("origincert") || text.includes("tunnel_origin_cert");
+}
+function commandErrorText(error) {
+	const record = error && typeof error === "object" ? error : {};
+	const stderr = typeof record.stderr === "string" ? record.stderr : "";
+	const stdout = typeof record.stdout === "string" ? record.stdout : "";
+	const message = error instanceof Error ? error.message : "";
+	return stderr || stdout || message;
+}
+function formatCommandMessage(text) {
+	const messages = text.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).map((line) => {
+		try {
+			const parsed = JSON.parse(line);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+				const message = parsed.message;
+				if (typeof message === "string" && message.trim()) return message.trim();
+			}
+		} catch {
+			return line;
+		}
+		return line;
+	});
+	return messages.filter((line, index) => messages.indexOf(line) === index).join("\n");
+}
+function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//#endregion
+//#region app/server/git.service.ts
+var execFileAsync = promisify(execFile);
+var workspaceRoot = realpathSync(homedir());
+async function readGitStatus(inputPath) {
+	const cwd = await resolveWorkspacePath(inputPath);
+	if (!await isGitRepository(cwd)) return {
+		ahead: 0,
+		behind: 0,
+		branch: "No repository",
+		changes: [],
+		commits: [],
+		isRepository: false,
+		message: "This workspace is not initialized as a Git repository."
+	};
+	const status = await runGit(cwd, [
+		"status",
+		"--short",
+		"--branch"
+	]);
+	const commits = await readGitLog(cwd);
+	return {
+		...parseGitStatus(status.stdout),
+		commits,
+		isRepository: true
+	};
+}
+async function initGitRepository(inputPath) {
+	const cwd = await resolveWorkspacePath(inputPath);
+	await runGit(cwd, ["init"]);
+	return readGitStatus(cwd);
+}
+async function stageGitPaths(inputPath, paths) {
+	const cwd = await resolveWorkspacePath(inputPath);
+	await ensureGitRepository(cwd);
+	await runGit(cwd, [
+		"add",
+		"--",
+		...paths.length ? paths : ["."]
+	]);
+	return readGitStatus(cwd);
+}
+async function unstageGitPaths(inputPath, paths) {
+	const cwd = await resolveWorkspacePath(inputPath);
+	await ensureGitRepository(cwd);
+	await runGit(cwd, [
+		"restore",
+		"--staged",
+		"--",
+		...paths.length ? paths : ["."]
+	]);
+	return readGitStatus(cwd);
+}
+async function discardGitPaths(inputPath, paths) {
+	const cwd = await resolveWorkspacePath(inputPath);
+	await ensureGitRepository(cwd);
+	const targets = paths.length ? paths : ["."];
+	await runGit(cwd, [
+		"restore",
+		"--staged",
+		"--worktree",
+		"--",
+		...targets
+	]).catch(() => void 0);
+	await runGit(cwd, [
+		"clean",
+		"-f",
+		"--",
+		...targets
+	]).catch(() => void 0);
+	return readGitStatus(cwd);
+}
+async function commitGitChanges(inputPath, message) {
+	const cwd = await resolveWorkspacePath(inputPath);
+	await ensureGitRepository(cwd);
+	if (!message.trim()) throw new HttpError(400, "Commit message is required.");
+	await runGit(cwd, [
+		"commit",
+		"-m",
+		message.trim()
+	]);
+	return readGitStatus(cwd);
+}
+async function pullGitRepository(inputPath) {
+	const cwd = await resolveWorkspacePath(inputPath);
+	await ensureGitRepository(cwd);
+	await runGit(cwd, ["pull", "--ff-only"]);
+	return readGitStatus(cwd);
+}
+async function pushGitRepository(inputPath) {
+	const cwd = await resolveWorkspacePath(inputPath);
+	await ensureGitRepository(cwd);
+	await runGit(cwd, ["push"]);
+	return readGitStatus(cwd);
+}
+async function ensureGitRepository(cwd) {
+	if (!await isGitRepository(cwd)) throw new HttpError(400, "This workspace is not initialized as a Git repository.");
+}
+async function isGitRepository(cwd) {
+	try {
+		return (await runGit(cwd, ["rev-parse", "--is-inside-work-tree"])).stdout.trim() === "true";
+	} catch {
+		return false;
+	}
+}
+function parseGitStatus(output) {
+	const lines = output.split(/\r?\n/).filter(Boolean);
+	return {
+		...parseBranchLine(lines[0]?.startsWith("## ") ? lines.shift() ?? "" : ""),
+		changes: lines.map(parseStatusLine).filter((change) => Boolean(change))
+	};
+}
+function parseBranchLine(line) {
+	const [left, tracking = ""] = line.replace(/^##\s+/, "").split("...");
+	const branch = left || "HEAD";
+	const upstream = tracking.replace(/\s+\[.*\]$/, "") || void 0;
+	return {
+		ahead: Number.parseInt(tracking.match(/ahead (\d+)/)?.[1] ?? "0", 10),
+		behind: Number.parseInt(tracking.match(/behind (\d+)/)?.[1] ?? "0", 10),
+		branch,
+		upstream
+	};
+}
+function parseStatusLine(line) {
+	const indexStatus = line[0] ?? " ";
+	const workingTreeStatus = line[1] ?? " ";
+	const rawPath = line.slice(3);
+	if (!rawPath) return null;
+	const [originalPath, pathName] = rawPath.includes(" -> ") ? rawPath.split(" -> ", 2) : [void 0, rawPath];
+	return {
+		indexStatus,
+		originalPath,
+		path: pathName,
+		staged: indexStatus !== " " && indexStatus !== "?",
+		status: statusFromCode(indexStatus !== " " && indexStatus !== "?" ? indexStatus : workingTreeStatus),
+		workingTreeStatus
+	};
+}
+function statusFromCode(code) {
+	if (code === "?") return "untracked";
+	if (code === "A") return "added";
+	if (code === "D") return "deleted";
+	if (code === "R") return "renamed";
+	return "modified";
+}
+async function readGitLog(cwd) {
+	try {
+		return (await runGit(cwd, [
+			"log",
+			"--date-order",
+			"--decorate=short",
+			"--pretty=format:%h%x09%D%x09%s%x09%an",
+			"-n",
+			"16"
+		])).stdout.split(/\r?\n/).filter(Boolean).map((line) => {
+			const [hash = "", refs = "", subject = "", author = ""] = line.split("	");
+			return {
+				author,
+				hash,
+				refs,
+				subject
+			};
+		});
+	} catch {
+		return [];
+	}
+}
+async function runGit(cwd, args) {
+	try {
+		return await execFileAsync("git", args, {
+			cwd,
+			maxBuffer: 1024 * 1024,
+			timeout: 12e4
+		});
+	} catch (error) {
+		throw new HttpError(400, (error instanceof Error ? error.message : "Git command failed.").replace(/^Command failed: git [^\n]+\n?/, "").trim() || "Git command failed.");
+	}
+}
+async function resolveWorkspacePath(inputPath) {
+	const requested = inputPath?.trim();
+	if (!requested) throw new HttpError(400, "path is required.");
+	const resolvedPath = await resolveRealPath(resolveUserPath(requested));
+	if (!isPathWithinWorkspaceRoot(resolvedPath)) throw new HttpError(403, "Path is outside the file browser home.");
+	if (!(await stat(resolvedPath)).isDirectory()) throw new HttpError(400, "Path is not a directory.");
+	return resolvedPath;
+}
+async function resolveRealPath(inputPath) {
+	try {
+		return await realpath(path.resolve(inputPath));
+	} catch {
+		throw new HttpError(400, "Directory path does not exist.");
+	}
+}
+function resolveUserPath(inputPath) {
+	if (inputPath === "~") return workspaceRoot;
+	if (inputPath.startsWith("~/")) return path.join(workspaceRoot, inputPath.slice(2));
+	if (path.isAbsolute(inputPath)) return inputPath;
+	return path.join(workspaceRoot, inputPath);
+}
+function isPathWithinWorkspaceRoot(inputPath) {
+	const relativePath = path.relative(workspaceRoot, inputPath);
+	return relativePath === "" || !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+}
+//#endregion
+//#region app/server/mcp.service.ts
+var codexProviderId = "codex";
+var serverNamePattern = /^[A-Za-z0-9_-]+$/;
+var maxStatusErrorLength = 2e3;
+async function listMcpServers() {
+	await ensureDatabase();
+	return (await prisma.mcpServer.findMany({
+		include: { installations: true },
+		orderBy: { name: "asc" }
+	})).map(serializeMcpServer);
+}
+async function getMcpServer(serverId) {
+	return serializeMcpServer(await getMcpServerRecord(serverId));
+}
+async function createMcpServer(dto) {
+	await ensureDatabase();
+	const draft = readMcpServerDraft(dto, { requireTransport: true });
+	const name = draft.name;
+	const transport = draft.transport;
+	if (!name) throw new HttpError(400, "name is required.");
+	if (!transport) throw new HttpError(400, "transport is required.");
+	const created = await prisma.mcpServer.create({
+		data: {
+			adapterSettings: draft.adapterSettings,
+			config: draft.config ?? {},
+			displayName: draft.displayName ?? null,
+			enabled: draft.enabled,
+			name,
+			required: draft.required,
+			startupTimeoutSec: draft.startupTimeoutSec,
+			toolPolicy: draft.toolPolicy,
+			toolTimeoutSec: draft.toolTimeoutSec,
+			transport
+		},
+		include: { installations: true }
+	}).catch((error) => {
+		if (isUniqueConstraintError(error)) throw new HttpError(409, "An MCP server with this name already exists.");
+		throw error;
+	});
+	await replaceMcpServerInstallations(created.id, dto.accountIds);
+	return getMcpServer(created.id);
+}
+async function updateMcpServer(serverId, dto) {
+	await ensureDatabase();
+	await getMcpServerRecord(serverId);
+	const draft = readMcpServerDraft(dto, { requireTransport: false });
+	await prisma.mcpServer.update({
+		where: { id: serverId },
+		data: {
+			adapterSettings: draft.adapterSettings === void 0 ? void 0 : draft.adapterSettings,
+			config: draft.config === void 0 ? void 0 : draft.config,
+			displayName: draft.displayName,
+			enabled: draft.enabled,
+			name: draft.name,
+			required: draft.required,
+			startupTimeoutSec: draft.startupTimeoutSec,
+			toolPolicy: draft.toolPolicy === void 0 ? void 0 : draft.toolPolicy,
+			toolTimeoutSec: draft.toolTimeoutSec,
+			transport: draft.transport
+		}
+	}).catch((error) => {
+		if (isUniqueConstraintError(error)) throw new HttpError(409, "An MCP server with this name already exists.");
+		throw error;
+	});
+	await replaceMcpServerInstallations(serverId, dto.accountIds);
+	return getMcpServer(serverId);
+}
+async function deleteMcpServer(serverId) {
+	await ensureDatabase();
+	const server = await getMcpServerRecord(serverId);
+	const accountIds = server.installations.map((installation) => installation.accountId);
+	const response = serializeMcpServer(server);
+	await prisma.mcpServer.delete({ where: { id: serverId } });
+	await Promise.allSettled([...new Set(accountIds)].map((accountId) => syncCodexAccountMcpConfig(accountId)));
+	return response;
+}
+async function syncMcpServer(serverId, dto = {}) {
+	await ensureDatabase();
+	const previousAccountIds = (await getMcpServerRecord(serverId)).installations.map((installation) => installation.accountId);
+	await replaceMcpServerInstallations(serverId, dto.accountIds);
+	const server = await getMcpServerRecord(serverId);
+	const targetAccountIds = dto.accountIds !== void 0 ? uniqueStrings([...previousAccountIds, ...dto.accountIds]) : uniqueStrings(server.installations.map((installation) => installation.accountId));
+	const failed = (await Promise.all(targetAccountIds.map((accountId) => syncCodexAccountMcpConfig(accountId)))).find((result) => result.error);
+	if (failed) throw new HttpError(502, failed.error ?? "Unable to sync MCP server.");
+	return getMcpServer(serverId);
+}
+async function listMcpServerStatuses(accountId) {
+	await ensureDatabase();
+	const account = await getCodexAccount(accountId);
+	const installations = await prisma.mcpServerInstallation.findMany({
+		include: { server: true },
+		orderBy: { server: { name: "asc" } },
+		where: {
+			accountId,
+			providerId: codexProviderId
+		}
+	});
+	let rawStatuses = [];
+	try {
+		rawStatuses = await listCodexMcpServerStatuses(account);
+	} catch (error) {
+		const message = errorMessage(error);
+		return {
+			accountId,
+			data: installations.map((installation) => statusItemFromInstallation(installation, message))
+		};
+	}
+	const statusByName = /* @__PURE__ */ new Map();
+	for (const rawStatus of rawStatuses) {
+		const name = readString(asJsonObject(rawStatus)?.name);
+		if (name) statusByName.set(name, rawStatus);
+	}
+	const items = installations.map((installation) => {
+		const rawStatus = statusByName.get(installation.server.name);
+		return rawStatus ? statusItemFromRaw(accountId, installation.server.id, rawStatus, installation.lastError) : statusItemFromInstallation(installation, installation.lastError);
+	});
+	for (const rawStatus of rawStatuses) {
+		const name = readString(asJsonObject(rawStatus)?.name);
+		if (name && !installations.some((installation) => installation.server.name === name)) items.push(statusItemFromRaw(accountId, null, rawStatus, null));
+	}
+	return {
+		accountId,
+		data: items
+	};
+}
+async function startMcpServerOauthLogin(serverId, dto) {
+	await ensureDatabase();
+	const server = await getMcpServerRecord(serverId);
+	const transport = serializeMcpTransport(server);
+	if (transport.type !== "streamable_http") throw new HttpError(400, "OAuth login is only available for HTTP MCP servers.");
+	const account = await getCodexAccount(dto.accountId);
+	if (!await prisma.mcpServerInstallation.findFirst({ where: {
+		accountId: account.id,
+		providerId: codexProviderId,
+		serverId
+	} })) throw new HttpError(400, "Install this MCP server to the selected account before starting OAuth login.");
+	const sync = await syncCodexAccountMcpConfig(account.id);
+	if (sync.error) throw new HttpError(502, sync.error);
+	const scopes = dto.scopes?.length ? dto.scopes : transport.scopes;
+	return startCodexMcpOauthLogin(account, server.name, scopes);
+}
+async function getMcpServerRecord(serverId) {
+	await ensureDatabase();
+	const server = await prisma.mcpServer.findUnique({
+		include: { installations: true },
+		where: { id: serverId }
+	});
+	if (!server) throw new HttpError(404, "MCP server not found.");
+	return server;
+}
+async function getCodexAccount(accountId) {
+	const account = await prisma.providerAccount.findUnique({ where: { id: accountId } });
+	if (!account) throw new HttpError(404, "Provider account not found.");
+	if (account.providerId !== codexProviderId) throw new HttpError(400, "MCP sync currently supports Codex accounts only.");
+	return account;
+}
+async function replaceMcpServerInstallations(serverId, accountIds) {
+	if (accountIds === void 0) return;
+	const uniqueAccountIds = uniqueStrings(accountIds);
+	if (!uniqueAccountIds.length) {
+		await prisma.mcpServerInstallation.deleteMany({ where: {
+			providerId: codexProviderId,
+			serverId
+		} });
+		return;
+	}
+	const accounts = await prisma.providerAccount.findMany({ where: {
+		id: { in: uniqueAccountIds },
+		providerId: codexProviderId
+	} });
+	const foundIds = new Set(accounts.map((account) => account.id));
+	const missing = uniqueAccountIds.find((accountId) => !foundIds.has(accountId));
+	if (missing) throw new HttpError(400, `Codex account ${missing} was not found.`);
+	await prisma.mcpServerInstallation.deleteMany({ where: {
+		accountId: { notIn: uniqueAccountIds },
+		providerId: codexProviderId,
+		serverId
+	} });
+	await Promise.all(uniqueAccountIds.map((accountId) => prisma.mcpServerInstallation.upsert({
+		create: {
+			accountId,
+			providerId: codexProviderId,
+			serverId
+		},
+		update: { enabled: true },
+		where: { serverId_providerId_accountId: {
+			accountId,
+			providerId: codexProviderId,
+			serverId
+		} }
+	})));
+}
+async function syncCodexAccountMcpConfig(accountId) {
+	const account = await getCodexAccount(accountId);
+	const installations = await prisma.mcpServerInstallation.findMany({
+		include: { server: true },
+		orderBy: { server: { name: "asc" } },
+		where: {
+			accountId,
+			providerId: codexProviderId
+		}
+	});
+	const startedAt = /* @__PURE__ */ new Date();
+	try {
+		await writeCodexMcpConfig(account, installations);
+	} catch (error) {
+		const message = errorMessage(error);
+		await markInstallationsSynced(accountId, startedAt, "ERROR", message);
+		return {
+			accountId,
+			error: message,
+			status: "ERROR"
+		};
+	}
+	try {
+		await reloadCodexMcpServerConfig(account);
+	} catch (error) {
+		const message = errorMessage(error);
+		await markInstallationsSynced(accountId, startedAt, "ERROR", message);
+		return {
+			accountId,
+			error: message,
+			status: "ERROR"
+		};
+	}
+	await markInstallationsSynced(accountId, startedAt, "SYNCED", null);
+	return {
+		accountId,
+		error: null,
+		status: "SYNCED"
+	};
+}
+async function markInstallationsSynced(accountId, syncedAt, status, error) {
+	await prisma.mcpServerInstallation.updateMany({
+		data: {
+			lastError: error ? truncateError(error) : null,
+			lastStatus: status,
+			lastSyncAt: syncedAt
+		},
+		where: {
+			accountId,
+			providerId: codexProviderId
+		}
+	});
+}
+async function writeCodexMcpConfig(account, installations) {
+	const codexHome = resolveCodexAccountHome(account);
+	await mkdir(codexHome, {
+		mode: 448,
+		recursive: true
+	});
+	const configPath = join(codexHome, "config.toml");
+	const currentConfig = await readCodexTomlConfig(configPath);
+	const mcpServers = {};
+	for (const installation of installations) mcpServers[installation.server.name] = codexConfigForServer(installation.server, installation);
+	if (Object.keys(mcpServers).length) currentConfig.mcp_servers = mcpServers;
+	else delete currentConfig.mcp_servers;
+	await writeFile(configPath, stringify(currentConfig), "utf8");
+}
+async function readCodexTomlConfig(configPath) {
+	const source = await readFile(configPath, "utf8").catch((error) => {
+		if (error.code === "ENOENT") return "";
+		throw error;
+	});
+	if (!source.trim()) return {};
+	const parsed = parse(source);
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Codex config.toml must contain a TOML table.");
+	return parsed;
+}
+function codexConfigForServer(server, installation) {
+	const transport = serializeMcpTransport(server);
+	const toolPolicy = serializeToolPolicy(server.toolPolicy);
+	const entry = {
+		enabled: server.enabled && installation.enabled,
+		required: server.required
+	};
+	if (transport.type === "stdio") {
+		entry.command = transport.command;
+		if (transport.args.length) entry.args = transport.args;
+		if (Object.keys(transport.env).length) entry.env = transport.env;
+		if (transport.envVars.length) entry.env_vars = transport.envVars.map(envVarName);
+		if (transport.cwd) entry.cwd = transport.cwd;
+	} else {
+		entry.url = transport.url;
+		if (transport.bearerTokenEnvVar) entry.bearer_token_env_var = transport.bearerTokenEnvVar;
+		if (Object.keys(transport.httpHeaders).length) entry.http_headers = transport.httpHeaders;
+		if (Object.keys(transport.envHttpHeaders).length) entry.env_http_headers = transport.envHttpHeaders;
+		if (transport.oauthClientId) entry.oauth = { client_id: transport.oauthClientId };
+		if (transport.oauthResource) entry.oauth_resource = transport.oauthResource;
+		if (transport.scopes.length) entry.scopes = transport.scopes;
+	}
+	if (server.startupTimeoutSec !== null) entry.startup_timeout_sec = server.startupTimeoutSec;
+	if (server.toolTimeoutSec !== null) entry.tool_timeout_sec = server.toolTimeoutSec;
+	if (toolPolicy.defaultToolsApprovalMode) entry.default_tools_approval_mode = toolPolicy.defaultToolsApprovalMode;
+	if (toolPolicy.enabledTools?.length) entry.enabled_tools = toolPolicy.enabledTools;
+	if (toolPolicy.disabledTools?.length) entry.disabled_tools = toolPolicy.disabledTools;
+	if (toolPolicy.tools && Object.keys(toolPolicy.tools).length) {
+		const tools = {};
+		for (const [toolName, override] of Object.entries(toolPolicy.tools)) tools[toolName] = override.approvalMode ? { approval_mode: override.approvalMode } : {};
+		entry.tools = tools;
+	}
+	return entry;
+}
+function readMcpServerDraft(dto, options) {
+	const transport = readTransportConfig(dto.transport, options.requireTransport);
+	const split = transport ? splitTransportConfig(transport) : null;
+	return {
+		adapterSettings: dto.adapterSettings === void 0 ? void 0 : readJsonObject(dto.adapterSettings, "adapterSettings"),
+		config: split?.config,
+		displayName: dto.displayName === void 0 ? void 0 : readOptionalString(dto.displayName, "displayName", 160),
+		enabled: dto.enabled === void 0 ? void 0 : readBooleanValue(dto.enabled, "enabled"),
+		name: dto.name === void 0 ? void 0 : readMcpServerName(dto.name),
+		required: dto.required === void 0 ? void 0 : readBooleanValue(dto.required, "required"),
+		startupTimeoutSec: dto.startupTimeoutSec === void 0 ? void 0 : readOptionalPositiveNumber(dto.startupTimeoutSec, "startupTimeoutSec"),
+		toolPolicy: dto.toolPolicy === void 0 ? void 0 : readToolPolicy(dto.toolPolicy),
+		toolTimeoutSec: dto.toolTimeoutSec === void 0 ? void 0 : readOptionalPositiveNumber(dto.toolTimeoutSec, "toolTimeoutSec"),
+		transport: split?.transport
+	};
+}
+function readTransportConfig(value, required) {
+	if (value === void 0) {
+		if (required) throw new HttpError(400, "transport is required.");
+		return;
+	}
+	const record = readObject(value, "transport");
+	const rawType = readString(record.type);
+	const type = rawType === "http" ? "streamable_http" : rawType;
+	if (type === "stdio") return {
+		args: readStringArray(record.args, "transport.args"),
+		command: readRequiredString(record.command, "transport.command", 500),
+		cwd: readOptionalString(record.cwd, "transport.cwd", 1e3),
+		env: readStringRecord(record.env, "transport.env"),
+		envVars: readEnvVarRefs(record.envVars ?? record.env_vars),
+		type
+	};
+	if (type === "streamable_http") return {
+		bearerTokenEnvVar: readOptionalString(record.bearerTokenEnvVar ?? record.bearer_token_env_var, "transport.bearerTokenEnvVar", 200),
+		envHttpHeaders: readStringRecord(record.envHttpHeaders ?? record.env_http_headers, "transport.envHttpHeaders"),
+		httpHeaders: readStringRecord(record.httpHeaders ?? record.http_headers, "transport.httpHeaders"),
+		oauthClientId: readOptionalString(record.oauthClientId ?? asJsonObject(record.oauth)?.client_id, "transport.oauthClientId", 500),
+		oauthResource: readOptionalString(record.oauthResource ?? record.oauth_resource, "transport.oauthResource", 1e3),
+		scopes: readStringArray(record.scopes, "transport.scopes"),
+		type,
+		url: readHttpUrl(record.url, "transport.url")
+	};
+	throw new HttpError(400, "transport.type must be stdio or streamable_http.");
+}
+function splitTransportConfig(transport) {
+	const { type, ...config } = transport;
+	return {
+		config,
+		transport: type
+	};
+}
+function serializeMcpServer(server) {
+	return {
+		adapterSettings: serializeJsonObject(server.adapterSettings),
+		createdAt: server.createdAt.toISOString(),
+		displayName: server.displayName,
+		enabled: server.enabled,
+		id: server.id,
+		installations: server.installations.map(serializeMcpInstallation),
+		name: server.name,
+		required: server.required,
+		startupTimeoutSec: server.startupTimeoutSec,
+		toolPolicy: serializeToolPolicy(server.toolPolicy),
+		toolTimeoutSec: server.toolTimeoutSec,
+		transport: serializeMcpTransport(server),
+		updatedAt: server.updatedAt.toISOString()
+	};
+}
+function serializeMcpInstallation(installation) {
+	return {
+		accountId: installation.accountId,
+		createdAt: installation.createdAt.toISOString(),
+		enabled: installation.enabled,
+		id: installation.id,
+		lastError: installation.lastError,
+		lastStatus: installation.lastStatus,
+		lastSyncAt: installation.lastSyncAt?.toISOString() ?? null,
+		providerId: installation.providerId,
+		serverId: installation.serverId,
+		updatedAt: installation.updatedAt.toISOString()
+	};
+}
+function serializeMcpTransport(server) {
+	const config = serializeJsonObject(server.config);
+	if (server.transport === "stdio") return readTransportConfig({
+		...config,
+		type: "stdio"
+	}, true);
+	return readTransportConfig({
+		...config,
+		type: "streamable_http"
+	}, true);
+}
+function readToolPolicy(value) {
+	const record = readJsonObject(value, "toolPolicy");
+	return {
+		defaultToolsApprovalMode: readApprovalMode(record.defaultToolsApprovalMode ?? record.default_tools_approval_mode, "toolPolicy.defaultToolsApprovalMode"),
+		disabledTools: record.disabledTools === void 0 && record.disabled_tools === void 0 ? void 0 : readStringArray(record.disabledTools ?? record.disabled_tools, "toolPolicy.disabledTools"),
+		enabledTools: record.enabledTools === void 0 && record.enabled_tools === void 0 ? void 0 : readStringArray(record.enabledTools ?? record.enabled_tools, "toolPolicy.enabledTools"),
+		tools: readToolOverrides(record.tools)
+	};
+}
+function serializeToolPolicy(value) {
+	return readToolPolicy(serializeJsonObject(value));
+}
+function readToolOverrides(value) {
+	if (value === void 0) return;
+	const record = readObject(value, "toolPolicy.tools");
+	const tools = {};
+	for (const [toolName, override] of Object.entries(record)) {
+		if (!toolName.trim()) throw new HttpError(400, "Tool override names cannot be empty.");
+		const overrideRecord = readObject(override, `toolPolicy.tools.${toolName}`);
+		tools[toolName] = { approvalMode: readApprovalMode(overrideRecord.approvalMode ?? overrideRecord.approval_mode, `toolPolicy.tools.${toolName}.approvalMode`) };
+	}
+	return tools;
+}
+function statusItemFromInstallation(installation, error) {
+	return {
+		accountId: installation.accountId,
+		authStatus: "unknown",
+		error: error ?? null,
+		lastError: installation.lastError,
+		name: installation.server.name,
+		resourceCount: 0,
+		resourceTemplateCount: 0,
+		serverId: installation.serverId,
+		serverInfo: null,
+		toolCount: 0,
+		tools: []
+	};
+}
+function statusItemFromRaw(accountId, serverId, rawStatus, lastError) {
+	const record = asJsonObject(rawStatus) ?? {};
+	const tools = readStatusNames(record.tools);
+	const resources = readStatusNames(record.resources);
+	const resourceTemplates = readStatusNames(record.resourceTemplates ?? record.resource_templates);
+	return {
+		accountId,
+		authStatus: readAuthStatus(record.authStatus ?? record.auth_status),
+		error: readString(record.error ?? record.startupError ?? record.startup_error) ?? null,
+		lastError: lastError ?? null,
+		name: readString(record.name) ?? "unknown",
+		raw: isJsonSerializable(rawStatus) ? rawStatus : void 0,
+		resourceCount: resources.length,
+		resourceTemplateCount: resourceTemplates.length,
+		serverId,
+		serverInfo: asJsonObject(record.serverInfo ?? record.server_info) ?? null,
+		toolCount: tools.length,
+		tools
+	};
+}
+function readStatusNames(value) {
+	if (Array.isArray(value)) return value.map((item) => typeof item === "string" ? item : readString(asJsonObject(item)?.name)).filter((name) => Boolean(name));
+	const record = asJsonObject(value);
+	return record ? Object.keys(record) : [];
+}
+function readAuthStatus(value) {
+	if (value === "unsupported" || value === "notLoggedIn" || value === "bearerToken" || value === "oAuth") return value;
+	if (value === "not_logged_in") return "notLoggedIn";
+	if (value === "bearer_token") return "bearerToken";
+	if (value === "oauth" || value === "o_auth") return "oAuth";
+	return "unknown";
+}
+function readMcpServerName(value) {
+	const name = readRequiredString(value, "name", 80);
+	if (!serverNamePattern.test(name)) throw new HttpError(400, "MCP server names can only contain letters, numbers, -, and _.");
+	return name;
+}
+function readHttpUrl(value, field) {
+	const url = readRequiredString(value, field, 2e3);
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		throw new HttpError(400, `${field} must be a valid URL.`);
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new HttpError(400, `${field} must use http or https.`);
+	return url;
+}
+function readObject(value, field) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new HttpError(400, `${field} must be an object.`);
+	return value;
+}
+function readJsonObject(value, field) {
+	return readObject(value, field);
+}
+function readRequiredString(value, field, maxLength) {
+	if (typeof value !== "string" || !value.trim()) throw new HttpError(400, `${field} is required.`);
+	const trimmed = value.trim();
+	if (trimmed.length > maxLength) throw new HttpError(400, `${field} must be ${maxLength} characters or fewer.`);
+	return trimmed;
+}
+function readOptionalString(value, field, maxLength) {
+	if (value === void 0 || value === null || value === "") return null;
+	return readRequiredString(value, field, maxLength) || null;
+}
+function readBooleanValue(value, field) {
+	const booleanValue = readBoolean(value);
+	if (booleanValue === void 0) throw new HttpError(400, `${field} must be a boolean.`);
+	return booleanValue;
+}
+function readOptionalPositiveNumber(value, field) {
+	if (value === null || value === "") return null;
+	const numberValue = readNumber(value);
+	if (numberValue === void 0 || numberValue < 0) throw new HttpError(400, `${field} must be a positive number.`);
+	return numberValue;
+}
+function readStringArray(value, field) {
+	if (value === void 0 || value === null) return [];
+	if (!Array.isArray(value)) throw new HttpError(400, `${field} must be an array.`);
+	return value.map((item, index) => readRequiredString(item, `${field}[${index}]`, 500)).filter((item, index, values) => values.indexOf(item) === index);
+}
+function readStringRecord(value, field) {
+	if (value === void 0 || value === null) return {};
+	const record = readObject(value, field);
+	return Object.fromEntries(Object.entries(record).map(([key, item]) => [readRequiredString(key, `${field} key`, 200), readRequiredString(item, `${field}.${key}`, 2e3)]));
+}
+function readEnvVarRefs(value) {
+	if (value === void 0 || value === null) return [];
+	if (!Array.isArray(value)) throw new HttpError(400, "transport.envVars must be an array.");
+	return value.map((item, index) => {
+		if (typeof item === "string") return readRequiredString(item, `transport.envVars[${index}]`, 200);
+		const record = readObject(item, `transport.envVars[${index}]`);
+		const name = readRequiredString(record.name, `transport.envVars[${index}].name`, 200);
+		const source = record.source === "local" || record.source === "remote" ? record.source : void 0;
+		return source ? {
+			name,
+			source
+		} : { name };
+	});
+}
+function envVarName(value) {
+	return typeof value === "string" ? value : value.name;
+}
+function readApprovalMode(value, field) {
+	if (value === void 0 || value === null || value === "") return null;
+	if (value === "auto" || value === "prompt" || value === "approve") return value;
+	throw new HttpError(400, `${field} must be auto, prompt, or approve.`);
+}
+function serializeJsonObject(value) {
+	return asJsonObject(value) ?? {};
+}
+function uniqueStrings(values) {
+	return values.map((value) => value.trim()).filter((value, index, next) => Boolean(value) && next.indexOf(value) === index);
+}
+function isUniqueConstraintError(error) {
+	return error instanceof Prisma.PrismaClientKnownRequestError && error.code === "P2002";
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : "Request failed.";
+}
+function truncateError(error) {
+	return error.length > maxStatusErrorLength ? `${error.slice(0, maxStatusErrorLength - 3)}...` : error;
+}
+function isJsonSerializable(value) {
+	try {
+		JSON.stringify(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region app/server/providers/types.server.ts
+function serializeProviderDefinition(definition) {
+	return definition;
+}
+//#endregion
+//#region app/server/providers.service.ts
+async function listProviders() {
+	await ensureDatabase();
+	return listProviderAdapters().map((adapter) => serializeProviderDefinition(adapter.definition));
+}
+//#endregion
+//#region app/server/plugins.service.ts
+async function listPlugins() {
+	return Promise.all(listPluginRegistrations().map((registration) => serializePlugin(registration.definition.id)));
+}
+async function updatePlugin(pluginId, dto) {
+	const registration = readKnownPlugin(pluginId);
+	const current = await readPluginSetting(pluginId, registration.definition.defaultSettings);
+	const settings = dto.settings === void 0 ? current.settings : filterSettings(dto.settings, registration.definition.settingsFields.map((field) => field.key), current.settings);
+	const secrets = dto.secrets === void 0 ? current.secrets : filterSecrets(dto.secrets, registration.definition.secretFields.map((field) => field.key), current.secrets);
+	const enabled = dto.enabled ?? current.enabled;
+	if (pluginId === "telegram" && enabled) await verifyTelegramBotToken(readSecret(secrets, "botToken"));
+	await writePluginSetting({
+		enabled,
+		pluginId,
+		secrets,
+		settings
+	});
+	await restartPlugin(pluginId);
+	return serializePlugin(pluginId);
+}
+async function runPluginAction(pluginId, action) {
+	const registration = readKnownPlugin(pluginId);
+	const handler = registration.actions?.[action];
+	if (!handler) throw new HttpError(404, "Plugin action not found.");
+	const result = await handler(createPluginContext(pluginId, await readPluginSetting(pluginId, registration.definition.defaultSettings)));
+	await restartPlugin(pluginId);
+	return {
+		message: result?.message,
+		plugin: await serializePlugin(pluginId)
+	};
+}
+async function serializePlugin(pluginId) {
+	const registration = readKnownPlugin(pluginId);
+	const setting = await readPluginSetting(pluginId, registration.definition.defaultSettings);
+	const state = await readPluginState(pluginId);
+	return {
+		description: registration.definition.description,
+		enabled: setting.enabled,
+		icon: registration.definition.icon,
+		id: registration.definition.id,
+		label: registration.definition.label,
+		secretConfigured: Object.fromEntries(registration.definition.secretFields.map((field) => [field.key, Boolean(readSecret(setting.secrets, field.key))])),
+		secrets: setting.secrets,
+		secretFields: registration.definition.secretFields,
+		settings: setting.settings,
+		settingsFields: registration.definition.settingsFields,
+		stateSummary: registration.summarizeState?.(state) ?? {},
+		status: setting.enabled ? getPluginStatus(pluginId) : {
+			state: "disabled",
+			message: null,
+			updatedAt: null
+		}
+	};
+}
+function readKnownPlugin(pluginId) {
+	try {
+		return readPluginRegistration(pluginId);
+	} catch {
+		throw new HttpError(404, "Plugin not found.");
+	}
+}
+function filterSettings(value, allowedKeys, current) {
+	const next = { ...current };
+	for (const key of allowedKeys) if (value[key] !== void 0) next[key] = value[key];
+	return next;
+}
+function filterSecrets(value, allowedKeys, current) {
+	const next = { ...current };
+	for (const key of allowedKeys) {
+		const secret = value[key];
+		if (typeof secret === "string" && secret.trim()) next[key] = secret.trim();
+		if (secret === null) delete next[key];
+	}
+	return next;
+}
+function readSecret(secrets, key) {
+	const value = secrets[key];
+	return typeof value === "string" ? value : "";
+}
+//#endregion
+//#region app/server/api.server.ts
+function installApiServer(middlewares) {
+	middlewares.use((req, res, next) => {
+		const url = new URL(req.url ?? "/", "http://localhost");
+		if (!url.pathname.startsWith("/api/")) {
+			next();
+			return;
+		}
+		handleApiRequest(req, res, url).catch((error) => {
+			sendRouteError(res, error);
+		});
+	});
+}
+async function handleApiRequest(req, res, url) {
+	const method = req.method ?? "GET";
+	if (url.pathname === "/api/providers") {
+		requireMethod(method, ["GET"]);
+		sendJson(res, await listProviders());
+		return;
+	}
+	if (url.pathname === "/api/plugins") {
+		requireMethod(method, ["GET"]);
+		sendJson(res, await listPlugins());
+		return;
+	}
+	const pluginActionMatch = url.pathname.match(/^\/api\/plugins\/([^/]+)\/actions\/([^/]+)$/);
+	if (pluginActionMatch) {
+		requireMethod(method, ["POST"]);
+		sendJson(res, await runPluginAction(decodeURIComponent(pluginActionMatch[1]), decodeURIComponent(pluginActionMatch[2])));
+		return;
+	}
+	const pluginMatch = url.pathname.match(/^\/api\/plugins\/([^/]+)$/);
+	if (pluginMatch) {
+		requireMethod(method, ["PATCH"]);
+		sendJson(res, await updatePlugin(decodeURIComponent(pluginMatch[1]), readPluginSettingsUpdateRequest(await readNodeJsonBody(req))));
+		return;
+	}
+	if (url.pathname === "/api/providers/codex/instructions") {
+		requireMethod(method, ["GET", "PUT"]);
+		if (method === "PUT") {
+			sendJson(res, await updateCodexInstructions(readCodexInstructionsRequest(await readNodeJsonBody(req)).instructions));
+			return;
+		}
+		sendJson(res, await readCodexInstructions());
+		return;
+	}
+	if (url.pathname === "/api/mcp-servers") {
+		requireMethod(method, ["GET", "POST"]);
+		if (method === "POST") {
+			sendJson(res, await createMcpServer(await readNodeJsonBody(req)), 201);
+			return;
+		}
+		sendJson(res, await listMcpServers());
+		return;
+	}
+	if (url.pathname === "/api/mcp-servers/status") {
+		requireMethod(method, ["GET"]);
+		sendJson(res, await listMcpServerStatuses(readStringField(url.searchParams.get("accountId"), "accountId", { required: true })));
+		return;
+	}
+	const mcpServerSyncMatch = url.pathname.match(/^\/api\/mcp-servers\/([^/]+)\/sync$/);
+	if (mcpServerSyncMatch) {
+		requireMethod(method, ["POST"]);
+		sendJson(res, await syncMcpServer(decodeURIComponent(mcpServerSyncMatch[1]), await readNodeJsonBody(req)));
+		return;
+	}
+	const mcpServerOauthLoginMatch = url.pathname.match(/^\/api\/mcp-servers\/([^/]+)\/oauth-login$/);
+	if (mcpServerOauthLoginMatch) {
+		requireMethod(method, ["POST"]);
+		sendJson(res, await startMcpServerOauthLogin(decodeURIComponent(mcpServerOauthLoginMatch[1]), await readNodeJsonBody(req)));
+		return;
+	}
+	const mcpServerMatch = url.pathname.match(/^\/api\/mcp-servers\/([^/]+)$/);
+	if (mcpServerMatch) {
+		const serverId = decodeURIComponent(mcpServerMatch[1]);
+		requireMethod(method, [
+			"DELETE",
+			"GET",
+			"PATCH"
+		]);
+		if (method === "DELETE") {
+			sendJson(res, await deleteMcpServer(serverId));
+			return;
+		}
+		if (method === "PATCH") {
+			sendJson(res, await updateMcpServer(serverId, await readNodeJsonBody(req)));
+			return;
+		}
+		sendJson(res, await getMcpServer(serverId));
+		return;
+	}
+	if (url.pathname === "/api/provider-accounts") {
+		requireMethod(method, ["GET", "POST"]);
+		if (method === "POST") {
+			sendJson(res, await createAccount(readCreateAccountRequest(await readNodeJsonBody(req))), 201);
+			return;
+		}
+		sendJson(res, await listAccounts());
+		return;
+	}
+	if (url.pathname === "/api/provider-accounts/limits") {
+		requireMethod(method, ["GET"]);
+		sendJson(res, await readConnectedAccountLimits());
+		return;
+	}
+	if (url.pathname === "/api/chats") {
+		requireMethod(method, ["GET", "POST"]);
+		if (method === "POST") {
+			sendJson(res, await createChat(readCreateChatRequest(await readNodeJsonBody(req))), 201);
+			return;
+		}
+		sendJson(res, await listChats(url.searchParams.get("workingDirectory")));
+		return;
+	}
+	if (url.pathname === "/api/schedules") {
+		requireMethod(method, ["GET", "POST"]);
+		if (method === "POST") {
+			sendJson(res, await createMessageSchedule(readCreateMessageScheduleRequest(await readNodeJsonBody(req))), 201);
+			return;
+		}
+		sendJson(res, await listMessageSchedules(url.searchParams.get("workingDirectory")));
+		return;
+	}
+	const scheduleRunsMatch = url.pathname.match(/^\/api\/schedules\/([^/]+)\/runs$/);
+	if (scheduleRunsMatch) {
+		requireMethod(method, ["GET"]);
+		sendJson(res, await listMessageScheduleRuns(decodeURIComponent(scheduleRunsMatch[1])));
+		return;
+	}
+	const scheduleMatch = url.pathname.match(/^\/api\/schedules\/([^/]+)$/);
+	if (scheduleMatch) {
+		const scheduleId = decodeURIComponent(scheduleMatch[1]);
+		requireMethod(method, [
+			"DELETE",
+			"GET",
+			"PATCH"
+		]);
+		if (method === "DELETE") {
+			sendJson(res, await archiveMessageSchedule(scheduleId));
+			return;
+		}
+		if (method === "PATCH") {
+			sendJson(res, await updateMessageSchedule(scheduleId, readUpdateMessageScheduleRequest(await readNodeJsonBody(req))));
+			return;
+		}
+		sendJson(res, await getMessageSchedule(scheduleId));
+		return;
+	}
+	const chatMessagesMatch = url.pathname.match(/^\/api\/chats\/([^/]+)\/messages$/);
+	if (chatMessagesMatch) {
+		const chatId = decodeURIComponent(chatMessagesMatch[1]);
+		requireMethod(method, ["GET", "POST"]);
+		if (method === "POST") {
+			sendJson(res, await executeMessage(chatId, readExecuteChatRequest(await readNodeJsonBody(req))), 202);
+			return;
+		}
+		sendJson(res, await listMessages(chatId, readIntegerParam(url.searchParams.get("limit"), 1e3)));
+		return;
+	}
+	const chatInterruptMatch = url.pathname.match(/^\/api\/chats\/([^/]+)\/interrupt$/);
+	if (chatInterruptMatch) {
+		requireMethod(method, ["POST"]);
+		sendJson(res, await interruptChatRun(decodeURIComponent(chatInterruptMatch[1])));
+		return;
+	}
+	const chatForkMatch = url.pathname.match(/^\/api\/chats\/([^/]+)\/fork$/);
+	if (chatForkMatch) {
+		requireMethod(method, ["POST"]);
+		sendJson(res, await forkChat(decodeURIComponent(chatForkMatch[1]), readForkChatRequest(await readNodeJsonBody(req))), 201);
+		return;
+	}
+	const chatCompactMatch = url.pathname.match(/^\/api\/chats\/([^/]+)\/compact$/);
+	if (chatCompactMatch) {
+		requireMethod(method, ["POST"]);
+		sendJson(res, await compactChat(decodeURIComponent(chatCompactMatch[1]), readCompactChatRequest(await readNodeJsonBody(req))));
+		return;
+	}
+	const chatReviewMatch = url.pathname.match(/^\/api\/chats\/([^/]+)\/review$/);
+	if (chatReviewMatch) {
+		requireMethod(method, ["POST"]);
+		sendJson(res, await reviewChat(decodeURIComponent(chatReviewMatch[1]), readReviewChatRequest(await readNodeJsonBody(req))));
+		return;
+	}
+	const chatRefreshMatch = url.pathname.match(/^\/api\/chats\/([^/]+)\/refresh$/);
+	if (chatRefreshMatch) {
+		requireMethod(method, ["POST"]);
+		sendJson(res, await refreshChat(decodeURIComponent(chatRefreshMatch[1])));
+		return;
+	}
+	const serverRequestMatch = url.pathname.match(/^\/api\/chats\/([^/]+)\/server-requests\/([^/]+)$/);
+	if (serverRequestMatch) {
+		requireMethod(method, ["POST"]);
+		sendJson(res, await respondToServerRequest(decodeURIComponent(serverRequestMatch[1]), decodeURIComponent(serverRequestMatch[2]), readServerRequestResponseRequest(await readNodeJsonBody(req))));
+		return;
+	}
+	const queuedRunsReorderMatch = url.pathname.match(/^\/api\/chats\/([^/]+)\/runs\/reorder$/);
+	if (queuedRunsReorderMatch) {
+		requireMethod(method, ["POST"]);
+		sendJson(res, await reorderQueuedChatRuns(decodeURIComponent(queuedRunsReorderMatch[1]), readReorderQueuedChatRunsRequest(await readNodeJsonBody(req))));
+		return;
+	}
+	const queuedRunSteerMatch = url.pathname.match(/^\/api\/chats\/([^/]+)\/runs\/([^/]+)\/steer$/);
+	if (queuedRunSteerMatch) {
+		requireMethod(method, ["POST"]);
+		sendJson(res, await steerQueuedChatRun(decodeURIComponent(queuedRunSteerMatch[1]), decodeURIComponent(queuedRunSteerMatch[2])));
+		return;
+	}
+	const queuedRunMatch = url.pathname.match(/^\/api\/chats\/([^/]+)\/runs\/([^/]+)$/);
+	if (queuedRunMatch) {
+		const chatId = decodeURIComponent(queuedRunMatch[1]);
+		const runId = decodeURIComponent(queuedRunMatch[2]);
+		requireMethod(method, ["DELETE", "PATCH"]);
+		if (method === "DELETE") {
+			sendJson(res, await deleteQueuedChatRun(chatId, runId));
+			return;
+		}
+		sendJson(res, await updateQueuedChatRun(chatId, runId, readUpdateQueuedChatRunRequest(await readNodeJsonBody(req))));
+		return;
+	}
+	const chatMatch = url.pathname.match(/^\/api\/chats\/([^/]+)$/);
+	if (chatMatch) {
+		const chatId = decodeURIComponent(chatMatch[1]);
+		requireMethod(method, ["DELETE", "PATCH"]);
+		if (method === "DELETE") {
+			sendJson(res, await archiveChat(chatId));
+			return;
+		}
+		sendJson(res, await updateChat(chatId, readUpdateChatRequest(await readNodeJsonBody(req))));
+		return;
+	}
+	const accountAuthMatch = url.pathname.match(/^\/api\/provider-accounts\/([^/]+)\/authenticate$/);
+	if (accountAuthMatch) {
+		requireMethod(method, ["POST"]);
+		const body = await readNodeJsonBody(req);
+		sendJson(res, await authenticateAccount(decodeURIComponent(accountAuthMatch[1]), readAuthMode(body.mode)));
+		return;
+	}
+	const accountModelsMatch = url.pathname.match(/^\/api\/provider-accounts\/([^/]+)\/models$/);
+	if (accountModelsMatch) {
+		requireMethod(method, ["GET"]);
+		sendJson(res, await listAccountModels(decodeURIComponent(accountModelsMatch[1])));
+		return;
+	}
+	const accountMatch = url.pathname.match(/^\/api\/provider-accounts\/([^/]+)$/);
+	if (accountMatch) {
+		requireMethod(method, ["DELETE", "PATCH"]);
+		const accountId = decodeURIComponent(accountMatch[1]);
+		if (method === "DELETE") {
+			sendJson(res, await deleteAccount(accountId));
+			return;
+		}
+		sendJson(res, await updateAccount(accountId, readUpdateAccountRequest(await readNodeJsonBody(req))));
+		return;
+	}
+	if (url.pathname === "/api/workspaces") {
+		requireMethod(method, [
+			"DELETE",
+			"GET",
+			"POST"
+		]);
+		if (method === "POST") {
+			sendJson(res, await saveWorkspaceHistory(readStringField((await readNodeJsonBody(req)).path, "path", { required: true })), 201);
+			return;
+		}
+		if (method === "DELETE") {
+			sendJson(res, await deleteWorkspaceHistory(readStringField(url.searchParams.get("path"), "path", { required: true })));
+			return;
+		}
+		sendJson(res, await listWorkspaceHistory());
+		return;
+	}
+	if (url.pathname === "/api/workspaces/directories") {
+		requireMethod(method, ["GET"]);
+		sendJson(res, await listWorkspaceDirectory(url.searchParams.get("path"), url.searchParams.get("hidden") === "1"));
+		return;
+	}
+	if (url.pathname === "/api/workspaces/tree") {
+		requireMethod(method, ["GET"]);
+		sendJson(res, await readWorkspaceTree(url.searchParams.get("path"), url.searchParams.get("hidden") === "1"));
+		return;
+	}
+	if (url.pathname === "/api/workspaces/resource") {
+		requireMethod(method, ["GET"]);
+		sendJson(res, await readWorkspaceResource(url.searchParams.get("path")));
+		return;
+	}
+	if (url.pathname === "/api/cloudflared/status") {
+		requireMethod(method, ["GET"]);
+		sendJson(res, await readCloudflaredStatus());
+		return;
+	}
+	if (url.pathname === "/api/cloudflared/temporary") {
+		requireMethod(method, ["POST"]);
+		sendJson(res, await startTemporaryCloudflaredTunnel(readStringField((await readNodeJsonBody(req)).url, "url", {
+			required: true,
+			maxLength: 2e3
+		})), 201);
+		return;
+	}
+	const cloudflaredTemporaryMatch = url.pathname.match(/^\/api\/cloudflared\/temporary\/([^/]+)$/);
+	if (cloudflaredTemporaryMatch) {
+		requireMethod(method, ["DELETE"]);
+		sendJson(res, await stopTemporaryCloudflaredTunnel(decodeURIComponent(cloudflaredTemporaryMatch[1])));
+		return;
+	}
+	const cloudflaredTunnelMatch = url.pathname.match(/^\/api\/cloudflared\/tunnels\/([^/]+)$/);
+	if (cloudflaredTunnelMatch) {
+		requireMethod(method, ["DELETE"]);
+		sendJson(res, await deleteNamedCloudflaredTunnel(decodeURIComponent(cloudflaredTunnelMatch[1])));
+		return;
+	}
+	if (url.pathname === "/api/git/status") {
+		requireMethod(method, ["GET"]);
+		sendJson(res, await readGitStatus(url.searchParams.get("path") ?? void 0));
+		return;
+	}
+	if (url.pathname === "/api/git/init") {
+		requireMethod(method, ["POST"]);
+		sendJson(res, await initGitRepository(readStringField((await readNodeJsonBody(req)).path, "path", { required: true })), 201);
+		return;
+	}
+	if (url.pathname === "/api/git/stage") {
+		requireMethod(method, ["POST"]);
+		const body = await readNodeJsonBody(req);
+		sendJson(res, await stageGitPaths(readStringField(body.path, "path", { required: true }), readStringArrayField(body.paths, "paths")));
+		return;
+	}
+	if (url.pathname === "/api/git/unstage") {
+		requireMethod(method, ["POST"]);
+		const body = await readNodeJsonBody(req);
+		sendJson(res, await unstageGitPaths(readStringField(body.path, "path", { required: true }), readStringArrayField(body.paths, "paths")));
+		return;
+	}
+	if (url.pathname === "/api/git/discard") {
+		requireMethod(method, ["POST"]);
+		const body = await readNodeJsonBody(req);
+		sendJson(res, await discardGitPaths(readStringField(body.path, "path", { required: true }), readStringArrayField(body.paths, "paths")));
+		return;
+	}
+	if (url.pathname === "/api/git/commit") {
+		requireMethod(method, ["POST"]);
+		const body = await readNodeJsonBody(req);
+		sendJson(res, await commitGitChanges(readStringField(body.path, "path", { required: true }), readStringField(body.message, "message", {
+			required: true,
+			maxLength: 500
+		})));
+		return;
+	}
+	if (url.pathname === "/api/git/pull") {
+		requireMethod(method, ["POST"]);
+		sendJson(res, await pullGitRepository(readStringField((await readNodeJsonBody(req)).path, "path", { required: true })));
+		return;
+	}
+	if (url.pathname === "/api/git/push") {
+		requireMethod(method, ["POST"]);
+		sendJson(res, await pushGitRepository(readStringField((await readNodeJsonBody(req)).path, "path", { required: true })));
+		return;
+	}
+	throw new HttpError(404, "API route not found.");
+}
+function readCreateAccountRequest(body) {
+	return {
+		displayName: readStringField(body.displayName, "displayName", { maxLength: 100 }),
+		providerId: readStringField(body.providerId, "providerId", { required: true }),
+		runtimeDefaults: readRecordField(body.runtimeDefaults, "runtimeDefaults"),
+		settings: readRecordField(body.settings, "settings")
+	};
+}
+function readPluginSettingsUpdateRequest(body) {
+	return {
+		enabled: readBooleanField(body.enabled, "enabled"),
+		secrets: readRecordField(body.secrets, "secrets"),
+		settings: readRecordField(body.settings, "settings")
+	};
+}
+function readCodexInstructionsRequest(body) {
+	if (body.instructions === void 0) return { instructions: "" };
+	if (typeof body.instructions !== "string") throw new HttpError(400, "instructions must be a string.");
+	if (body.instructions.length > 1e5) throw new HttpError(400, "instructions must be 100000 characters or fewer.");
+	return { instructions: body.instructions };
+}
+function readCreateChatRequest(body) {
+	return {
+		accountId: readStringField(body.accountId, "accountId", { required: true }),
+		autoRotateAccount: readBooleanField(body.autoRotateAccount, "autoRotateAccount"),
+		collaborationMode: readStringField(body.collaborationMode, "collaborationMode"),
+		model: readStringField(body.model, "model"),
+		permissionMode: readStringField(body.permissionMode, "permissionMode"),
+		providerId: readStringField(body.providerId, "providerId"),
+		reasoningEffort: readStringField(body.reasoningEffort, "reasoningEffort"),
+		serviceTier: readStringField(body.serviceTier, "serviceTier"),
+		title: readStringField(body.title, "title", { maxLength: 160 }),
+		workingDirectory: readStringField(body.workingDirectory, "workingDirectory", { required: true })
+	};
+}
+function readCreateMessageScheduleRequest(body) {
+	return {
+		accountId: readStringField(body.accountId, "accountId", { required: true }),
+		collaborationMode: readNullableStringField(body.collaborationMode, "collaborationMode"),
+		firstRunAt: readStringField(body.firstRunAt, "firstRunAt", { required: true }),
+		goalObjective: readNullableStringField(body.goalObjective, "goalObjective"),
+		message: readStringField(body.message, "message", {
+			required: true,
+			maxLength: 2e4
+		}),
+		model: readNullableStringField(body.model, "model"),
+		permissionMode: readNullableStringField(body.permissionMode, "permissionMode"),
+		reasoningEffort: readNullableStringField(body.reasoningEffort, "reasoningEffort"),
+		recurrence: readScheduleRecurrence(body.recurrence),
+		serviceTier: readNullableStringField(body.serviceTier, "serviceTier"),
+		status: readCreateScheduleStatus(body.status),
+		title: readStringField(body.title, "title", { maxLength: 160 }),
+		workingDirectory: readStringField(body.workingDirectory, "workingDirectory", { required: true })
+	};
+}
+function readUpdateMessageScheduleRequest(body) {
+	return {
+		accountId: readNullableStringField(body.accountId, "accountId"),
+		collaborationMode: readNullableStringField(body.collaborationMode, "collaborationMode"),
+		firstRunAt: readNullableStringField(body.firstRunAt, "firstRunAt"),
+		goalObjective: readNullableStringField(body.goalObjective, "goalObjective"),
+		message: readStringField(body.message, "message", { maxLength: 2e4 }),
+		model: readNullableStringField(body.model, "model"),
+		permissionMode: readNullableStringField(body.permissionMode, "permissionMode"),
+		reasoningEffort: readNullableStringField(body.reasoningEffort, "reasoningEffort"),
+		recurrence: readScheduleRecurrence(body.recurrence),
+		serviceTier: readNullableStringField(body.serviceTier, "serviceTier"),
+		status: readScheduleStatus(body.status),
+		title: readStringField(body.title, "title", { maxLength: 160 })
+	};
+}
+function readUpdateChatRequest(body) {
+	return {
+		accountId: readNullableStringField(body.accountId, "accountId"),
+		autoRotateAccount: readBooleanField(body.autoRotateAccount, "autoRotateAccount"),
+		collaborationMode: readNullableStringField(body.collaborationMode, "collaborationMode"),
+		model: readNullableStringField(body.model, "model"),
+		permissionMode: readNullableStringField(body.permissionMode, "permissionMode"),
+		reasoningEffort: readNullableStringField(body.reasoningEffort, "reasoningEffort"),
+		serviceTier: readNullableStringField(body.serviceTier, "serviceTier"),
+		title: readStringField(body.title, "title", { maxLength: 160 }),
+		workingDirectory: readStringField(body.workingDirectory, "workingDirectory")
+	};
+}
+function readForkChatRequest(body) {
+	return { lastTurnId: readNullableStringField(body.lastTurnId, "lastTurnId") };
+}
+function readCompactChatRequest(_body) {
+	return {};
+}
+function readReviewChatRequest(body) {
+	const target = body.target;
+	if (target !== void 0 && target !== null && target !== "uncommittedChanges" && target !== "baseBranch" && target !== "commit" && target !== "custom") throw new HttpError(400, "target must be uncommittedChanges, baseBranch, commit, or custom.");
+	const delivery = body.delivery;
+	if (delivery !== void 0 && delivery !== null && delivery !== "inline" && delivery !== "detached") throw new HttpError(400, "delivery must be inline or detached.");
+	return {
+		baseBranch: readNullableStringField(body.baseBranch, "baseBranch"),
+		commitSha: readNullableStringField(body.commitSha, "commitSha"),
+		commitTitle: readNullableStringField(body.commitTitle, "commitTitle"),
+		delivery,
+		instructions: readNullableStringField(body.instructions, "instructions"),
+		target
+	};
+}
+function readExecuteChatRequest(body) {
+	return {
+		accountId: readStringField(body.accountId, "accountId"),
+		attachments: readChatAttachments(body.attachments),
+		collaborationMode: readNullableStringField(body.collaborationMode, "collaborationMode"),
+		content: readStringField(body.content, "content", { required: true }),
+		delivery: body.delivery === "queue" || body.delivery === "steer" ? body.delivery : void 0,
+		goalObjective: readNullableStringField(body.goalObjective, "goalObjective"),
+		metadata: readRecordField(body.metadata, "metadata"),
+		permissionMode: readNullableStringField(body.permissionMode, "permissionMode")
+	};
+}
+function readUpdateQueuedChatRunRequest(body) {
+	return { content: readStringField(body.content, "content", { required: true }) };
+}
+function readReorderQueuedChatRunsRequest(body) {
+	if (!Array.isArray(body.runIds)) throw new HttpError(400, "runIds must be an array.");
+	return { runIds: body.runIds.map((runId) => readStringField(runId, "runIds[]", { required: true })).filter((runId, index, runIds) => runIds.indexOf(runId) === index) };
+}
+function readServerRequestResponseRequest(body) {
+	const kind = body.kind;
+	if (kind !== "approval" && kind !== "permissions" && kind !== "userInput") throw new HttpError(400, "kind must be approval, permissions, or userInput.");
+	return {
+		decision: body.decision,
+		kind,
+		result: body.result
+	};
+}
+function readChatAttachments(value) {
+	if (value === void 0) return;
+	if (!Array.isArray(value)) throw new HttpError(400, "attachments must be an array.");
+	return value.slice(0, 20).map((item, index) => {
+		if (!item || typeof item !== "object" || Array.isArray(item)) throw new HttpError(400, `attachments[${index}] must be an object.`);
+		const record = item;
+		const kind = record.kind;
+		if (kind !== "file" && kind !== "folder" && kind !== "image") throw new HttpError(400, `attachments[${index}].kind is invalid.`);
+		const size = record.size;
+		return {
+			dataUrl: readStringField(record.dataUrl, `attachments[${index}].dataUrl`),
+			kind,
+			mimeType: readStringField(record.mimeType, `attachments[${index}].mimeType`),
+			name: readStringField(record.name, `attachments[${index}].name`, {
+				required: true,
+				maxLength: 240
+			}),
+			path: readStringField(record.path, `attachments[${index}].path`, { maxLength: 1e3 }),
+			size: typeof size === "number" && Number.isFinite(size) ? size : void 0
+		};
+	});
+}
+function readUpdateAccountRequest(body) {
+	return {
+		displayName: readStringField(body.displayName, "displayName", { maxLength: 100 }),
+		runtimeDefaults: readRecordField(body.runtimeDefaults, "runtimeDefaults"),
+		settings: readRecordField(body.settings, "settings")
+	};
+}
+function readScheduleRecurrence(value) {
+	if (value === void 0) return;
+	const record = readRecordField(value, "recurrence") ?? {};
+	const frequency = record.frequency;
+	if (frequency !== void 0 && frequency !== "none" && frequency !== "daily" && frequency !== "weekly" && frequency !== "monthly") throw new HttpError(400, "recurrence.frequency must be none, daily, weekly, or monthly.");
+	return {
+		anchorDay: readOptionalNumber(record.anchorDay, "recurrence.anchorDay") ?? void 0,
+		endAt: readNullableStringField(record.endAt, "recurrence.endAt"),
+		frequency,
+		interval: readOptionalNumber(record.interval, "recurrence.interval") ?? void 0,
+		maxRuns: readOptionalNumber(record.maxRuns, "recurrence.maxRuns")
+	};
+}
+function readCreateScheduleStatus(value) {
+	if (value === void 0) return;
+	if (value === "ACTIVE" || value === "PAUSED") return value;
+	throw new HttpError(400, "status must be ACTIVE or PAUSED.");
+}
+function readScheduleStatus(value) {
+	if (value === void 0) return;
+	if (value === "ACTIVE" || value === "PAUSED" || value === "COMPLETED" || value === "ARCHIVED") return value;
+	throw new HttpError(400, "status must be ACTIVE, PAUSED, COMPLETED, or ARCHIVED.");
+}
+function readOptionalNumber(value, field) {
+	if (value === void 0) return;
+	if (value === null || value === "") return null;
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new HttpError(400, `${field} must be a number.`);
+	return value;
+}
+function readNullableStringField(value, field) {
+	if (value === null) return null;
+	return readStringField(value, field);
+}
+function readStringArrayField(value, field) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) throw new HttpError(400, `${field} must be an array.`);
+	return value.map((item, index) => readStringField(item, `${field}[${index}]`, { required: true }));
+}
+function readAuthMode(value) {
+	if (value === void 0 || value === null) return "browser";
+	if (value === "browser" || value === "device" || value === "local") return value;
+	throw new HttpError(400, "mode must be browser, device, or local.");
+}
+function readIntegerParam(value, fallback) {
+	if (!value) return fallback;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) ? parsed : fallback;
+}
+async function readNodeJsonBody(req) {
+	const chunks = [];
+	for await (const chunk of req) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	const text = Buffer.concat(chunks).toString("utf8");
+	if (!text.trim()) return {};
+	try {
+		const value = JSON.parse(text);
+		if (!value || typeof value !== "object" || Array.isArray(value)) throw new HttpError(400, "JSON body must be an object.");
+		return value;
+	} catch (error) {
+		if (error instanceof HttpError) throw error;
+		throw new HttpError(400, "Request body must be valid JSON.");
+	}
+}
+function requireMethod(method, allowed) {
+	if (!allowed.includes(method)) throw new HttpError(405, `${method} is not supported for this route.`);
+}
+function sendJson(res, data, status = 200) {
+	res.statusCode = status;
+	res.setHeader("Content-Type", "application/json");
+	res.end(JSON.stringify(data));
+}
+function sendRouteError(res, error) {
+	if (error instanceof HttpError) {
+		sendJson(res, { error: error.message }, error.status);
+		return;
+	}
+	sendJson(res, { error: error instanceof Error ? error.message : "Request failed." }, 500);
+}
+//#endregion
+export { handleApiRequest, installApiServer, sendRouteError };