void 0.10.7 → 0.10.8

package/dist/cli/cli.mjs

@@ -1967,7 +1967,7 @@ else if (command === "domain") runSubcommandGroup("domain", domainSubcommands, p
 else if (command === "db") runSubcommandGroup("db", dbSubcommands, parseDbArgs, (root, parsed) => import("../db-DjKE2-A-.mjs").then(({ runDbCommand }) => runDbCommand(root, parsed)));
 else if (command === "env") runSubcommandGroup("env", envSubcommands, parseEnvArgs, (root, parsed) => import("../env-CO5XAS9t.mjs").then(({ runEnvCommand }) => runEnvCommand(root, parsed)));
 else if (command === "gen") runSubcommandGroup("gen", genSubcommands, parseGenArgs, (root, parsed) => import("../gen-Cf79J4aw.mjs").then(({ runGenCommand }) => runGenCommand(root, parsed)));
-else if (command === "github") runSubcommandGroup("github", githubSubcommands, parseGithubArgs, (root, parsed) => import("../github-cmd-DnqxyOsb.mjs").then(({ runGithubCommand }) => runGithubCommand(root, parsed)));
+else if (command === "github") runSubcommandGroup("github", githubSubcommands, parseGithubArgs, (root, parsed) => import("../github-cmd-B6OX9c7d.mjs").then(({ runGithubCommand }) => runGithubCommand(root, parsed)));
 else if (command === "build") runSubcommandGroup("build", buildSubcommands, parseBuildArgs, (root, parsed) => import("../build-cmd-Br8qL0rA.mjs").then(({ runBuildCommand }) => runBuildCommand(root, parsed)));
 else if (command === "prepare") {
 	const root = process.cwd();
@@ -2103,7 +2103,7 @@ else if (command === "-v" || command === "--version") {
 			case "project": return runSubcommandGroup("project", projectSubcommands, parseProjectArgs, (r, p) => import("../project-cmd-DnU7u9QF.mjs").then(({ runProjectCommand }) => runProjectCommand(r, p)));
 			case "secret": return runSubcommandGroup("secret", secretSubcommands, parseSecretArgs, (r, p) => import("../secret-u7FRvg8d.mjs").then(({ runSecretCommand }) => runSecretCommand(r, p)));
 			case "domain": return runSubcommandGroup("domain", domainSubcommands, parseDomainArgs, (r, p) => import("../domain-_luIsM_B.mjs").then(({ runDomainCommand }) => runDomainCommand(r, p)));
-			case "github": return runSubcommandGroup("github", githubSubcommands, parseGithubArgs, (r, p) => import("../github-cmd-DnqxyOsb.mjs").then(({ runGithubCommand }) => runGithubCommand(r, p)));
+			case "github": return runSubcommandGroup("github", githubSubcommands, parseGithubArgs, (r, p) => import("../github-cmd-B6OX9c7d.mjs").then(({ runGithubCommand }) => runGithubCommand(r, p)));
 			case "build": return runSubcommandGroup("build", buildSubcommands, parseBuildArgs, (r, p) => import("../build-cmd-Br8qL0rA.mjs").then(({ runBuildCommand }) => runBuildCommand(r, p)));
 			case "db": return runSubcommandGroup("db", dbSubcommands, parseDbArgs, (r, p) => import("../db-DjKE2-A-.mjs").then(({ runDbCommand }) => runDbCommand(r, p)));
 			case "env": return runSubcommandGroup("env", envSubcommands, parseEnvArgs, (r, p) => import("../env-CO5XAS9t.mjs").then(({ runEnvCommand }) => runEnvCommand(r, p)));

package/dist/{github-cmd-DnqxyOsb.mjs → github-cmd-B6OX9c7d.mjs}

@@ -187,35 +187,38 @@ async function runGithubLink(root, client) {
 	else log.success("GitHub account linked.");
 }
 /**
-* Discover and join the shared GitHub App installations owned by the
-* organizations the logged-in GitHub identity belongs to. Drives the same
-* 3-endpoint localhost + PKCE handshake as {@link runGithubLink}, but against
-* the platform's JOIN routes: membership upsert is idempotent, so unlike link
-* there is no 409/already-linked conflict to map. The only special error is the
-* fail-closed 503 raised when org-installation sharing is not configured on the
-* instance.
+* Browser round-trip (localhost + PKCE) that joins the caller to their
+* organization's shared GitHub App installations. Returns the number of
+* installations joined. Throws PlatformApiError — including the 503
+* `github_oauth_not_configured` — so callers own the user-facing handling
+* (`runGithubJoin` prints and exits; the connect auto-join fallback falls
+* through to its install-first error).
 */
-async function runGithubJoin(root, client) {
+async function performGithubJoin(client) {
 	const verifier = createCodeVerifier();
 	const challenge = createCodeChallenge(verifier);
 	const state = randomBytes(32).toString("hex");
+	const { count } = await awaitBrowserCallback({
+		state,
+		buildAuthUrl: async (callback) => {
+			callback.searchParams.set("state", state);
+			const { url } = await client.getGithubJoinUrl(callback.href, challenge);
+			return url;
+		},
+		describeError: (p) => p.get("error") ? "GitHub authorization failed." : null,
+		onUrl: (url) => log.message(`Open this URL to join your organization's shared GitHub App installations:\n${import_picocolors.default.cyan(url)}`),
+		finalize: async (params) => {
+			const joinCode = params.get("join_code");
+			if (!joinCode) throw new Error("github: join callback did not return a join code.");
+			return client.completeGithubJoin(joinCode, verifier);
+		}
+	});
+	return count;
+}
+async function runGithubJoin(root, client) {
 	let count;
 	try {
-		({count} = await awaitBrowserCallback({
-			state,
-			buildAuthUrl: async (callback) => {
-				callback.searchParams.set("state", state);
-				const { url } = await client.getGithubJoinUrl(callback.href, challenge);
-				return url;
-			},
-			describeError: (p) => p.get("error") ? "GitHub authorization failed." : null,
-			onUrl: (url) => log.message(`Open this URL to join your organization's shared GitHub App installations:\n${import_picocolors.default.cyan(url)}`),
-			finalize: async (params) => {
-				const joinCode = params.get("join_code");
-				if (!joinCode) throw new Error("github: join callback did not return a join code.");
-				return client.completeGithubJoin(joinCode, verifier);
-			}
-		}));
+		count = await performGithubJoin(client);
 	} catch (err) {
 		if (err instanceof PlatformApiError && err.status === 503 && err.code === "github_oauth_not_configured") {
 			log.error("Organization installation sharing is not enabled on this Void instance.");
@@ -281,6 +284,26 @@ async function runGithubConnectAuthorize(client, installationId, repoFullName) {
 		codeVerifier: verifier
 	};
 }
+/**
+* Free-text repository prompt used when the installation's repository list is
+* not enumerable client-side: `repository_selection === 'all'`, or a shared
+* org installation whose list the server redacts for non-owner members. The
+* server re-verifies actual access on connect, so this is DX, not security.
+*/
+async function promptRepoFullName(root) {
+	const gitDefault = parseGithubRepoFullName(collectGitDeployMetadata(root, null).repositoryUrl);
+	const input = await text({
+		message: "Repository (owner/repo):",
+		placeholder: gitDefault ?? "owner/repo",
+		initialValue: gitDefault ?? "",
+		validate: (value) => /^[^/\s]+\/[^/\s]+$/.test((value ?? "").trim()) ? void 0 : "Enter the repository as owner/repo."
+	});
+	if (isCancel(input)) {
+		cancel("Cancelled.");
+		process.exit(0);
+	}
+	return input.trim();
+}
 async function runConnect(root, client, args) {
 	const isTTY = process.stdin.isTTY === true;
 	let projectId;
@@ -318,14 +341,36 @@ async function runConnect(root, client, args) {
 			projectId = picked;
 		}
 	}
-	const installations = (await client.listGithubInstallations()).filter((i) => i.status === "active");
+	const listActiveInstallations = async () => (await client.listGithubInstallations()).filter((i) => i.status === "active");
+	let autoJoinAttempted = false;
+	const attemptAutoJoin = async () => {
+		autoJoinAttempted = true;
+		try {
+			return await performGithubJoin(client);
+		} catch (err) {
+			if (err instanceof PlatformApiError && err.status === 503 && err.code === "github_oauth_not_configured") return 0;
+			throw err;
+		}
+	};
+	let installations = await listActiveInstallations();
+	if (installations.length === 0 && isTTY) {
+		log.info("No GitHub App installation is linked to your account yet — checking whether your organization already installed the Void GitHub App…");
+		if (await attemptAutoJoin() > 0) installations = await listActiveInstallations();
+	}
 	if (installations.length === 0) {
-		log.error("No active GitHub App installation. Run `void github install` first.");
+		log.error(isTTY ? "No GitHub App installation found for your account or your organizations. Run `void github install` first." : "No active GitHub App installation. Run `void github install` first, or `void github join` if your organization already installed the Void GitHub App.");
 		process.exit(1);
 	}
 	let installation;
 	if (args.installationId) {
-		const found = installations.find((i) => i.installation_id === args.installationId);
+		let found = installations.find((i) => i.installation_id === args.installationId);
+		if (!found && isTTY && !autoJoinAttempted) {
+			log.info(`Installation '${args.installationId}' is not linked to your account yet — checking whether your organization shares it…`);
+			if (await attemptAutoJoin() > 0) {
+				installations = await listActiveInstallations();
+				found = installations.find((i) => i.installation_id === args.installationId);
+			}
+		}
 		if (!found) {
 			log.error(`connect: No active installation found with id '${args.installationId}'.`);
 			process.exit(1);
@@ -352,8 +397,11 @@ async function runConnect(root, client, args) {
 	let repoFullName;
 	if (args.repo) repoFullName = args.repo;
 	else if (installation.repository_selection === "selected") if (installation.repositories.length === 0) {
-		log.error("connect: The installation has no accessible repositories. Update the GitHub App install to grant access.");
-		process.exit(1);
+		if (!isTTY) {
+			log.error("connect: --repo <owner/repo> is required — this installation does not expose a repository list to your account.");
+			process.exit(1);
+		}
+		repoFullName = await promptRepoFullName(root);
 	} else if (installation.repositories.length === 1) repoFullName = installation.repositories[0].full_name;
 	else if (!isTTY) {
 		log.error("connect: Multiple repositories available. Pass --repo <owner/repo>.");
@@ -377,21 +425,7 @@ async function runConnect(root, client, args) {
 			log.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 text({
-			message: "Repository (owner/repo):",
-			placeholder: gitDefault ?? "owner/repo",
-			initialValue: gitDefault ?? ""
-		});
-		if (isCancel(input)) {
-			cancel("Cancelled.");
-			process.exit(0);
-		}
-		repoFullName = input.trim();
-		if (!repoFullName) {
-			log.error("connect: Repository is required.");
-			process.exit(1);
-		}
+		repoFullName = await promptRepoFullName(root);
 	}
 	const branchDefault = args.branch ?? collectGitDeployMetadata(root, null).gitRef ?? "main";
 	let branch;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "void",
-  "version": "0.10.7",
+  "version": "0.10.8",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/voidzero-dev/void.git",
@@ -353,7 +353,7 @@
     "valibot": ">=1.0.0-beta.7",
     "vite": "^8.0.0",
     "zod": "^3.25.0 || ^4.0.0",
-    "@void/md": "0.10.7"
+    "@void/md": "0.10.8"
   },
   "peerDependenciesMeta": {
     "@void/md": {

package/skills/void/docs/reference/cli.md

@@ -609,6 +609,8 @@ void github join
 
 Join the GitHub App installations your organization already has. If a teammate installed the Void GitHub App on a shared GitHub organization, run `void github join` to gain access to those installations without re-installing. Void opens your browser to authorize (a localhost + PKCE handshake, the same mechanics as `void github link`), confirms with GitHub which installations you can manage, and records your membership. Afterwards `void github installations` lists them and `void github connect` can connect your own projects to their repositories.
 
+In an interactive terminal you rarely need to run this yourself — `void github connect` runs the same join automatically when no active installations are linked to your account. Running `void github join` yourself matters mainly for non-interactive use (without a TTY, `void github connect` never opens a browser), or to link installations ahead of time.
+
 Requires an authenticated CLI (`void auth login` first) and organization-installation sharing enabled on your Void instance; when it is not enabled the command fails closed with a clear message. You can only join installations your GitHub authorization actually returns — you cannot name or join one you cannot access on GitHub.
 
 ### `void github connect`
@@ -619,6 +621,8 @@ void github connect [project] [options]
 
 Connect a GitHub repository to a Void project for automatic deploys. On every push to the configured branch, Void builds and deploys your project automatically.
 
+Interactively (TTY), if your account has no active installations linked, `void github connect` first runs the same browser authorize as `void github join` automatically — if a teammate already installed the Void GitHub App on your organization, you join it on the spot and the connect continues. Only when no shared installation is found does it ask you to run `void github install`. The same recovery runs when `--installation <id>` names an installation your account is not linked to yet. Without a TTY, connect never opens a browser: it fails closed and tells you to run `void github install`, or `void github join` if your organization already installed the App.
+
 **Options**
 
 | Flag                  | Description                                                                       |
@@ -636,7 +640,7 @@ Interactively (TTY), after resolving the repository and branch, `void github con
 
 **Non-interactive use (CI)**
 
-When stdin is not a TTY, `void github connect` never prompts — it fails closed and names any flag it needs. `--branch` is always required. `--project` must be resolvable (positional / `--project` / `VOID_PROJECT` / linked `.void/project.json`). `--installation` is required only when your account has more than one installation; otherwise the sole installation is used. `--repo` is required when the installation grants access to all repos or to more than one selected repo; when it grants exactly one repo that repo is used automatically. Use `void github installations` to discover the `installation_id`.
+When stdin is not a TTY, `void github connect` never prompts — it fails closed and names any flag it needs. `--branch` is always required. `--project` must be resolvable (positional / `--project` / `VOID_PROJECT` / linked `.void/project.json`). `--installation` is required only when your account has more than one installation; otherwise the sole installation is used. `--repo` is required when the installation grants access to all repos or to more than one selected repo; when it grants exactly one repo that repo is used automatically. `--repo` is also required when the installation does not expose a repository list to your account (shared org installations hide it). Use `void github installations` to discover the `installation_id`.
 
 ```
 void github connect my-app \
@@ -649,7 +653,7 @@ void github connect my-app \
 
 **Connecting as an organization member**
 
-If you are a member of a GitHub organization but not the person who installed the App, `void github connect` first confirms that you personally have access to the specific repository. When it detects this, it opens your browser once to authorize access to that repo on GitHub (a localhost + PKCE handshake), then completes the connection automatically — no extra flags. Run `void github join` first so the installation appears in `void github installations`. You can only connect repositories you can access on GitHub; one you cannot see is refused with a clear message.
+If you are a member of a GitHub organization but not the person who installed the App, `void github connect` first confirms that you personally have access to the specific repository. Interactively (TTY), when it detects this it opens your browser once to authorize access to that repo on GitHub (a localhost + PKCE handshake), then completes the connection automatically — no extra flags. Without a TTY, this per-repo authorization never opens a browser: connect fails closed with an error explaining that the installation requires per-repo authorization, which needs an interactive browser sign-in, and telling you to run `void github connect` locally to authorize, then retry. Interactively, connect joins the shared installation automatically when your account has no active installations linked, so running `void github join` first is optional — useful mainly to see the installation in `void github installations` beforehand. You can only connect repositories you can access on GitHub; one you cannot see is refused with a clear message.
 
 ### `void github update`