void 0.9.2 → 0.10.1

package/dist/github-cmd-CUB041gj.mjs

@@ -0,0 +1,308 @@
+import { s as import_picocolors } from "./output-DeiS4oEX.mjs";
+import { c as createCodeChallenge, d as getToken, l as createCodeVerifier, m as openBrowser, n as PlatformClient, o as parsePlatformErrorBody, s as awaitBrowserCallback, t as PlatformApiError } from "./client-D4awzTnj.mjs";
+import { _ as me, c as R, i as Ee, l as Re, x as q } from "./dist-abzUneor.mjs";
+import { r as readProjectConfig } from "./project-CH9pdo16.mjs";
+import { r as resolveProjectBySlug, t as getRequestedProjectSlug } from "./resolve-project-D4O1_fZz.mjs";
+import { t as collectGitDeployMetadata } from "./git-metadata-Ce0AtSZL.mjs";
+import { randomBytes } from "node:crypto";
+//#region src/cli/github-cmd.ts
+/**
+* Map a PlatformApiError status + error code string to a friendly user message.
+* Returns null for unrecognised cases (caller should re-throw).
+*/
+function describeConnectError(status, errorCode) {
+	const code = errorCode ?? "";
+	if (status === 409) {
+		if (code.includes("already connected")) return "This project is already connected to a GitHub repository.";
+		if (code.includes("not active")) return "Installation is not active. Re-install the GitHub App and try again.";
+	}
+	if (status === 400 && code.includes("not accessible")) return "Repository not accessible by this installation. Check the App has access to it.";
+	if (status === 403) return "You don't have access to this project.";
+	if (status === 404) return "Project or installation not found.";
+	return null;
+}
+/**
+* Extract `owner/repo` from a `https://github.com/owner/repo(.git)?` URL.
+* Returns null for non-GitHub URLs or null input.
+*/
+function parseGithubRepoFullName(repositoryUrl) {
+	if (!repositoryUrl) return null;
+	try {
+		const url = new URL(repositoryUrl);
+		if (url.hostname !== "github.com") return null;
+		const parts = url.pathname.replace(/^\//, "").replace(/\.git$/, "").split("/");
+		if (parts.length < 2 || !parts[0] || !parts[1]) return null;
+		return `${parts[0]}/${parts[1]}`;
+	} catch {
+		return null;
+	}
+}
+/**
+* Format a list of GitHub App installations into a human-readable string.
+* One block per installation:
+*   account_login (account_type) — selection, N repos, status
+*   [repo list for 'selected' installs]
+*/
+function formatInstallations(installations) {
+	return installations.map((inst) => {
+		const header = `${inst.account_login} (${inst.account_type}) [id: ${inst.installation_id}] — ${inst.repository_selection}, ${inst.repositories.length} repos, ${inst.status}`;
+		if (inst.repository_selection === "selected" && inst.repositories.length > 0) return `${header}\n${inst.repositories.map((r) => `  • ${r.full_name}`).join("\n")}`;
+		return header;
+	}).join("\n\n");
+}
+async function runGithubCommand(root, args) {
+	const token = getToken(root);
+	if (!token) {
+		R.error("Not logged in. Run `void auth login` first.");
+		process.exit(1);
+	}
+	const client = new PlatformClient(token, { root });
+	switch (args.subcommand) {
+		case "install": return runInstall(root, client);
+		case "installations": return runInstallations(client);
+		case "connect": return runConnect(root, client, args);
+		case "link": return runGithubLink(root, client);
+	}
+}
+/**
+* `void github install` — print the GitHub App install URL and open it.
+*
+* If the account has no linked GitHub identity, the server returns a 403 with
+* the stable code `github_identity_required` (Task 3). Rather than telling the
+* user to `void auth login` (which risks forking into a second account), we run
+* the link flow inline and retry the install URL exactly once.
+*
+* `linkIdentity` is injectable so tests can supply a fake linker instead of
+* starting a real localhost callback server / browser.
+*/
+async function runInstall(root, client, linkIdentity = runGithubLink) {
+	let url;
+	try {
+		({url} = await client.getGithubInstallUrl());
+	} catch (err) {
+		if (err instanceof PlatformApiError && err.status === 403 && err.code === "github_identity_required") {
+			R.message("Your Void account needs a linked GitHub identity. Starting the GitHub link…");
+			await linkIdentity(root, client);
+			try {
+				({url} = await client.getGithubInstallUrl());
+			} catch (retryErr) {
+				if (retryErr instanceof PlatformApiError && retryErr.status === 403 && retryErr.code === "github_identity_required") {
+					R.error("Could not start the GitHub App install after linking. Try `void github link`, then `void github install` again.");
+					process.exit(1);
+				}
+				throw retryErr;
+			}
+		} else throw err;
+	}
+	R.message(`Open this URL to install the Void GitHub App:\n${import_picocolors.default.cyan(url)}`);
+	const { execFile } = await import("node:child_process");
+	openBrowser(url, execFile);
+	R.message("After installing, run `void github connect` to link a repository to your project.");
+}
+/**
+* Link the current Void account (the logged-in CLI token holder) to a GitHub
+* identity. Drives the platform's 3-endpoint link flow with a localhost +
+* PKCE handshake, mirroring `void auth login`.
+*
+* Exported so Task 5 can call it (e.g. when `github install` returns 403 for a
+* GitHub-less account, prompt to link and retry). The success path is
+* non-exiting so a caller can continue; only error paths exit/throw.
+*/
+async function runGithubLink(root, client) {
+	const verifier = createCodeVerifier();
+	const challenge = createCodeChallenge(verifier);
+	const state = randomBytes(32).toString("hex");
+	let status;
+	try {
+		({status} = await awaitBrowserCallback({
+			state,
+			buildAuthUrl: async (callback) => {
+				callback.searchParams.set("state", state);
+				const { url } = await client.getGithubLinkUrl(callback.href, challenge);
+				return url;
+			},
+			describeError: (p) => p.get("error") ? "GitHub authorization failed." : null,
+			onUrl: (url) => R.message(`Open this URL to link your GitHub account:\n${import_picocolors.default.cyan(url)}`),
+			finalize: async (params) => {
+				const linkCode = params.get("link_code");
+				if (!linkCode) throw new Error("github: link callback did not return a link code.");
+				return client.completeGithubLink(linkCode, verifier);
+			}
+		}));
+	} catch (err) {
+		if (err instanceof PlatformApiError && err.code === "github_already_linked") {
+			R.error("Your Void account is already linked to a different GitHub account.");
+			process.exit(1);
+		}
+		if (err instanceof PlatformApiError && (err.status === 409 || err.code === "github_identity_conflict")) {
+			R.error("This GitHub account is already linked to another Void account.");
+			process.exit(1);
+		}
+		throw err;
+	}
+	if (status === "already_linked") R.success("GitHub account already linked.");
+	else R.success("GitHub account linked.");
+}
+async function runInstallations(client) {
+	const installations = await client.listGithubInstallations();
+	if (installations.length === 0) {
+		R.info("No GitHub App installations. Run `void github install` first.");
+		return;
+	}
+	R.message(formatInstallations(installations));
+}
+async function runConnect(root, client, args) {
+	const isTTY = process.stdin.isTTY === true;
+	let projectId;
+	const requestedSlug = getRequestedProjectSlug({ projectSlug: args.projectName || void 0 });
+	if (requestedSlug) {
+		const resolved = resolveProjectBySlug(await client.listProjects(), requestedSlug);
+		if (!resolved) {
+			R.error(`connect: No project found with slug '${requestedSlug}'.`);
+			process.exit(1);
+		}
+		projectId = resolved.projectId;
+	} else {
+		const linked = readProjectConfig(root);
+		if (linked) projectId = linked.projectId;
+		else if (!isTTY) {
+			R.error("connect: No project specified. Pass a project name or --project <name>, set VOID_PROJECT, or link one with `void project link`.");
+			process.exit(1);
+		} else {
+			const projects = await client.listProjects();
+			if (projects.length === 0) {
+				R.error("No projects found. Create one first with `void deploy`.");
+				process.exit(1);
+			}
+			const picked = await Ee({
+				message: "Select a project:",
+				options: projects.map((p) => ({
+					value: p.id,
+					label: p.slug
+				}))
+			});
+			if (q(picked)) {
+				me("Cancelled.");
+				process.exit(0);
+			}
+			projectId = picked;
+		}
+	}
+	const installations = (await client.listGithubInstallations()).filter((i) => i.status === "active");
+	if (installations.length === 0) {
+		R.error("No active GitHub App installation. Run `void github install` first.");
+		process.exit(1);
+	}
+	let installation;
+	if (args.installationId) {
+		const found = installations.find((i) => i.installation_id === args.installationId);
+		if (!found) {
+			R.error(`connect: No active installation found with id '${args.installationId}'.`);
+			process.exit(1);
+		}
+		installation = found;
+	} else if (installations.length === 1) installation = installations[0];
+	else if (!isTTY) {
+		R.error("connect: Multiple installations found. Pass --installation <id>.");
+		process.exit(1);
+	} else {
+		const picked = await Ee({
+			message: "Select a GitHub App installation:",
+			options: installations.map((i) => ({
+				value: i.installation_id,
+				label: `${i.account_login} (${i.account_type}) [id: ${i.installation_id}]`
+			}))
+		});
+		if (q(picked)) {
+			me("Cancelled.");
+			process.exit(0);
+		}
+		installation = installations.find((i) => i.installation_id === picked);
+	}
+	let repoFullName;
+	if (args.repo) repoFullName = args.repo;
+	else if (installation.repository_selection === "selected") if (installation.repositories.length === 0) {
+		R.error("connect: The installation has no accessible repositories. Update the GitHub App install to grant access.");
+		process.exit(1);
+	} else if (installation.repositories.length === 1) repoFullName = installation.repositories[0].full_name;
+	else if (!isTTY) {
+		R.error("connect: Multiple repositories available. Pass --repo <owner/repo>.");
+		process.exit(1);
+	} else {
+		const picked = await Ee({
+			message: "Select a repository:",
+			options: installation.repositories.map((r) => ({
+				value: r.full_name,
+				label: r.full_name
+			}))
+		});
+		if (q(picked)) {
+			me("Cancelled.");
+			process.exit(0);
+		}
+		repoFullName = picked;
+	}
+	else {
+		if (!isTTY) {
+			R.error("connect: --repo <owner/repo> is required in non-interactive mode for an all-repositories installation.");
+			process.exit(1);
+		}
+		const gitDefault = parseGithubRepoFullName(collectGitDeployMetadata(root, null).repositoryUrl);
+		const input = await Re({
+			message: "Repository (owner/repo):",
+			placeholder: gitDefault ?? "owner/repo",
+			initialValue: gitDefault ?? ""
+		});
+		if (q(input)) {
+			me("Cancelled.");
+			process.exit(0);
+		}
+		repoFullName = input.trim();
+		if (!repoFullName) {
+			R.error("connect: Repository is required.");
+			process.exit(1);
+		}
+	}
+	const branchDefault = args.branch ?? collectGitDeployMetadata(root, null).gitRef ?? "main";
+	let branch;
+	if (args.branch) branch = args.branch;
+	else if (!isTTY) {
+		R.error("connect: --branch is required in non-interactive mode. Pass --branch <name>.");
+		process.exit(1);
+	} else {
+		const input = await Re({
+			message: "Branch to deploy from:",
+			placeholder: branchDefault,
+			initialValue: branchDefault
+		});
+		if (q(input)) {
+			me("Cancelled.");
+			process.exit(0);
+		}
+		branch = input.trim() || branchDefault;
+	}
+	const executor = args.executor ?? "container";
+	try {
+		await client.connectGithub(projectId, {
+			installationId: installation.installation_id,
+			repoFullName,
+			branch,
+			buildExecutor: executor
+		});
+	} catch (err) {
+		if (err instanceof PlatformApiError) {
+			const body = parsePlatformErrorBody(err.body);
+			const code = body?.error ?? body?.message ?? "";
+			const message = describeConnectError(err.status, code);
+			if (message !== null) {
+				R.error(`connect: ${message}`);
+				process.exit(1);
+			}
+			throw err;
+		}
+		throw err;
+	}
+	R.success(`Connected ${repoFullName} (${branch}) → project. Push to ${branch} to deploy.`);
+}
+//#endregion
+export { runGithubCommand };

package/dist/{handler-xflsMwWM.d.mts → handler-DczZlaXR.d.mts}

@@ -1,6 +1,6 @@
-import { n as HeadDescriptor } from "./head-BsSTGnIe.mjs";
-import { r as AuthUser, t as AuthSession } from "./auth-CDeb2XAl.mjs";
-import { t as StandardSchemaV1 } from "./standard-schema-Dnsh2vnl.mjs";
+import { n as HeadDescriptor } from "./head-JAH2l3fg.mjs";
+import { r as AuthUser, t as AuthSession } from "./auth-nEUVHuFI.mjs";
+import { t as StandardSchemaV1 } from "./standard-schema-BCBv-QaP.mjs";
 import * as _$_cloudflare_sandbox0 from "@cloudflare/sandbox";
 import { Context, Env, MiddlewareHandler } from "hono";
 import { RewriteDestination } from "void/routes";
@@ -162,6 +162,17 @@ declare module "hono" {
 type CloudContext = Context<CloudEnv>;
 type HandlerFn = (c: CloudContext) => unknown | Promise<unknown>;
 type MiddlewareFn = MiddlewareHandler<CloudEnv>;
+type BasicAuthOptionValue = string | (() => string);
+interface BasicAuthOptions {
+  /** Username required by the Basic auth challenge. */
+  username: BasicAuthOptionValue;
+  /** Password required by the Basic auth challenge. */
+  password: BasicAuthOptionValue;
+  /** Browser prompt realm. Defaults to "Restricted". */
+  realm?: BasicAuthOptionValue;
+  /** Response body for failed authentication. Defaults to "Authentication required". */
+  message?: BasicAuthOptionValue;
+}
 /** Pre-rendered asset tags injected by the SSR build. */
 type RenderAssetTags = {
   /** CSS stylesheet links for `<head>`. */css: string; /** JS modulepreload links for `<head>` (only when page needs JS). */
@@ -243,6 +254,15 @@ declare namespace defineHandler {
 */
 declare function defineMiddleware(handler: MiddlewareHandler<CloudEnv>): MiddlewareHandler<CloudEnv>;
 /**
+* Create Basic authentication middleware for temporary site gates and
+* pre-launch protection.
+*
+* Void internal endpoints under `/__void` are always excluded so deploy-time
+* migrations, prerendering, cron/queue dispatch, and remote binding helpers
+* continue to reach Void's own internal-token checks.
+*/
+declare function basicAuth(options: BasicAuthOptions): MiddlewareHandler<CloudEnv>;
+/**
 * Identity function that provides type inference for scheduled jobs.
 * At runtime it simply returns the function passed to it.
 */
@@ -263,4 +283,4 @@ declare function defineHead<P = Record<string, unknown>>(handler: (c: CloudConte
 */
 declare function defineQueue<T = unknown>(handler: QueueFn<T>): TypedQueueHandler<T>;
 //#endregion
-export { HandlerInput as C, ValidationError as S, runValidation as T, defineScheduled as _, QueueBatch as a, InferProps as b, RenderAssetTags as c, VoidAssetRewriteError as d, defineHandler as f, defineRender as g, defineQueue as h, CloudEnv as i, TypedHandler as l, defineMiddleware as m, CloudContext as n, QueueMessage as o, defineHead as p, CloudContextVariables as r, QueueRetryOptions as s, CloudBindings as t, TypedQueueHandler as u, Deferred as v, ValidatorSlots as w, defer as x, DeferredState as y };
+export { defer as C, runValidation as D, ValidatorSlots as E, InferProps as S, HandlerInput as T, defineQueue as _, CloudEnv as a, Deferred as b, QueueRetryOptions as c, TypedQueueHandler as d, VoidAssetRewriteError as f, defineMiddleware as g, defineHead as h, CloudContextVariables as i, RenderAssetTags as l, defineHandler as m, CloudBindings as n, QueueBatch as o, basicAuth as p, CloudContext as r, QueueMessage as s, BasicAuthOptions as t, TypedHandler as u, defineRender as v, ValidationError as w, DeferredState as x, defineScheduled as y };

package/dist/{headers-Y0jshugF.mjs → headers-BNWymgnH.mjs}

@@ -1,6 +1,6 @@
 import { a as join } from "./pathe.M-eThtNZ-BrPhGF_K.mjs";
-import { a as convertRedirectsConfig, d as parseHostPrefixedSource, i as convertHeadersConfig, o as convertRewritesConfig, r as convertFallbacksConfig, s as countSplats, t as VALID_REDIRECT_STATUSES, u as isProtocolRelative } from "./config-BVEC0lti.mjs";
-import { i as voidWarn } from "./log-CWWZV4V1.mjs";
+import { a as convertRedirectsConfig, d as parseHostPrefixedSource, i as convertHeadersConfig, o as convertRewritesConfig, r as convertFallbacksConfig, s as countSplats, t as VALID_REDIRECT_STATUSES, u as isProtocolRelative } from "./config-8dLIngKW.mjs";
+import { i as voidWarn } from "./log-BdD_Fpms.mjs";
 import { existsSync, readFileSync } from "node:fs";
 //#region src/cli/headers.ts
 /**

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-import { n as HeadDescriptor } from "./head-BsSTGnIe.mjs";
-import { r as AuthUser } from "./auth-CDeb2XAl.mjs";
-import { C as HandlerInput, _ as defineScheduled, a as QueueBatch, b as InferProps, c as RenderAssetTags, d as VoidAssetRewriteError, f as defineHandler, g as defineRender, h as defineQueue, i as CloudEnv, l as TypedHandler, m as defineMiddleware, n as CloudContext, o as QueueMessage, p as defineHead, r as CloudContextVariables, s as QueueRetryOptions, u as TypedQueueHandler, v as Deferred, w as ValidatorSlots, x as defer, y as DeferredState } from "./handler-xflsMwWM.mjs";
+import { n as HeadDescriptor } from "./head-JAH2l3fg.mjs";
+import { r as AuthUser } from "./auth-nEUVHuFI.mjs";
+import { C as defer, E as ValidatorSlots, S as InferProps, T as HandlerInput, _ as defineQueue, a as CloudEnv, b as Deferred, c as QueueRetryOptions, d as TypedQueueHandler, f as VoidAssetRewriteError, g as defineMiddleware, h as defineHead, i as CloudContextVariables, l as RenderAssetTags, m as defineHandler, o as QueueBatch, p as basicAuth, r as CloudContext, s as QueueMessage, t as BasicAuthOptions, u as TypedHandler, v as defineRender, x as DeferredState, y as defineScheduled } from "./handler-DczZlaXR.mjs";
 import { QueueMap } from "./runtime/queues.mjs";
 import { PluginConfig } from "@cloudflare/vite-plugin";
 import { Plugin } from "vite";
@@ -29,4 +29,4 @@ declare function voidPlugin(options?: {
   auxiliaryWorkers?: PluginConfig["auxiliaryWorkers"];
 }): Array<Plugin>;
 //#endregion
-export { type AuthUser, type CloudContext, type CloudContextVariables, type CloudEnv, type Deferred, type DeferredState, type HandlerInput, type HeadDescriptor, type InferProps, type QueueBatch, type QueueMap, type QueueMessage, type QueueRetryOptions, type RenderAssetTags, type TypedHandler, type TypedQueueHandler, type ValidatorSlots, VoidAssetRewriteError, defer, defineHandler, defineHead, defineMiddleware, defineQueue, defineRender, defineScheduled, voidPlugin };
+export { type AuthUser, type BasicAuthOptions, type CloudContext, type CloudContextVariables, type CloudEnv, type Deferred, type DeferredState, type HandlerInput, type HeadDescriptor, type InferProps, type QueueBatch, type QueueMap, type QueueMessage, type QueueRetryOptions, type RenderAssetTags, type TypedHandler, type TypedQueueHandler, type ValidatorSlots, VoidAssetRewriteError, basicAuth, defer, defineHandler, defineHead, defineMiddleware, defineQueue, defineRender, defineScheduled, voidPlugin };