void 0.10.12 → 0.20.0

package/dist/neon-DHwd2zvC.mjs

@@ -0,0 +1,54 @@
+import { defineDatabaseProvider } from "./database-provider.mjs";
+//#region src/database-providers/neon.ts
+function getConnectionString(payload) {
+	if (!payload || typeof payload !== "object") return;
+	const record = payload;
+	const direct = record.connection_uri ?? record.connectionString;
+	if (typeof direct === "string") return direct;
+	if (Array.isArray(record.connection_uris)) for (const item of record.connection_uris) {
+		const result = getConnectionString(item);
+		if (result) return result;
+	}
+}
+function createNeonDatabaseProvider(options = {}) {
+	const apiKey = options.apiKey ?? process.env.NEON_API_KEY;
+	const apiBaseUrl = options.apiBaseUrl ?? "https://console.neon.tech/api/v2";
+	const fetchImpl = options.fetch ?? globalThis.fetch;
+	return defineDatabaseProvider({
+		id: "neon",
+		label: "Neon",
+		dialects: ["postgresql"],
+		async provision(input) {
+			if (!apiKey) throw new Error("NEON_API_KEY is required to provision a Neon database.");
+			if (input.dialect !== "postgresql") throw new Error("Neon provisions PostgreSQL databases only.");
+			const response = await fetchImpl(`${apiBaseUrl}/projects`, {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${apiKey}`,
+					"Content-Type": "application/json"
+				},
+				body: JSON.stringify({ project: {
+					name: input.name,
+					...input.region ? { region_id: input.region } : {}
+				} }),
+				signal: input.signal
+			});
+			const payload = await response.json().catch(() => void 0);
+			if (!response.ok) {
+				const message = typeof payload?.message === "string" ? payload.message : `${response.status} ${response.statusText}`.trim();
+				throw new Error(`Neon provisioning failed: ${message}`);
+			}
+			const connectionString = getConnectionString(payload);
+			if (!connectionString) throw new Error("Neon created the project but did not return a connection string.");
+			const project = payload?.project;
+			const projectId = typeof project?.id === "string" ? project.id : void 0;
+			return {
+				connectionString,
+				projectId,
+				dashboardUrl: projectId ? `https://console.neon.tech/app/projects/${projectId}` : void 0
+			};
+		}
+	});
+}
+//#endregion
+export { createNeonDatabaseProvider };

package/dist/{node-Da0UcsGA.mjs → node-BkaXcpAc.mjs}

@@ -1,10 +1,10 @@
-import { a as join } from "./dist-DaKKDf8D.mjs";
-import { c as loadVoidAuthConfig, s as findVoidAuthConfig } from "./scan-DYXkrasO.mjs";
-import { f as readConfig } from "./config-BkTvs43g.mjs";
-import { a as resolveVoidAuthMigrationSchema } from "./route-types-COI2DsZv.mjs";
-import { n as applySqliteAuthMigrations, t as applyPgAuthMigrations } from "./auth-migrations-BTZ-ATvQ.mjs";
-import { getMiniflareDatabasePath } from "./runner-kapo9aPs.mjs";
-import { loadEnv } from "vite";
+import { o as join } from "./dist-BrsS7cai.mjs";
+import { c as loadVoidAuthConfig, s as findVoidAuthConfig } from "./scan-BMH4rzlv.mjs";
+import { f as readConfig } from "./config-BQFq7QvD.mjs";
+import { r as getMiniflareDatabasePath } from "./local-d1-BE8KBbMy.mjs";
+import { a as resolveVoidAuthMigrationSchema } from "./route-types-Da-DpyUp.mjs";
+import { a as loadLocalEnv } from "./env-D4Emu-M_.mjs";
+import { n as applyPgAuthMigrations, r as applySqliteAuthMigrations, t as applyMySqlAuthMigrations } from "./auth-migrations-9vif1uj8.mjs";
 //#region src/auth/node.ts
 async function runLocalVoidAuthMigrations(root, dialect, persistRoot = join(root, ".void"), databaseId = "local", configPath = findVoidAuthConfig(root)) {
 	const authConfig = await loadVoidAuthConfig(configPath);
@@ -13,7 +13,10 @@ async function runLocalVoidAuthMigrations(root, dialect, persistRoot = join(root
 		providers: readConfig(root).auth?.providers ?? null,
 		userConfig: authConfig
 	};
-	const env = loadEnv("development", root, "");
+	const env = {
+		...loadLocalEnv(root),
+		...process.env
+	};
 	const migrationSchema = resolveVoidAuthMigrationSchema(runtime, env);
 	if (dialect === "sqlite") {
 		const { DatabaseSync } = await import("node:sqlite");
@@ -34,6 +37,24 @@ async function runLocalVoidAuthMigrations(root, dialect, persistRoot = join(root
 	}
 	const connectionString = typeof env.DATABASE_URL === "string" && env.DATABASE_URL.length > 0 ? env.DATABASE_URL : void 0;
 	if (!connectionString) return;
+	if (dialect === "mysql") {
+		const { createConnection } = await import("mysql2/promise");
+		const connection = await createConnection(connectionString);
+		try {
+			await applyMySqlAuthMigrations({
+				async all(sql, params) {
+					const [rows] = await connection.query(sql, params);
+					return rows;
+				},
+				async run(sql, params) {
+					await connection.query(sql, params);
+				}
+			}, migrationSchema);
+		} finally {
+			await connection.end();
+		}
+		return;
+	}
 	const { Client } = await import("pg");
 	const client = new Client({ connectionString });
 	await client.connect();

package/dist/operator-cmd-DYWRbWUA.mjs

@@ -0,0 +1,348 @@
+import { G as normalizePlatformApiUrl, K as platformCredentialAccount, V as getActivePlatformConnection, W as listPlatformConnections, at as readKeyringPassword, it as deleteKeyringPassword, ot as writeKeyringPassword } from "./output-tFQLLj26.mjs";
+import { n as OperatorClient, r as OperatorClientError } from "./cli/cli.mjs";
+import { createHash } from "node:crypto";
+import { createInterface } from "node:readline/promises";
+import { setTimeout } from "node:timers/promises";
+/** Operator authority never comes from repository-controlled metadata. */
+function resolveOperatorOrigin(connection = "") {
+	if (connection) {
+		let normalized = null;
+		try {
+			normalized = normalizePlatformApiUrl(connection);
+		} catch {}
+		const matches = listPlatformConnections().filter((entry) => entry.id === connection || entry.installationId === connection || entry.apiUrl === normalized);
+		if (matches.length !== 1) throw new OperatorClientError("Select a registered platform connection ID or URL. Run `void connect <url> --no-login` to register it first.", "invalid_connection");
+		return matches[0].apiUrl;
+	}
+	if (process.env.VOID_API_URL) return normalizePlatformApiUrl(process.env.VOID_API_URL);
+	if (process.env.VOID_OPERATOR_TOKEN) throw new OperatorClientError("VOID_OPERATOR_TOKEN requires an explicit --connection or VOID_API_URL to select its recipient.", "explicit_origin_required");
+	const active = getActivePlatformConnection();
+	if (!active) throw new OperatorClientError("No default platform connection. Run `void connect <url>` or specify --connection.", "connection_required");
+	return active.apiUrl;
+}
+function readOperatorToken(origin) {
+	const token = process.env.VOID_OPERATOR_TOKEN || readKeyringPassword("dev.void.cli.operator", platformCredentialAccount(origin));
+	if (!token) throw new OperatorClientError("No operator session. Run `void platform auth login` or set VOID_OPERATOR_TOKEN with an explicit origin.", "authentication_required");
+	return token;
+}
+function saveOperatorToken(origin, token) {
+	if (!writeKeyringPassword("dev.void.cli.operator", platformCredentialAccount(origin), token)) throw new OperatorClientError("The system keychain is unavailable. Use `void platform auth token --token-stdin` with a full API session to obtain a token for VOID_OPERATOR_TOKEN; plaintext credential storage is disabled.", "keychain_unavailable");
+}
+function removeOperatorToken(origin) {
+	const account = platformCredentialAccount(origin);
+	if (readKeyringPassword("dev.void.cli.operator", account) && !deleteKeyringPassword("dev.void.cli.operator", account)) throw new OperatorClientError("The operator session was revoked, but its local keychain entry could not be removed.", "keychain_unavailable");
+}
+async function readOperatorApiTokenStdin() {
+	if (process.stdin.isTTY) throw new OperatorClientError("--token-stdin requires an API session token piped on standard input.", "invalid_token_input");
+	let input = "";
+	for await (const chunk of process.stdin) {
+		input += String(chunk);
+		if (input.length > 32768) throw new OperatorClientError("API session token input is too large.", "invalid_token_input");
+	}
+	const token = input.trim();
+	if (!token || token.length > 32768 || /\s/.test(token)) throw new OperatorClientError("Standard input must contain one API session token.", "invalid_token_input");
+	return token;
+}
+async function exchangeOperatorSession(origin, apiToken) {
+	const session = await new OperatorClient(origin, apiToken).request("/session", {
+		method: "POST",
+		body: {}
+	});
+	if (typeof session.token !== "string" || !session.token || session.apiVersion !== 1 || typeof session.expiresAt !== "string") throw new OperatorClientError("Operator API returned an invalid session.", "invalid_response");
+	return session;
+}
+//#endregion
+//#region src/cli/operator-cmd.ts
+const MAX_RUNTIME_FOLLOW_ROWS = 1e4;
+function printable(value) {
+	if (value === null || value === void 0) return "—";
+	if (typeof value === "string") return value.replace(/[\u0000-\u001f\u007f]/g, " ");
+	if (typeof value === "object") return JSON.stringify(value);
+	return String(value);
+}
+function table(rows, indent) {
+	if (!rows.length) return [`${indent}(none)`];
+	if (!rows.every((row) => row && typeof row === "object" && !Array.isArray(row))) return rows.map((row) => `${indent}${printable(row)}`);
+	const records = rows;
+	const keys = [...new Set(records.flatMap((row) => Object.keys(row)))].filter((key) => records.some((row) => row[key] !== null && typeof row[key] !== "object"));
+	const preferred = [
+		"id",
+		"name",
+		"login",
+		"email",
+		"slug",
+		"status",
+		"plan",
+		"action",
+		"target",
+		"created_at",
+		"version"
+	];
+	const columns = [...preferred.filter((key) => keys.includes(key)), ...keys.filter((key) => !preferred.includes(key))].slice(0, 7);
+	if (!columns.length) return records.flatMap((row) => humanLines(row, indent));
+	const widths = columns.map((key) => Math.min(64, Math.max(key.length, ...records.map((row) => printable(row[key]).length))));
+	const rowText = (values) => indent + values.map((value, index) => {
+		const width = widths[index];
+		return (value.length > width ? `${value.slice(0, width - 1)}…` : value).padEnd(width);
+	}).join("  ").trimEnd();
+	return [rowText(columns.map((key) => key.toUpperCase())), ...records.map((row) => rowText(columns.map((key) => printable(row[key]))))];
+}
+function eventLines(events, indent) {
+	if (!events.length) return [`${indent}(none)`];
+	return events.flatMap((event, index) => [`${indent}${index + 1}.`, ...humanLines(event, `${indent}  `)]);
+}
+function humanLines(value, indent = "") {
+	if (Array.isArray(value)) return table(value, indent);
+	if (!value || typeof value !== "object") return [`${indent}${printable(value)}`];
+	return Object.entries(value).flatMap(([key, item]) => {
+		const label = key.replaceAll("_", " ").replace(/([a-z])([A-Z])/g, "$1 $2");
+		if (Array.isArray(item)) return [`${indent}${label}:`, ...key === "events" ? eventLines(item, `${indent}  `) : table(item, `${indent}  `)];
+		if (item && typeof item === "object") return [`${indent}${label}:`, ...humanLines(item, `${indent}  `)];
+		return [`${indent}${label}: ${printable(item)}`];
+	});
+}
+function output(value, json) {
+	console.log(json ? JSON.stringify(value) : humanLines(value).join("\n"));
+}
+function outputLogs(result, json) {
+	if (json) {
+		output(result, true);
+		return;
+	}
+	if (Array.isArray(result.lines)) {
+		for (const entry of result.lines) if (entry && typeof entry === "object") {
+			const line = entry;
+			console.log(`${line.ts ? `[${printable(line.ts)}] ` : ""}${printable(line.line ?? line.text ?? entry)}`);
+		} else console.log(printable(entry));
+		if (result.external) console.log(`External build logs: ${printable(result.external)}`);
+		if (result.terminal) console.log(`Build ${printable(result.status ?? "finished")}.`);
+	} else if (Array.isArray(result.data)) {
+		for (const entry of result.data) {
+			if (!entry || typeof entry !== "object") {
+				console.log(printable(entry));
+				continue;
+			}
+			const row = entry;
+			console.log(`${printable(row.timestamp ?? row.ts)} ${printable(row.method)} ${printable(row.url)} ${printable(row.status ?? row.statusCode ?? row.outcome)}`);
+			if (Array.isArray(row.logs)) for (const log of row.logs) if (log && typeof log === "object") {
+				const record = log;
+				console.log(`  ${record.level ? `[${printable(record.level)}] ` : ""}${printable(record.message ?? log)}`);
+			} else console.log(`  ${printable(log)}`);
+			if (Array.isArray(row.exceptions)) for (const exception of row.exceptions) if (exception && typeof exception === "object") {
+				const record = exception;
+				const name = record.name ? `${printable(record.name)}: ` : "";
+				console.log(`  ${name}${printable(record.message ?? exception)}`);
+			} else console.log(`  ${printable(exception)}`);
+		}
+		if (result.nextCursor) console.log(`Next cursor: ${printable(result.nextCursor)}`);
+	} else output(result, false);
+}
+function runtimeLogFingerprint(row) {
+	const ingestedAt = row && typeof row === "object" && !Array.isArray(row) ? row.ingestedAt : void 0;
+	if (!row || typeof row !== "object" || Array.isArray(row) || typeof ingestedAt !== "number" || !Number.isSafeInteger(ingestedAt)) throw new OperatorClientError("Runtime log response has an invalid ingestion cursor.", "invalid_response");
+	return createHash("sha256").update(JSON.stringify(row)).digest("base64url");
+}
+async function confirmOperatorMutation(origin, preview, args) {
+	if (args.plan) {
+		output({
+			origin,
+			...preview
+		}, args.json);
+		return false;
+	}
+	if (!args.json || !args.yes) process.stderr.write(`${JSON.stringify({
+		origin,
+		...preview
+	}, null, 2)}\n`);
+	if (args.yes) return true;
+	if (!process.stdin.isTTY || !process.stderr.isTTY) throw new OperatorClientError("Mutations in non-interactive mode require --yes or --plan.", "confirmation_required");
+	const prompt = createInterface({
+		input: process.stdin,
+		output: process.stderr
+	});
+	try {
+		const answer = await prompt.question(`Apply this change to ${origin}? [y/N] `);
+		if (!/^y(es)?$/i.test(answer.trim())) throw new OperatorClientError("Cancelled.", "cancelled");
+		return true;
+	} finally {
+		prompt.close();
+	}
+}
+async function runAuth(origin, args) {
+	if (args.action === "login" || args.action === "token" && args.tokenStdin) {
+		if (!args.tokenStdin && !process.stdin.isTTY) throw new OperatorClientError("Browser login requires an interactive terminal. Use --token-stdin to exchange an API session.", "interactive_login_required");
+		const session = await exchangeOperatorSession(origin, args.tokenStdin ? await readOperatorApiTokenStdin() : await import("./auth-W9WII-mN.mjs").then((n) => n.t).then(({ runPlatformLogin }) => runPlatformLogin(origin, args.provider, (url) => process.stderr.write(`Sign in at ${url}\n`))));
+		const { token, ...identity } = session;
+		if (args.action === "token") {
+			if (args.json) output({
+				origin,
+				...session
+			}, true);
+			else console.log(token);
+		} else {
+			saveOperatorToken(origin, token);
+			output({
+				origin,
+				...identity
+			}, args.json);
+		}
+		return;
+	}
+	const token = readOperatorToken(origin);
+	const client = new OperatorClient(origin, token);
+	if (args.action === "logout") {
+		try {
+			await client.request("/session/logout", {
+				method: "POST",
+				body: {}
+			});
+		} catch (error) {
+			if (!(error instanceof OperatorClientError) || error.status !== 401) throw error;
+		}
+		removeOperatorToken(origin);
+		output({
+			origin,
+			ok: true,
+			...process.env.VOID_OPERATOR_TOKEN ? { message: "Operator session revoked. Unset VOID_OPERATOR_TOKEN in your shell." } : {}
+		}, args.json);
+	} else {
+		const session = await client.request("/session");
+		if (args.action === "token") {
+			if (args.json) output({
+				origin,
+				token,
+				...session
+			}, true);
+			else console.log(token);
+		} else output({
+			origin,
+			...session
+		}, args.json);
+	}
+}
+/** Poll cursors until interrupted (runtime) or terminal (build), without mutation retries. */
+async function followOperatorLogs(client, args, signal, pollIntervalMs = 2e3) {
+	const controller = new AbortController();
+	const stop = () => controller.abort();
+	process.once("SIGINT", stop);
+	const combined = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
+	const query = { ...args.query };
+	let terminalBuildSince = null;
+	let legacyQuietSince = null;
+	let legacyQuietSeq = null;
+	let previousRuntimeRows = /* @__PURE__ */ new Map();
+	let currentRuntimeRows = /* @__PURE__ */ new Map();
+	let currentRuntimeRowCount = 0;
+	try {
+		while (!combined.aborted) {
+			const result = await client.request(args.path, {
+				query,
+				signal: combined
+			});
+			let visibleResult = result;
+			if (args.group === "deployment") {
+				if (!Array.isArray(result.data)) throw new OperatorClientError("Runtime log response is missing its data rows.", "invalid_response");
+				const data = result.data.filter((row) => {
+					currentRuntimeRowCount++;
+					if (currentRuntimeRowCount > MAX_RUNTIME_FOLLOW_ROWS) throw new OperatorClientError(`Runtime log follow window exceeded ${MAX_RUNTIME_FOLLOW_ROWS} rows. Retry without --follow and query a narrower history.`, "invalid_response");
+					const fingerprint = runtimeLogFingerprint(row);
+					const occurrence = (currentRuntimeRows.get(fingerprint) ?? 0) + 1;
+					currentRuntimeRows.set(fingerprint, occurrence);
+					return occurrence > (previousRuntimeRows.get(fingerprint) ?? 0);
+				});
+				visibleResult = {
+					...result,
+					data
+				};
+			}
+			outputLogs(visibleResult, args.json);
+			if (args.group === "build") {
+				if (typeof result.lastSeq !== "number" || !Number.isSafeInteger(result.lastSeq) || result.lastSeq < Number(query.since ?? 0)) throw new OperatorClientError("Build log response has an invalid cursor.", "invalid_response");
+				const previousSeq = Number(query.since ?? 0);
+				query.since = String(result.lastSeq);
+				if (result.hasMore === true) {
+					if (result.lastSeq === previousSeq) throw new OperatorClientError("Build log pagination did not advance.", "invalid_response");
+					continue;
+				}
+				if (result.logsComplete !== void 0 && result.logsComplete !== null && typeof result.logsComplete !== "boolean") throw new OperatorClientError("Build log response has an invalid completion state.", "invalid_response");
+				if (result.terminal === true) {
+					if (result.logsComplete === true) return;
+					const now = Date.now();
+					terminalBuildSince ??= now;
+					if (now - terminalBuildSince >= 12e4) throw new OperatorClientError("Build finished, but its log producer did not confirm completion. Retry the command to recover the final log tail.", "invalid_response");
+					if (result.logsComplete === null || result.logsComplete === void 0) {
+						if (legacyQuietSeq !== result.lastSeq) {
+							legacyQuietSeq = result.lastSeq;
+							legacyQuietSince = now;
+						} else {
+							legacyQuietSince ??= now;
+							if (now - legacyQuietSince >= 3e4) return;
+						}
+					}
+				} else {
+					terminalBuildSince = null;
+					legacyQuietSince = null;
+					legacyQuietSeq = null;
+				}
+			} else {
+				if (typeof result.nextCursor === "string" && result.nextCursor) {
+					if (result.nextCursor === query.cursor) throw new OperatorClientError("Runtime log pagination did not advance.", "invalid_response");
+					query.cursor = result.nextCursor;
+					continue;
+				}
+				delete query.cursor;
+				if (typeof result.watermark !== "string" && typeof result.watermark !== "number") throw new OperatorClientError("Runtime log response is missing its follow watermark.", "invalid_response");
+				previousRuntimeRows = currentRuntimeRows;
+				currentRuntimeRows = /* @__PURE__ */ new Map();
+				currentRuntimeRowCount = 0;
+				query.after = String(result.watermark);
+				delete query.since;
+			}
+			await setTimeout(pollIntervalMs, void 0, { signal: combined });
+		}
+	} catch (error) {
+		if (!combined.aborted) throw error;
+	} finally {
+		process.removeListener("SIGINT", stop);
+	}
+}
+async function runOperatorCommand(args) {
+	if (!args.action) {
+		const { printHelpPage } = await import("./cli/cli.mjs").then((n) => n.t);
+		printHelpPage(["platform", args.group]);
+		return;
+	}
+	const origin = resolveOperatorOrigin(args.connection);
+	if (args.group === "auth") return runAuth(origin, args);
+	const client = new OperatorClient(origin, readOperatorToken(origin));
+	if (args.method === "POST") {
+		if (!args.plan && !args.yes && (!process.stdin.isTTY || !process.stderr.isTTY)) throw new OperatorClientError("Mutations in non-interactive mode require --yes or --plan.", "confirmation_required");
+		const preview = await client.request(args.path, {
+			method: "POST",
+			body: {
+				...args.body,
+				dryRun: true
+			},
+			timeoutMs: args.timeoutMs
+		});
+		if (preview.dryRun !== true || typeof preview.action !== "string" || !Object.hasOwn(preview, "target")) throw new OperatorClientError("The server did not return a valid mutation preview. No change was requested.", "invalid_preview");
+		if (!await confirmOperatorMutation(origin, preview, args)) return;
+		const body = {
+			...args.body,
+			...args.group === "worker" && args.action === "rollback-all" ? { versions: preview.versions } : {}
+		};
+		output(await client.request(args.path, {
+			method: "POST",
+			body,
+			timeoutMs: args.timeoutMs
+		}), args.json);
+	} else if (args.follow) await followOperatorLogs(client, args);
+	else {
+		const result = await client.request(args.path, { query: args.query });
+		if (args.action === "logs") outputLogs(result, args.json);
+		else output(result, args.json);
+		if (result.allOk === false) process.exitCode = 1;
+	}
+}
+//#endregion
+export { runOperatorCommand };