@hitch42/applet 0.1.1-beta.20 → 0.1.1-beta.21

package/dist/git-deploy-C12nMNB6.js

@@ -0,0 +1,290 @@
+import { m as resolveInstanceUrl } from "./store-E5NhITHl.js";
+import { a as findWorkspaceRoot, o as isRootLayout, r as findParentRoot, t as SDK_VERSION_PATTERN } from "./workspace-CtIKSgMD.js";
+import { i as withOrgAuth } from "./auth-DuMRqSGe.js";
+import { n as ORG_CODE_PATTERN, t as APPLET_CODE_PATTERN } from "./manifest-patterns-BfxqImlp.js";
+import { n as gitEnvironment } from "./source-hash-BbvtRaus.js";
+import { n as stagedSecretPaths, t as StagedSecretsError } from "./git-safety-Ck3X7jvA.js";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+// src/git-deploy.ts
+const execFileAsync = promisify(execFile);
+function hitchRemoteUrl(organizationUrl, code) {
+	return `${organizationUrl}/api/git/${code}.git`;
+}
+async function runClone(name, directory, _message) {
+	const parts = name.split("/");
+	const [org, code] = parts;
+	if (parts.length !== 2 || !org || !code || !ORG_CODE_PATTERN.test(org) || !APPLET_CODE_PATTERN.test(code)) throw new Error("Use applet clone <org>/<code> [dir].");
+	const cwd = process.cwd();
+	const parent = findParentRoot(cwd);
+	if (findWorkspaceRoot(cwd) !== void 0 && parent !== cwd) throw new Error("Run applet clone outside an applet repo, or in a .hitchroot parent.");
+	const base = parent ?? cwd;
+	const target = directory === void 0 ? resolve(base, code) : resolve(directory);
+	await withOrgAuth(org, async (organizationUrl, token) => {
+		try {
+			await gitWithAuth(base, org, organizationUrl, token, [
+				"clone",
+				"--origin",
+				"hitch",
+				hitchRemoteUrl(organizationUrl, code),
+				target
+			]);
+			return { unauthorized: false };
+		} catch (error) {
+			const message = gitError(error);
+			if (/401|Authentication failed|HTTP Basic: Access denied/i.test(message)) return { unauthorized: true };
+			throw new Error(message, { cause: error });
+		}
+	});
+	const clonedRoot = resolve(target);
+	await configureGitCredentialHelper(clonedRoot, org);
+	if (!await git(clonedRoot, [
+		"rev-parse",
+		"--verify",
+		"HEAD"
+	]).then(() => true).catch(() => false)) console.log("The applet has no code in Hitch yet.");
+	console.log(`Cloned ${code} into ${target}. Run applet deploy -m "..." to deploy changes.`);
+	const rootLayout = isRootLayout(clonedRoot);
+	const sdk = await readFile(resolve(clonedRoot, rootLayout ? "applet.manifest.ts" : "hitch.config.ts"), "utf8").then((text) => /\bsdk:\s*["']([^"'\s]+)["']/.exec(text)?.[1]).catch((error) => {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return void 0;
+		throw error;
+	});
+	if (rootLayout && (sdk === void 0 || !SDK_VERSION_PATTERN.test(sdk))) throw new Error("The cloned manifest must contain an exact \"sdk\" version.");
+	if (sdk) console.log(`Run pnpm dlx ${rootLayout ? `@hitch42/applet@${sdk}` : sdk} bootstrap to set up this checkout.`);
+}
+function syncAction(input) {
+	if (!input.remoteMain || input.isAncestor) return "continue";
+	return input.hasMergeBase ? "rebase" : "unrelated";
+}
+function deployErrorMessage(code) {
+	if (code === "main_moved") return "Someone deployed while you were deploying. Run applet deploy again to rebase onto their change.";
+}
+function gitError(error) {
+	if (error instanceof Error && "stderr" in error && typeof error.stderr === "string") return error.stderr.trim() || error.message;
+	return error instanceof Error ? error.message : String(error);
+}
+async function git(root, args) {
+	const { stdout } = await execFileAsync("git", args, {
+		cwd: root,
+		env: gitEnvironment()
+	});
+	return stdout.trim();
+}
+async function configureGitCredentialHelper(root, org) {
+	await withOrgAuth(org, async (organizationUrl) => {
+		const instanceUrl = await resolveInstanceUrl();
+		for (const args of gitCredentialConfigCommands(organizationUrl, instanceUrl)) await git(root, args);
+		return { unauthorized: false };
+	});
+}
+function gitCredentialConfigCommands(organizationUrl, instanceUrl) {
+	const key = `credential.${organizationUrl}.helper`;
+	const quotedInstance = `'${instanceUrl.replaceAll("'", "'\\''")}'`;
+	return [[
+		"config",
+		"--local",
+		"--replace-all",
+		key,
+		""
+	], [
+		"config",
+		"--local",
+		"--add",
+		key,
+		`!pnpm exec applet git-credential --instance ${quotedInstance}`
+	]];
+}
+async function hasRef(root, ref) {
+	try {
+		await git(root, [
+			"show-ref",
+			"--verify",
+			"--quiet",
+			ref
+		]);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function gitNetwork(root, org, args) {
+	return (await withOrgAuth(org, async (organizationUrl, token) => {
+		try {
+			return {
+				unauthorized: false,
+				output: await gitWithAuth(root, org, organizationUrl, token, args)
+			};
+		} catch (error) {
+			const message = gitError(error);
+			if (/401|Authentication failed|HTTP Basic: Access denied/i.test(message)) return {
+				unauthorized: true,
+				output: ""
+			};
+			throw new Error(message, { cause: error });
+		}
+	})).output;
+}
+async function gitProxyErrorMessage(message, org, repositoryUrl, token) {
+	if (!/\b403\b/.test(message)) return message;
+	const response = await fetch(`${repositoryUrl}/info/refs?service=git-upload-pack`, {
+		headers: { Authorization: `Bearer ${token}` },
+		redirect: "error"
+	});
+	if (response.status === 403 && response.headers.get("Content-Type")?.includes("application/json")) {
+		if ((await response.json()).code === "git_not_enabled") return `Hitch git is not switched on for ${org}. Deploy with the current stable CLI instead.`;
+	}
+	return message;
+}
+async function gitWithAuth(root, org, organizationUrl, token, args) {
+	try {
+		const { stdout } = await execFileAsync("git", args, {
+			cwd: root,
+			env: {
+				...gitEnvironment(),
+				GIT_TERMINAL_PROMPT: "0",
+				GIT_CONFIG_COUNT: "1",
+				GIT_CONFIG_KEY_0: `http.${organizationUrl}/.extraHeader`,
+				GIT_CONFIG_VALUE_0: `Authorization: Bearer ${token}`
+			}
+		});
+		return stdout.trim();
+	} catch (error) {
+		const message = gitError(error);
+		if (!/\b403\b/.test(message)) throw error;
+		const repositoryUrl = args[0] === "clone" ? args[3] : await git(root, [
+			"remote",
+			"get-url",
+			"hitch"
+		]);
+		if (!repositoryUrl.startsWith(`${organizationUrl}/api/git/`)) throw error;
+		throw new Error(await gitProxyErrorMessage(message, org, repositoryUrl, token), { cause: error });
+	}
+}
+async function refreshHitchMain(workspaceRoot, org, code) {
+	await withOrgAuth(org, async (organizationUrl) => {
+		const url = hitchRemoteUrl(organizationUrl, code);
+		let current;
+		try {
+			current = await git(workspaceRoot, [
+				"remote",
+				"get-url",
+				"hitch"
+			]);
+		} catch {
+			current = void 0;
+		}
+		if (current === void 0) await git(workspaceRoot, [
+			"remote",
+			"add",
+			"hitch",
+			url
+		]);
+		else if (current !== url) await git(workspaceRoot, [
+			"remote",
+			"set-url",
+			"hitch",
+			url
+		]);
+		return { unauthorized: false };
+	});
+	await configureGitCredentialHelper(workspaceRoot, org);
+	try {
+		await gitNetwork(workspaceRoot, org, [
+			"fetch",
+			"hitch",
+			"main"
+		]);
+	} catch (error) {
+		if (!/couldn't find remote ref main|requested URL returned error: 404|repository '[^']*' not found/i.test(gitError(error))) throw error;
+	}
+}
+async function prepareGitDeploy(workspaceRoot, code, org, message, prebuilt = false) {
+	let topLevel;
+	try {
+		topLevel = await git(workspaceRoot, ["rev-parse", "--show-toplevel"]);
+	} catch (error) {
+		if (!/not a git repository/i.test(gitError(error))) throw error;
+		await git(workspaceRoot, [
+			"init",
+			"-b",
+			"main"
+		]);
+		topLevel = workspaceRoot;
+	}
+	if (resolve(topLevel) !== resolve(workspaceRoot)) throw new Error(`The git repository must start at the workspace root ${workspaceRoot}.`);
+	if ((await Promise.all([
+		"rebase-merge",
+		"rebase-apply",
+		"MERGE_HEAD"
+	].map((name) => git(workspaceRoot, [
+		"rev-parse",
+		"--git-path",
+		name
+	])))).some((path) => existsSync(resolve(workspaceRoot, path)))) throw new Error("A rebase or merge is in progress. Finish or abort it, then run applet deploy again.");
+	if (await git(workspaceRoot, ["status", "--porcelain"])) {
+		if (!message) throw new Error("You have uncommitted changes. Pass -m \"<message>\" to commit them with the deploy.");
+		await git(workspaceRoot, ["add", "-A"]);
+		const secrets = stagedSecretPaths((await git(workspaceRoot, [
+			"diff",
+			"--cached",
+			"--name-only",
+			"-z",
+			"--diff-filter=ACMR"
+		])).split("\0").filter(Boolean));
+		if (secrets.length > 0) throw new StagedSecretsError(secrets);
+		await git(workspaceRoot, [
+			"commit",
+			"-m",
+			message
+		]);
+	} else if (message) console.log("There is nothing to commit.");
+	try {
+		await git(workspaceRoot, [
+			"rev-parse",
+			"--verify",
+			"HEAD"
+		]);
+	} catch {
+		throw new Error("Nothing to deploy: the repository has no commits.");
+	}
+	await refreshHitchMain(workspaceRoot, org, code);
+	const remoteMain = await hasRef(workspaceRoot, "refs/remotes/hitch/main");
+	const isAncestor = remoteMain ? await git(workspaceRoot, [
+		"merge-base",
+		"--is-ancestor",
+		"hitch/main",
+		"HEAD"
+	]).then(() => true).catch(() => false) : false;
+	const action = syncAction({
+		remoteMain,
+		isAncestor,
+		hasMergeBase: remoteMain && !isAncestor ? await git(workspaceRoot, [
+			"merge-base",
+			"hitch/main",
+			"HEAD"
+		]).then(() => true).catch(() => false) : false
+	});
+	if (action === "unrelated") throw new Error("This folder's history is not the applet's history in Hitch. Clone the applet repository and move your changes into it.");
+	if (action === "rebase" && prebuilt) throw new Error("main moved since your last deploy, so the build in --dist is out of date. Run applet deploy without --dist.");
+	if (action === "rebase") {
+		console.log("main moved since your last deploy. Rebasing onto it.");
+		try {
+			await git(workspaceRoot, ["rebase", "hitch/main"]);
+		} catch {
+			await git(workspaceRoot, ["rebase", "--abort"]).catch(() => void 0);
+			throw new Error("Your changes conflict with main. Run git pull --rebase hitch main, fix the conflicts, then run applet deploy again.");
+		}
+	}
+	return git(workspaceRoot, ["rev-parse", "HEAD"]);
+}
+async function pushStagedCommit(workspaceRoot, org, sha) {
+	await gitNetwork(workspaceRoot, org, [
+		"push",
+		"hitch",
+		`HEAD:refs/hitch/staged/${sha}`
+	]);
+}
+export { prepareGitDeploy as a, runClone as c, hitchRemoteUrl as i, syncAction as l, gitCredentialConfigCommands as n, pushStagedCommit as o, gitProxyErrorMessage as r, refreshHitchMain as s, deployErrorMessage as t };

package/dist/git-deploy-CNz6mxiF.js

@@ -0,0 +1 @@
+export { c as runClone } from "./git-deploy-C12nMNB6.js";