kizlo 0.28.0 → 0.30.0

package/dist/cli/wp/export.js

@@ -0,0 +1,355 @@
+import { createStack, docker, dockerHint, dockerStatus, runningProjectContainers } from "./docker.js";
+import { ensureGitignored } from "../utils.js";
+import { ownerStatus } from "../process-owner.js";
+import { acquire, operationLock, releaseOwned } from "../daemon/lock.js";
+import { projectSession } from "./session.js";
+import { resolveDevConfig, usesLocalWordPress } from "../daemon/config.js";
+import { devStack } from "./stack.js";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { chmodSync, existsSync, linkSync, mkdirSync, mkdtempSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { setTimeout } from "node:timers/promises";
+
+//#region src/cli/wp/export.ts
+const ARCHIVE_SCRIPT = fileURLToPath(new URL("./compose/export.php", import.meta.url));
+const COMMAND_TIMEOUT = 15 * 6e4;
+function checked(result, action) {
+	if (result.code !== 0) throw new Error(`${action} failed: ${result.stderr || result.stdout || "command interrupted or timed out"}`);
+	return result.stdout.trim();
+}
+async function endDevSession(project, file, session = projectSession(project)) {
+	if (!session) return;
+	if (!("token" in session) || !session.token || session.operationFile !== file) {
+		if (await ownerStatus(session) === "dead") return;
+		throw new Error("This dev session predates export coordination. Stop it and restart `kizlo dev` with the updated CLI before exporting.");
+	}
+	if (session.pid === process.pid) throw new Error("Cannot export from inside the foreground dev owner. Run `kizlo dev --export` in another terminal.");
+	const deadline = Date.now() + 1e4;
+	let signalled = false;
+	while (Date.now() < deadline) {
+		const status = await ownerStatus(session);
+		if (status === "dead") return;
+		if (status === "alive" && !signalled) {
+			try {
+				process.kill(session.pid, "SIGTERM");
+			} catch (error) {
+				if (error.code === "ESRCH") return;
+				throw error;
+			}
+			signalled = true;
+		}
+		await setTimeout(200);
+	}
+	throw new Error("Could not confirm dev session shutdown within 10 seconds. Export was cancelled.");
+}
+function restoreReadme(metadata) {
+	return `Kizlo WordPress export
+
+This archive contains private site data and user credentials. Store it securely.
+Source WordPress: ${metadata.wordpress}
+Source database: ${metadata.database}
+Source home URL: ${metadata.home}
+Source site URL: ${metadata.siteurl}
+Table prefix: ${metadata.prefix}
+Source collations: ${metadata.collations}
+
+Manual restore
+1. Back up the destination database and files. Install WordPress core separately,
+   with compatible PHP and plugins. This archive supplies only wp-content and SQL.
+2. Extract the outer ZIP and copy wp-content to the destination WordPress install.
+3. Keep database.sql.zip compressed. In phpMyAdmin, select the intended destination
+   database (its name may differ from the source), open Import, choose
+   database.sql.zip, select SQL format, and import. Do not upload the outer ZIP.
+   Import replaces matching tables. Use an account scoped to the destination DB.
+4. Keep the destination's own wp-config.php, database connection, salts and server
+   configuration. Set its table prefix to the source prefix shown above.
+5. Replace each distinct source URL with your destination URL using a
+   serialization-aware tool. This is a separate post-import step. For example:
+   wp search-replace 'SOURCE_URL' 'DESTINATION_URL' --all-tables --precise --dry-run
+   Check the dry run, then repeat without --dry-run. Do not edit serialized SQL
+   with text replacement. This export has not rewritten the source database.
+6. Check admin login, uploads, active plugins and representative site content.
+
+Compatibility and limits
+The SQL is a single-database MySQL dump. The inner ZIP contains only database.sql.
+Schema and collations are preserved, so the destination must support the source
+schema and collations above. Compressed imports through phpMyAdmin 5.2.3 have been
+validated against MySQL 8.4.10 and MariaDB 11.8.9 with utf8mb4_0900_ai_ci and
+utf8mb4_unicode_520_ci tables. Other versions/collations need their own check.
+DEFINER-bearing views, triggers, routines and events
+are rejected rather than silently omitted. A compatible SQL format cannot make an
+older database engine accept unsupported collations or features.
+PHP/phpMyAdmin upload_max_filesize, post_max_size and execution time limits may
+need increasing for a large import. These are separate from database compatibility.
+The PHP ZIP writer supports exports up to 4 GiB and 65,535 entries.
+See https://docs.phpmyadmin.net/en/latest/import_export.html for import limits.
+`;
+}
+/** Export existing data only; provisioning and foreground startup never run on this path. */
+async function exportDev(cwd) {
+	if (!await usesLocalWordPress(cwd)) throw new Error("Export requires an enabled local dev WordPress in kizlo.config.ts.");
+	const status = await dockerStatus();
+	if (status !== "running") throw new Error(dockerHint(status));
+	const cfg = await resolveDevConfig(cwd);
+	for (const file of [
+		"wp-config.php",
+		"wp-includes/version.php",
+		"wp-content"
+	]) if (!existsSync(join(cfg.wordpressDir, file))) throw new Error("No initialized local WordPress site found. Run `kizlo dev` before exporting.");
+	const lock = operationLock(cfg.configDir);
+	if (!await acquire(lock)) throw new Error("Another dev operation is active. Wait for it to finish and retry the export.");
+	const abort = new AbortController();
+	const cancel = () => abort.abort(/* @__PURE__ */ new Error("Export interrupted"));
+	const signals = [
+		"SIGINT",
+		"SIGTERM",
+		"SIGHUP"
+	];
+	for (const signal of signals) process.once(signal, cancel);
+	let staging;
+	let mysql;
+	let controlled = false;
+	let containerCreated = false;
+	let session;
+	const id = randomUUID();
+	const container = `${cfg.project}-export-${id}`;
+	const workspace = `/tmp/kizlo-export-${id}`;
+	const dump = `${workspace}.sql`;
+	const command = async (args, action, timeout = COMMAND_TIMEOUT) => {
+		abort.signal.throwIfAborted();
+		return checked(await docker(args, {
+			signal: abort.signal,
+			timeout
+		}), action);
+	};
+	let failure;
+	let output;
+	let published = false;
+	try {
+		const ids = await command([
+			"ps",
+			"-aq",
+			"--filter",
+			`label=com.docker.compose.project=${cfg.project}`,
+			"--filter",
+			"label=com.docker.compose.service=mysql"
+		], "Find existing database");
+		if (ids.length === 0 || ids.includes("\n")) throw new Error("No unique existing local database container found. Start and stop `kizlo dev` before exporting.");
+		mysql = ids;
+		ensureGitignored(cfg.configDir, ".kizlo/");
+		const exportsDir = join(cfg.configDir, ".kizlo/exports");
+		mkdirSync(exportsDir, {
+			recursive: true,
+			mode: 448
+		});
+		staging = mkdtempSync(join(exportsDir, ".staging-"));
+		chmodSync(staging, 448);
+		await command([
+			"cp",
+			`${mysql}:/var/lib/mysql/auto.cnf`,
+			join(staging, "initialized")
+		], "Validate initialized database volume");
+		session = projectSession(cfg.project);
+		if (session && await ownerStatus(session) !== "dead" && (!("token" in session) || session.operationFile !== lock)) throw new Error("Stop the existing dev session and restart it with the updated CLI before exporting.");
+		const stack = createStack(devStack(cfg));
+		const compose = async (args, action) => {
+			abort.signal.throwIfAborted();
+			return checked(await stack.compose(args, {
+				signal: abort.signal,
+				timeout: COMMAND_TIMEOUT
+			}), action);
+		};
+		controlled = true;
+		await compose([
+			"stop",
+			"wordpress",
+			"wp-cli"
+		], "Stop web and background WordPress requests");
+		await endDevSession(cfg.project, lock, session);
+		await command(["start", mysql], "Start existing database");
+		const sql = async (query, timeout = COMMAND_TIMEOUT) => command([
+			"exec",
+			mysql,
+			"sh",
+			"-c",
+			"export MYSQL_PWD=\"$MYSQL_ROOT_PASSWORD\"; exec mysql -uroot --batch --raw --skip-column-names --default-character-set=utf8mb4 \"$MYSQL_DATABASE\" -e \"$1\"",
+			"kizlo-export",
+			query
+		], "Read source database", timeout);
+		let ready = false;
+		const readinessDeadline = Date.now() + 3e4;
+		while (Date.now() < readinessDeadline) {
+			try {
+				await sql("SELECT 1", 1e3);
+				ready = true;
+				break;
+			} catch {
+				abort.signal.throwIfAborted();
+			}
+			await setTimeout(500, void 0, { signal: abort.signal });
+		}
+		if (!ready) throw new Error("Existing database did not become ready within 30 seconds.");
+		const objects = await sql("SELECT CONCAT('trigger: ', TRIGGER_NAME) FROM information_schema.TRIGGERS WHERE TRIGGER_SCHEMA=DATABASE() UNION ALL SELECT CONCAT('routine: ', ROUTINE_NAME) FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA=DATABASE() UNION ALL SELECT CONCAT('event: ', EVENT_NAME) FROM information_schema.EVENTS WHERE EVENT_SCHEMA=DATABASE() UNION ALL SELECT CONCAT('view: ', TABLE_NAME) FROM information_schema.VIEWS WHERE TABLE_SCHEMA=DATABASE()");
+		if (objects) throw new Error(`Database contains objects requiring hosting-specific DEFINER privileges. Export cannot omit them safely:\n${objects}`);
+		containerCreated = true;
+		await compose([
+			"run",
+			"-d",
+			"--no-deps",
+			"--name",
+			container,
+			"--user",
+			"0:0",
+			"--entrypoint",
+			"tail",
+			"wp-cli",
+			"-f",
+			"/dev/null"
+		], "Start temporary export tooling");
+		await command([
+			"exec",
+			container,
+			"php",
+			"-r",
+			"if (!class_exists(\"PharData\") || !Phar::canCompress(Phar::GZ)) { fwrite(STDERR, \"PHP requires PharData and zlib\"); exit(1); }"
+		], "Check PHP ZIP support");
+		const prefix = await command([
+			"exec",
+			container,
+			"wp",
+			"--allow-root",
+			"config",
+			"get",
+			"table_prefix",
+			"--type=variable"
+		], "Read table prefix");
+		if (!/^[a-zA-Z0-9_]+$/.test(prefix)) throw new Error("WordPress table prefix is invalid; export cannot read site metadata safely.");
+		const metadata = JSON.parse(await sql(`SELECT JSON_OBJECT('database', VERSION(), 'prefix', '${prefix}', 'home', (SELECT option_value FROM \`${prefix}options\` WHERE option_name='home'), 'siteurl', (SELECT option_value FROM \`${prefix}options\` WHERE option_name='siteurl'), 'collations', (SELECT GROUP_CONCAT(DISTINCT COLLATION_NAME ORDER BY COLLATION_NAME) FROM information_schema.COLUMNS WHERE TABLE_SCHEMA=DATABASE()))`));
+		const wordpress = await command([
+			"exec",
+			container,
+			"php",
+			"-r",
+			"require \"/var/www/html/wp-includes/version.php\"; echo $wp_version;"
+		], "Read WordPress version");
+		writeFileSync(join(staging, "README.txt"), restoreReadme({
+			...metadata,
+			wordpress
+		}), { mode: 384 });
+		await command([
+			"exec",
+			mysql,
+			"sh",
+			"-c",
+			"umask 077; export MYSQL_PWD=\"$MYSQL_ROOT_PASSWORD\"; exec mysqldump -uroot --single-transaction --quick --skip-lock-tables --skip-add-locks --no-tablespaces --set-gtid-purged=OFF --hex-blob --default-character-set=utf8mb4 --routines --events --triggers --result-file=\"$1\" \"$MYSQL_DATABASE\"",
+			"kizlo-export",
+			dump
+		], "Dump source database");
+		await command([
+			"cp",
+			`${mysql}:${dump}`,
+			join(staging, "database.sql")
+		], "Copy SQL to staging");
+		if (!statSync(join(staging, "database.sql")).size) throw new Error("The database dump is empty.");
+		await command([
+			"exec",
+			container,
+			"mkdir",
+			"-m",
+			"700",
+			workspace
+		], "Create temporary archive workspace");
+		for (const [source, destination] of [
+			[join(staging, "database.sql"), "database.sql"],
+			[join(staging, "README.txt"), "README.txt"],
+			[ARCHIVE_SCRIPT, "export.php"]
+		]) await command([
+			"cp",
+			source,
+			`${container}:${workspace}/${destination}`
+		], "Copy archive inputs");
+		await command([
+			"exec",
+			container,
+			"php",
+			"-d",
+			"memory_limit=-1",
+			`${workspace}/export.php`,
+			workspace,
+			"/var/www/html/wp-content"
+		], "Build export ZIP");
+		await command([
+			"cp",
+			`${container}:${workspace}/site.zip`,
+			join(staging, "site.zip")
+		], "Copy completed export");
+		if (!statSync(join(staging, "site.zip")).size) throw new Error("The completed export is empty.");
+		output = join(exportsDir, `wordpress-${(/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-")}-${id}.zip`);
+	} catch (error) {
+		failure = error;
+	}
+	const cleanupErrors = [];
+	const cleanup = async (args, action) => {
+		try {
+			checked(await docker(args, {
+				timeout: 6e4,
+				detached: true
+			}), action);
+		} catch (error) {
+			cleanupErrors.push(error);
+		}
+	};
+	if (controlled && mysql) await cleanup([
+		"exec",
+		mysql,
+		"rm",
+		"-f",
+		dump
+	], "Remove temporary SQL");
+	if (containerCreated) await cleanup([
+		"rm",
+		"-f",
+		container
+	], "Remove temporary export container");
+	if (controlled) try {
+		const ids = await runningProjectContainers(cfg.project, { timeout: 6e4 });
+		if (ids.length) await cleanup(["stop", ...ids], "Stop local dev stack");
+		if ((await runningProjectContainers(cfg.project, { timeout: 6e4 })).length) throw new Error("Local dev containers are still running.");
+		await endDevSession(cfg.project, lock, session);
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+	try {
+		abort.signal.throwIfAborted();
+		if (!failure && !cleanupErrors.length && output && staging) {
+			chmodSync(join(staging, "site.zip"), 384);
+			linkSync(join(staging, "site.zip"), output);
+			published = true;
+		}
+	} catch (error) {
+		failure ??= error;
+	}
+	try {
+		if (staging) rmSync(staging, {
+			recursive: true,
+			force: true
+		});
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+	for (const signal of signals) process.removeListener(signal, cancel);
+	try {
+		await releaseOwned(lock);
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+	if (failure || cleanupErrors.length || !output) {
+		if (published && output) rmSync(output, { force: true });
+		throw new AggregateError([...failure ? [failure] : [], ...cleanupErrors], [failure instanceof Error ? failure.message : "Export failed", ...cleanupErrors.map(String)].join("\n"));
+	}
+	return output;
+}
+
+//#endregion
+export { exportDev };

package/dist/cli/wp/session.js

@@ -1,11 +1,12 @@
 import { stopProjectContainers } from "./docker.js";
-import { currentProcessOwner, ownerAlive } from "../process-owner.js";
+import { currentProcessOwner, ownerStatus } from "../process-owner.js";
+import { acquire, releaseOwned } from "../daemon/lock.js";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { execFile, spawn } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { promisify } from "node:util";
 import { homedir } from "node:os";
+import { promisify } from "node:util";
 
 //#region src/cli/wp/session.ts
 const exec = promisify(execFile);
@@ -17,6 +18,9 @@ const exec = promisify(execFile);
 function registryPath() {
 	return join(homedir(), ".cache", "kizlo", "dev-sessions.json");
 }
+function projectSession(project) {
+	return readRegistry()[project];
+}
 function readRegistry() {
 	const file = registryPath();
 	if (!existsSync(file)) return {};
@@ -68,7 +72,7 @@ async function removeProjectContainers(project) {
 * being stopped, so the watchdog would have nothing to do). Best effort: a failure
 * here just means we fall back to signal handlers + the startup reaper.
 */
-function spawnWatchdog(project, owner) {
+function spawnWatchdog(project, owner, operationFile) {
 	try {
 		const watchdog = fileURLToPath(new URL("./watchdog.js", import.meta.url));
 		const child = spawn(process.execPath, [
@@ -76,7 +80,8 @@ function spawnWatchdog(project, owner) {
 			String(owner.pid),
 			String(owner.port),
 			owner.token,
-			project
+			project,
+			...operationFile ? [operationFile] : []
 		], {
 			detached: true,
 			stdio: "ignore"
@@ -88,10 +93,13 @@ function spawnWatchdog(project, owner) {
 	}
 }
 /** Record this process as the owner of `project`'s foreground stack. */
-async function registerSession(project) {
+async function registerSession(project, operationFile) {
 	const owner = await currentProcessOwner();
 	const registry = readRegistry();
-	registry[project] = owner;
+	registry[project] = {
+		...owner,
+		...operationFile ? { operationFile } : {}
+	};
 	writeRegistry(registry);
 	return owner;
 }
@@ -105,6 +113,19 @@ function unregisterSession(project) {
 		}
 	} catch {}
 }
+/** Defer crash cleanup while an export/lifecycle operation owns the project's resources. */
+async function retireSession(project, session) {
+	const file = session.operationFile;
+	if (file && !await acquire(file)) return false;
+	try {
+		const successor = projectSession(project);
+		if (successor && "token" in successor && (!("token" in session) || successor.token !== session.token) && await ownerStatus(successor) !== "dead") return true;
+		await stopProjectContainers(project);
+		return true;
+	} finally {
+		if (file) await releaseOwned(file);
+	}
+}
 /**
 * Stop any foreground stacks whose owning session has died (SIGKILL, crash, power
 * loss) — the cases a signal handler can never catch. Runs at the start of every
@@ -116,11 +137,13 @@ async function reapOrphans() {
 	const reaped = [];
 	let changed = false;
 	for (const [project, session] of Object.entries(registry)) {
-		if (await ownerAlive(session)) continue;
+		if (await ownerStatus(session) !== "dead") continue;
 		try {
-			await stopProjectContainers(project);
+			if (!await retireSession(project, session)) continue;
 			reaped.push(project);
-		} catch {}
+		} catch {
+			continue;
+		}
 		delete registry[project];
 		changed = true;
 	}
@@ -129,4 +152,4 @@ async function reapOrphans() {
 }
 
 //#endregion
-export { reapOrphans, registerSession, removeProjectContainers, spawnWatchdog, unregisterSession };
+export { projectSession, reapOrphans, registerSession, removeProjectContainers, retireSession, spawnWatchdog, unregisterSession };

package/dist/cli/wp/watchdog.js

@@ -1,9 +1,7 @@
-import { ownerAlive } from "../process-owner.js";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
+import { ownerStatus } from "../process-owner.js";
+import { retireSession } from "./session.js";
 
 //#region src/cli/wp/watchdog.ts
-const exec = promisify(execFile);
 /**
 * Standalone watchdog process spawned (detached, in its own session) by a foreground
 * `kizlo dev`. It polls the parent's identity and, the moment the parent is gone for *any*
@@ -17,18 +15,7 @@ const parentPid = Number(process.argv[2]);
 const parentPort = Number(process.argv[3]);
 const parentToken = process.argv[4];
 const project = process.argv[5];
-async function stopStack() {
-	try {
-		const { stdout } = await exec("docker", [
-			"ps",
-			"-q",
-			"--filter",
-			`label=com.docker.compose.project=${project}`
-		]);
-		const ids = stdout.split("\n").filter(Boolean);
-		if (ids.length) await exec("docker", ["stop", ...ids]);
-	} catch {}
-}
+const operationFile = process.argv[6];
 if (!parentPid || !parentPort || !parentToken || !project) process.exit(1);
 const parent = {
 	pid: parentPid,
@@ -48,8 +35,8 @@ let missed = 0;
 const timer = setInterval(() => {
 	if (checking) return;
 	checking = true;
-	ownerAlive(parent).then((alive) => {
-		if (alive) {
+	ownerStatus(parent).then(async (status) => {
+		if (status !== "dead") {
 			missed = 0;
 			checking = false;
 			return;
@@ -58,8 +45,20 @@ const timer = setInterval(() => {
 			checking = false;
 			return;
 		}
+		try {
+			if (!await retireSession(project, {
+				...parent,
+				operationFile
+			})) {
+				checking = false;
+				return;
+			}
+		} catch {
+			checking = false;
+			return;
+		}
 		clearInterval(timer);
-		stopStack().then(() => process.exit(0));
+		process.exit(0);
 	});
 }, 1e3);
 

package/dist/context.d.ts

@@ -1,5 +1,4 @@
 import { ActiveWordPressClient, WordPressCredentials } from "./wordpress/types.js";
-import { WordPressTransport } from "./wordpress/transport.js";
 import "./wordpress/index.js";
 import { AuthUser } from "./adapters/auth.js";
 import { PreviewTokenPayload } from "./shared/schema.js";
@@ -31,8 +30,8 @@ type VerifyPreviewTokenFn = (token: string) => Promise<PreviewTokenPayload | nul
  * the server builds. A procedure's handler receives this base plus whatever its middleware injected
  * via `next({ context })`.
  */
-interface ProcedureContext {
-  /** The incoming HTTP `Request`, or `null` for server-side (non-HTTP) invocations. */
+interface BuiltinProcedureContext {
+  /** The active HTTP `Request`, or `null` outside a request scope. */
   request: Request | null;
   /** Response headers to be sent (e.g. `Set-Cookie`), or `null` server-side. */
   headers: Headers | null;
@@ -59,6 +58,10 @@ interface ProcedureContext {
   /** How the procedure was called: `"client"` (over HTTP) or `"server"` (direct server invocation). */
   invokedBy: "client" | "server";
 }
+/** Augment in the application to add typed, server-supplied request fields. */
+interface ProcedureContext extends BuiltinProcedureContext {}
+/** The application fields accepted by handler(request, values), excluding Kizlo-owned fields. */
+type PlatformRequestCtx = Omit<ProcedureContext, keyof BuiltinProcedureContext> & object;
 declare class Context {
   private readonly config;
   private readonly logger;
@@ -77,35 +80,15 @@ declare class Context {
   private warnIfOutdated;
   /** Bold yellow, boxed in dashes so it stands out in a busy dev console. */
   private warn;
-  createRestContext(request: Request): {
-    getConnInfo: ConnInfoFn;
-    verifyCaptcha: VerifyCaptchaFn;
-    getSession: SessionFn;
-    verifyPreviewToken: VerifyPreviewTokenFn;
-    cookies: CookiesStorage;
-    invokedBy: "client";
-    wordpress: WordPressTransport;
-    settings: SettingsService;
-    email: EmailService;
-    headers: Headers;
+  withRequestContext(request: Request, values: PlatformRequestCtx | undefined, handle: () => Promise<Response>): Promise<Response>;
+  createRestContext(request: Request, values?: PlatformRequestCtx): ProcedureContext & {
     request: Request;
-    config: ContextConfig;
-    logger: Logger;
+    headers: Headers;
+    invokedBy: "client";
   };
-  createServerContext(): {
-    getSession: SessionFn;
-    getConnInfo: ConnInfoFn;
-    verifyCaptcha: VerifyCaptchaFn;
-    verifyPreviewToken: VerifyPreviewTokenFn;
-    invokedBy: "server";
-    wordpress: WordPressTransport;
-    settings: SettingsService;
-    email: EmailService;
-    cookies: CookiesStorage;
+  createServerContext(): ProcedureContext & {
     headers: null;
-    request: null;
-    config: ContextConfig;
-    logger: Logger;
+    invokedBy: "server";
   };
   private createRestCookieStorage;
   private createVerifyCaptchaFn;
@@ -115,4 +98,4 @@ declare class Context {
   private createLogger;
 }
 //#endregion
-export { ConnInfoFn, Context, ContextConfig, ProcedureContext, SessionFn, VerifyCaptchaFn, VerifyPreviewTokenFn };
+export { ConnInfoFn, Context, ContextConfig, PlatformRequestCtx, ProcedureContext, SessionFn, VerifyCaptchaFn, VerifyPreviewTokenFn };

package/dist/context.js

@@ -102,9 +102,15 @@ var Context = class {
 		const border = "-".repeat(inner.length + 2);
 		console.warn(`\n\x1b[1m\x1b[33m${border}\n|${inner}|\n${border}\x1b[0m\n`);
 	}
-	createRestContext(request) {
+	withRequestContext(request, values, handle) {
+		if (values !== void 0 && (values === null || typeof values !== "object" || Array.isArray(values))) throw new TypeError("Request context must be an object.");
+		return this.config.adapters?.requestContext?.run?.(request, values, handle) ?? handle();
+	}
+	createRestContext(request, values) {
 		const headers = new Headers();
 		return {
+			...this.config.adapters?.requestContext?.get()?.values,
+			...values,
 			headers,
 			request: request.clone(),
 			config: this.config,
@@ -123,21 +129,24 @@ var Context = class {
 		};
 	}
 	createServerContext() {
+		const scope = this.config.adapters?.requestContext?.get();
+		const request = scope?.request ?? null;
 		const cookies = new CookiesStorage(this.config.adapters?.cookies);
 		return {
+			...scope?.values,
 			cookies,
 			headers: null,
-			request: null,
+			request,
 			config: this.config,
 			logger: this.logger,
-			...this.config.adapters?.geo ? this.createServices(null) : {
+			...this.config.adapters?.geo ? this.createServices(request) : {
 				wordpress: this.wordpress,
 				settings: this.settings,
 				email: this.email
 			},
-			getSession: this.createGetSessionFn(null, cookies),
-			getConnInfo: this.createConnInfoFn(null),
-			verifyCaptcha: this.createVerifyCaptchaFn(null),
+			getSession: this.createGetSessionFn(request, cookies),
+			getConnInfo: this.createConnInfoFn(request),
+			verifyCaptcha: this.createVerifyCaptchaFn(request),
 			verifyPreviewToken: this.createVerifyPreviewTokenFn(),
 			invokedBy: "server"
 		};