void 0.21.9 → 0.23.0

package/dist/sandbox-container-C6ItmVuN.mjs

@@ -0,0 +1,281 @@
+import { DurableObject, RpcTarget } from "cloudflare:workers";
+import { Files } from "@cloudflare/sandbox";
+//#region src/runtime/sandbox-container.ts
+const OPTIONS = /* @__PURE__ */ new Set([
+	"inactivityTimeoutMs",
+	"enableInternet",
+	"labels"
+]);
+const FILE_OPERATIONS = /* @__PURE__ */ new Set([
+	"readFile",
+	"writeFile",
+	"stat",
+	"lstat",
+	"readDirectory",
+	"mkdir",
+	"rename",
+	"remove"
+]);
+const DEFAULT_SANDBOX_INACTIVITY_TIMEOUT_MS = 6e5;
+function validateSandboxOptions(options) {
+	if (!options || typeof options !== "object" || Array.isArray(options)) throw new TypeError("Sandbox options must be an object.");
+	for (const key of Object.keys(options)) if (!OPTIONS.has(key)) throw new TypeError(`Unsupported Sandbox option: ${key}`);
+	if (options.inactivityTimeoutMs !== void 0 && (!Number.isInteger(options.inactivityTimeoutMs) || options.inactivityTimeoutMs < 1 || options.inactivityTimeoutMs > 216e5)) throw new TypeError("Sandbox inactivityTimeoutMs must be an integer between 1 and 21600000.");
+	if (options.enableInternet !== void 0 && typeof options.enableInternet !== "boolean") throw new TypeError("Sandbox enableInternet must be a boolean.");
+	if (options.labels !== void 0 && (!options.labels || typeof options.labels !== "object" || Array.isArray(options.labels) || Object.values(options.labels).some((value) => typeof value !== "string"))) throw new TypeError("Sandbox labels must be strings.");
+}
+var ProcessCapability = class extends RpcTarget {
+	#process;
+	#exited = false;
+	#waitForExit;
+	constructor(process, waitForExit) {
+		super();
+		this.#process = process;
+		this.#waitForExit = waitForExit;
+		process.exitCode.then(() => {
+			this.#exited = true;
+		}, () => {
+			this.#exited = true;
+		});
+	}
+	async invoke(operation, args) {
+		if (!Array.isArray(args)) throw new TypeError("Sandbox arguments must be an array.");
+		if (operation === "exitCode") return this.#waitForExit();
+		if (operation === "kill") {
+			if (this.#exited) return;
+			return this.#process.kill(args[0]);
+		}
+		if (operation === "resize") return this.#process.resize(args[0], args[1]);
+		throw new TypeError(`Unsupported Sandbox process operation: ${operation}`);
+	}
+};
+/** Decode cancellation without trying to serialize an AbortSignal over Workers RPC. */
+function operationOptions(value) {
+	const { abort, ...options } = value ?? {};
+	if (abort === void 0) return {
+		options,
+		finish() {}
+	};
+	if (!(abort instanceof ReadableStream)) throw new TypeError("Invalid Sandbox cancellation stream.");
+	const controller = new AbortController();
+	const reader = abort.getReader();
+	let finished = false;
+	reader.read().then(() => {
+		if (!finished) controller.abort();
+	}, () => {
+		if (!finished) controller.abort();
+	});
+	return {
+		options: {
+			...options,
+			signal: controller.signal
+		},
+		finish() {
+			finished = true;
+			reader.cancel().catch(() => {});
+		}
+	};
+}
+/** Shared native execution, used by local Workers and the trusted platform controller. */
+var SandboxContainer = class extends DurableObject {
+	instanceType = "lite";
+	#setup;
+	#options = {};
+	#ready;
+	starting = false;
+	#epoch = 0;
+	constructor(ctx, env) {
+		super(ctx, env);
+		this.#ready = ctx.blockConcurrencyWhile(async () => {
+			this.#options = await ctx.storage.get("__voidSandboxOptions") ?? {};
+			if (this.container.running) await this.container.setInactivityTimeout(this.inactivityTimeoutMs);
+		});
+	}
+	get container() {
+		if (!this.ctx.container) throw new Error("Sandbox container binding is missing.");
+		return this.ctx.container;
+	}
+	async configure(options) {
+		validateSandboxOptions(options);
+		await this.#ready;
+		this.#options = { ...options };
+		await this.ctx.storage.put("__voidSandboxOptions", this.#options);
+		if (this.container.running) await this.container.setInactivityTimeout(this.inactivityTimeoutMs);
+	}
+	get inactivityTimeoutMs() {
+		return this.#options.inactivityTimeoutMs ?? 6e5;
+	}
+	async beforeStart() {}
+	async afterStart() {}
+	async beforeUse() {}
+	async stopped() {}
+	processContext(_exitCode) {}
+	async waitForProcessExit(exitCode, _context) {
+		return exitCode;
+	}
+	/** Native abort listeners must be detached as soon as a process exits. */
+	async execProcess(argv, options = {}) {
+		const { signal, ...nativeOptions } = options;
+		if (!signal) return this.container.exec(argv, nativeOptions);
+		const controller = new AbortController();
+		const abort = () => controller.abort();
+		if (signal.aborted) abort();
+		else signal.addEventListener("abort", abort, { once: true });
+		const finish = () => signal.removeEventListener("abort", abort);
+		try {
+			const process = await this.container.exec(argv, {
+				...nativeOptions,
+				signal: controller.signal
+			});
+			process.exitCode.then(finish, finish);
+			return process;
+		} catch (error) {
+			finish();
+			throw error;
+		}
+	}
+	async initializationOutput(argv, options, timeoutMs) {
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), timeoutMs);
+		const finish = () => clearTimeout(timer);
+		try {
+			const process = await this.execProcess(argv, {
+				...options,
+				signal: controller.signal
+			});
+			process.exitCode.then(finish, finish);
+			return await process.output();
+		} finally {
+			finish();
+		}
+	}
+	async initialize() {
+		if ((await this.initializationOutput([
+			"sh",
+			"-c",
+			"mkdir -p /workspace"
+		], {}, 6e4)).exitCode !== 0) throw new Error("Sandbox workspace initialization failed.");
+	}
+	get entrypoint() {}
+	get image() {
+		return this.container.images.default;
+	}
+	async ensureRunning() {
+		if (!this.#setup || !this.container.running && !this.starting) {
+			this.starting = true;
+			this.#setup = this.setup(this.#epoch).catch((error) => {
+				this.#setup = void 0;
+				throw error;
+			}).finally(() => {
+				this.starting = false;
+			});
+		}
+		await this.#setup;
+		await this.beforeUse();
+	}
+	async setup(epoch) {
+		await this.#ready;
+		try {
+			await this.beforeStart();
+			if (epoch !== this.#epoch) throw new Error("Sandbox startup was cancelled.");
+			if (!this.container.running) this.container.start({
+				image: this.image,
+				instance: this.instanceType,
+				enableInternet: this.#options.enableInternet ?? false,
+				labels: this.#options.labels,
+				...this.entrypoint ? { entrypoint: this.entrypoint } : {}
+			});
+			await this.initialize();
+			if (epoch !== this.#epoch) throw new Error("Sandbox startup was cancelled.");
+			await this.container.setInactivityTimeout(this.inactivityTimeoutMs);
+			await this.afterStart();
+		} catch (error) {
+			await this.destroy().catch(() => {});
+			throw error;
+		}
+	}
+	async destroy() {
+		this.#epoch++;
+		if (this.container.running) await this.container.destroy();
+		if (this.container.running) throw new Error("VOID_SANDBOX_unavailable");
+		if (!this.starting) this.#setup = void 0;
+		await this.stopped();
+	}
+	async invoke(operation, args) {
+		if (!Array.isArray(args)) throw new TypeError("Sandbox arguments must be an array.");
+		if (operation === "destroy") return this.destroy();
+		if (operation === "running") return this.container.running;
+		if (operation === "files") {
+			const [method, ...parameters] = args;
+			if (!FILE_OPERATIONS.has(method)) throw new TypeError(`Unsupported Sandbox file operation: ${String(method)}`);
+			await this.ensureRunning();
+			const index = method === "writeFile" || method === "rename" ? 2 : 1;
+			const { options, finish } = operationOptions(parameters[index]);
+			parameters[index] = options;
+			try {
+				const files = new Files({ exec: (argv, options) => this.execProcess(argv, options) });
+				const result = await files[method].apply(files, parameters);
+				if (result instanceof Response && result.body) {
+					const reader = result.body.getReader();
+					return new Response(new ReadableStream({
+						async pull(controller) {
+							try {
+								const chunk = await reader.read();
+								if (chunk.done) {
+									finish();
+									controller.close();
+								} else controller.enqueue(chunk.value);
+							} catch (error) {
+								finish();
+								controller.error(error);
+							}
+						},
+						async cancel(reason) {
+							finish();
+							await reader.cancel(reason);
+						}
+					}), result);
+				}
+				finish();
+				return result;
+			} catch (error) {
+				finish();
+				throw error;
+			}
+		}
+		if (operation === "exec") {
+			const [argv, value] = args;
+			if (!Array.isArray(argv) || argv.length === 0 || argv.some((arg) => typeof arg !== "string")) throw new TypeError("Sandbox exec requires an executable and arguments as an array of strings.");
+			const { options, finish } = operationOptions(value);
+			try {
+				await this.ensureRunning();
+				const process = await this.execProcess(argv, {
+					cwd: "/workspace",
+					...options
+				});
+				process.exitCode.then(finish, finish);
+				const processContext = this.processContext(process.exitCode);
+				return {
+					capability: new ProcessCapability(process, () => this.waitForProcessExit(process.exitCode, processContext)),
+					pid: process.pid,
+					isPty: process.isPty ?? false,
+					stdin: process.stdin ?? null,
+					stdout: process.stdout ?? null,
+					stderr: process.stderr ?? null
+				};
+			} catch (error) {
+				finish();
+				throw error;
+			}
+		}
+		if (operation === "fetch") {
+			const [port, request] = args;
+			if (!Number.isInteger(port) || port < 1 || port > 65535) throw new TypeError("Invalid Sandbox TCP port.");
+			await this.ensureRunning();
+			return this.container.getTcpPort(port).fetch(request);
+		}
+		throw new TypeError(`Unsupported Sandbox operation: ${operation}`);
+	}
+};
+//#endregion
+export { SandboxContainer as n, validateSandboxOptions as r, DEFAULT_SANDBOX_INACTIVITY_TIMEOUT_MS as t };

package/dist/{scan-4tfN-PSn.mjs → scan-C7okrLyM.mjs}

@@ -2,41 +2,9 @@ import { a as join, n as dirname, r as extname, t as basename } from "./dist-BVq
 import { n as readProjectPaths } from "./project-paths-GgcMozYz.mjs";
 import { t as glob } from "./dist-Bn8Kodjp.mjs";
 import { n as isIdentifier, r as isLiteral } from "./ast-CPGPjb0V.mjs";
-import { n as parseRouteFilename } from "./parse-filename-DioPHiR9.mjs";
+import { a as staticLiteral, i as staticExportInitializers, n as parseRouteFilename } from "./parse-filename-CUbj-1MP.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import { parseSync } from "vite";
-//#region src/shared/static-exports.ts
-/** Read the initializer of directly exported constants without evaluating user code. */
-function staticExportInitializers(filename, source, names) {
-	const result = /* @__PURE__ */ new Map();
-	const program = parseSync(filename, source).program;
-	for (const statement of program.body ?? []) {
-		if (statement.type !== "ExportNamedDeclaration") continue;
-		const declaration = statement.declaration;
-		if (declaration?.type !== "VariableDeclaration" || declaration.kind !== "const") continue;
-		for (const variable of declaration.declarations ?? []) if (isIdentifier(variable.id) && names.has(variable.id.name) && variable.init) result.set(variable.id.name, variable.init);
-	}
-	return result;
-}
-function unwrapStaticExpression(node) {
-	while (node && [
-		"ParenthesizedExpression",
-		"TSAsExpression",
-		"TSSatisfiesExpression",
-		"TSTypeAssertion"
-	].includes(node.type)) node = node.expression;
-	return node;
-}
-function staticLiteral(node) {
-	node = unwrapStaticExpression(node);
-	if (node?.type === "Literal") return node.value;
-	if (node?.type === "TemplateLiteral") {
-		const expressions = node.expressions;
-		const quasis = node.quasis;
-		if (expressions?.length === 0 && quasis?.length === 1) return quasis[0]?.value?.cooked;
-	}
-}
-//#endregion
 //#region src/pages/layout-resolution.ts
 function isNamedLayout(layout) {
 	return "name" in layout;
@@ -131,7 +99,8 @@ function componentLayout(source, filename) {
 	const scripts = filename.endsWith(".vue") || filename.endsWith(".svelte") ? [...source.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script\s*>/gi)].map((match) => match[1]) : [source];
 	for (const script of scripts) {
 		if (!script.includes("layout")) continue;
-		const value = staticLiteral(staticExportInitializers(filename.replace(/\.(vue|svelte)$/, ".ts"), script, /* @__PURE__ */ new Set(["layout"])).get("layout"));
+		const initializer = staticExportInitializers(filename.replace(/\.(vue|svelte)$/, ".ts"), script, /* @__PURE__ */ new Set(["layout"])).get("layout");
+		const value = staticLiteral(initializer);
 		if (typeof value === "string" || value === false) return value;
 	}
 }
@@ -366,4 +335,4 @@ function extractFrontmatterLayout(source) {
 	return value;
 }
 //#endregion
-export { resolveNamedLayout as a, unwrapStaticExpression as c, resolveLayoutIds as i, resolveEffectiveLayoutChain as n, staticExportInitializers as o, resolveLayoutChain as r, staticLiteral as s, scanPages as t };
+export { resolveNamedLayout as a, resolveLayoutIds as i, resolveEffectiveLayoutChain as n, resolveLayoutChain as r, scanPages as t };

package/dist/{secret-DN9sSNiV.mjs → secret-Dli5fP0B.mjs}

@@ -1,9 +1,9 @@
-import { r as cliTitle } from "./output-CCH48AMM.mjs";
-import { c as getToken } from "./auth-DLNN0D3Z.mjs";
+import { c as getToken } from "./auth-CSkdO2Bb.mjs";
 import { i as readDeploymentPlatform, o as readProjectConfig } from "./project-C0Fqu05O.mjs";
-import { _ as validateSecretValues } from "./env-validation-BB4GkLxn.mjs";
-import { E as confirm, F as password, N as note, O as intro, P as outro, T as cancel, W as isCancel, j as log } from "./dist-Dn6nn2IU.mjs";
-import { n as PlatformClient } from "./client-QTl6ko_D.mjs";
+import { _ as validateSecretValues } from "./env-validation-BPn7vk-V.mjs";
+import { E as confirm, F as password, N as note, O as intro, P as outro, T as cancel, W as isCancel, j as log } from "./dist-CTBk70IR.mjs";
+import { n as PlatformClient } from "./client-RV8NVeB8.mjs";
+import { r as cliTitle } from "./output-Dm_A4Tbv.mjs";
 import { r as resolveProjectBySlug, t as getRequestedProjectSlug } from "./resolve-project-BG5ORGID.mjs";
 import { readFileSync } from "node:fs";
 //#region src/cli/secret.ts
@@ -78,7 +78,7 @@ async function runSecretCommand(root, args) {
 }
 async function runCloudflareSecretCommand(root, args) {
 	if (args.projectName) throw new Error("secret: --project selects a Void platform project and is not used for direct Cloudflare apps.");
-	const { deleteCloudflareSecret, listCloudflareSecrets, putCloudflareSecret, resolveCloudflareOperationContext, syncCloudflareSecrets } = await import("./cloudflare-operations-BipGMJ5O.mjs");
+	const { deleteCloudflareSecret, listCloudflareSecrets, putCloudflareSecret, resolveCloudflareOperationContext, syncCloudflareSecrets } = await import("./cloudflare-operations-AiWashgg.mjs");
 	const context = resolveCloudflareOperationContext(root);
 	if (args.action === "list") {
 		const secrets = await listCloudflareSecrets(context);

package/dist/{skills-O6FUaizK.mjs → skills-D1II1Juz.mjs}

@@ -1,5 +1,5 @@
 import { a as join, l as relative } from "./dist-BVqXeR_h.mjs";
-import { j as log } from "./dist-Dn6nn2IU.mjs";
+import { j as log } from "./dist-CTBk70IR.mjs";
 import { n as getPackageDir } from "./agents-B_pX_HmQ.mjs";
 import { existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, symlinkSync } from "node:fs";
 //#region src/cli/skills.ts

package/dist/{sse-BaC1jXko.mjs → sse-CQNaDFFV.mjs}

@@ -55,6 +55,7 @@ function eventStream(start, options = {}) {
 	const markClosed = () => {
 		if (closedOnce) return;
 		closedOnce = true;
+		options.signal?.removeEventListener("abort", abort);
 		if (!signalController.signal.aborted) signalController.abort();
 		if (keepAliveTimer != null) {
 			clearInterval(keepAliveTimer);
@@ -68,10 +69,12 @@ function eventStream(start, options = {}) {
 		await writer.close().catch(() => {});
 	}
 	async function fail(error) {
-		if (closedOnce) return;
 		markClosed();
 		await writer.abort(error).catch(() => {});
 	}
+	function abort() {
+		fail(options.signal?.reason ?? new SseStreamClosedError());
+	}
 	async function write(text) {
 		if (closedOnce) throw new SseStreamClosedError();
 		try {
@@ -95,11 +98,11 @@ function eventStream(start, options = {}) {
 	writer.closed.catch(() => {
 		close();
 	});
-	if (options.signal?.aborted) close();
-	else options.signal?.addEventListener("abort", () => void close(), { once: true });
 	if (keepAlive) keepAliveTimer = setInterval(() => {
 		stream.comment(keepAlive.comment).catch(() => close());
 	}, keepAlive.intervalMs);
+	if (options.signal?.aborted) abort();
+	else options.signal?.addEventListener("abort", abort, { once: true });
 	queueMicrotask(() => {
 		(async () => {
 			try {

package/dist/{subcommand-prompt-BuGYkAkC.mjs → subcommand-prompt-CY1C4fvl.mjs}

@@ -1,5 +1,5 @@
-import { c as import_picocolors } from "./output-CCH48AMM.mjs";
-import { S as S_STEP_SUBMIT, _ as S_RADIO_ACTIVE, c as S_CHECKBOX_INACTIVE, i as S_BAR_END, q as wrapAnsi, r as S_BAR, s as S_CHECKBOX_ACTIVE, v as S_RADIO_INACTIVE, y as S_STEP_ACTIVE } from "./dist-Dn6nn2IU.mjs";
+import { S as S_STEP_SUBMIT, _ as S_RADIO_ACTIVE, c as S_CHECKBOX_INACTIVE, i as S_BAR_END, q as wrapAnsi, r as S_BAR, s as S_CHECKBOX_ACTIVE, v as S_RADIO_INACTIVE, y as S_STEP_ACTIVE } from "./dist-CTBk70IR.mjs";
+import { c as import_picocolors } from "./output-Dm_A4Tbv.mjs";
 //#region src/cli/subcommand-prompt.ts
 function promptSubcommand(command, subcommands) {
 	return new Promise((resolve) => {

package/dist/validate-Dq_L3s0S.mjs

@@ -0,0 +1,2 @@
+import { i as validateMigrations } from "./validate-ctOrgiS3.mjs";
+export { validateMigrations };

package/dist/{validate-CIUwFpjB.mjs → validate-ctOrgiS3.mjs}

@@ -1,7 +1,8 @@
 import { a as join } from "./dist-BVqXeR_h.mjs";
 import { n as readJournal, r as stripSqlExt } from "./collect-DiTn9yr6.mjs";
-import { t as DESTRUCTIVE_PRAGMA, u as tokenizeSql } from "./plan-BEZ8VJW0.mjs";
+import { t as DESTRUCTIVE_PRAGMA } from "./plan-NPpwZ_kc.mjs";
 import { existsSync, readdirSync } from "node:fs";
+import { tokenizeSql } from "@void/deploy-core";
 //#region src/migrations/validate.ts
 /**
 * Destructive SQL patterns that are rejected unless the migration