@geekmidas/cli 10.0.0-alpha.78 → 10.0.0-alpha.80

package/dist/github-CVdbVlT5.mjs

@@ -0,0 +1,669 @@
+import { k as assertDeployedStage } from "./workspace-BBdqmkch.mjs";
+import { loadWorkspaceConfig } from "./config.mjs";
+import { $t as getKeyPath, Jt as isRemoteStore, Yt as secretsStoreFor, en as keystoreProject, nn as readKey } from "./seeds-BdkFpW0P.mjs";
+import { n as secretsParameterName } from "./aws-B-6uEhgP.mjs";
+import { t as secretsManagerSecretName } from "./secretsManager-Chs9VV2r.mjs";
+import { execFileSync } from "node:child_process";
+import { AttachRolePolicyCommand, CreateOpenIDConnectProviderCommand, CreateRoleCommand, DeleteRolePolicyCommand, DetachRolePolicyCommand, GetRoleCommand, IAMClient, ListAttachedRolePoliciesCommand, ListOpenIDConnectProvidersCommand, ListRoleTagsCommand, PutRolePolicyCommand, TagRoleCommand, UntagRoleCommand, UpdateAssumeRolePolicyCommand } from "@aws-sdk/client-iam";
+//#region src/deploy/githubOidc.ts
+/**
+* Template keys whose values are known for a repository's environment job
+* before the job runs. Anything else — `job_workflow_ref`, `ref`, `sha`,
+* `run_id`, `workflow`, `actor`, a custom property — depends on the run.
+*/
+const SUPPORTED_CLAIM_KEYS = [
+	"repo",
+	"context",
+	"environment",
+	"repository",
+	"repository_owner",
+	"repository_owner_id",
+	"repository_id",
+	"repository_visibility"
+];
+const NEEDS_FACTS = /* @__PURE__ */ new Set([
+	"repository_owner_id",
+	"repository_id",
+	"repository_visibility"
+]);
+/** A `:` inside a claim value is sent as `%3A`. */
+function claim(value) {
+	return value.replaceAll(":", "%3A");
+}
+/** Whether {@link oidcSubject} needs the repository's ids or visibility. */
+function needsRepoFacts(customization) {
+	const immutableWithoutPrefix = customization.use_immutable_subject === true && !customization.sub_claim_prefix;
+	if (customization.use_default) return immutableWithoutPrefix;
+	return (customization.include_claim_keys ?? []).some((key) => NEEDS_FACTS.has(key) || key === "repo" && immutableWithoutPrefix);
+}
+/**
+* The exact `sub` of a job in `repo`'s `stage` environment.
+*
+* @throws OidcSubjectNotSupported when a custom template includes a claim
+*   whose value depends on the run, so no one subject can be trusted.
+*/
+function oidcSubject(repo, stage, customization, facts) {
+	const [owner = "", name = ""] = repo.split("/");
+	const environment = `environment:${claim(stage)}`;
+	const repoSegment = () => {
+		if (customization.sub_claim_prefix) return customization.sub_claim_prefix;
+		if (customization.use_immutable_subject) {
+			if (!facts) throw new RepoFactsRequired(repo);
+			return `repo:${owner}@${facts.ownerId}/${name}@${facts.repoId}`;
+		}
+		return `repo:${repo}`;
+	};
+	const immutable = customization.use_immutable_subject === true || customization.sub_claim_prefix !== void 0;
+	if (customization.use_default) return {
+		subject: `${repoSegment()}:${environment}`,
+		kind: immutable ? "immutable" : "default"
+	};
+	const keys = customization.include_claim_keys ?? [];
+	const unsupported = keys.filter((key) => !SUPPORTED_CLAIM_KEYS.includes(key));
+	if (keys.length === 0 || unsupported.length > 0) throw new OidcSubjectNotSupported(repo, keys, unsupported);
+	if (keys.some((key) => NEEDS_FACTS.has(key)) && !facts) throw new RepoFactsRequired(repo);
+	return {
+		subject: keys.map((key) => {
+			switch (key) {
+				case "repo": return repoSegment();
+				case "context":
+				case "environment": return environment;
+				case "repository": return `repository:${claim(repo)}`;
+				case "repository_owner": return `repository_owner:${claim(owner)}`;
+				case "repository_owner_id": return `repository_owner_id:${facts.ownerId}`;
+				case "repository_id": return `repository_id:${facts.repoId}`;
+				default: return `repository_visibility:${claim(facts.visibility)}`;
+			}
+		}).join(":"),
+		kind: "custom"
+	};
+}
+/** The endpoint a repository's subject format is read from. */
+function customizationEndpoint(repo) {
+	return `repos/${repo}/actions/oidc/customization/sub`;
+}
+/**
+* The `sub` GitHub will send for `repo`'s `stage` environment, read from the
+* repository's OIDC settings through `gh`.
+*
+* A repository on a custom template that names no keys of its own uses its
+* organisation's, read from `orgs/{owner}/actions/oidc/customization/sub`.
+* When the settings cannot be read at all — no permission, or a GitHub
+* Enterprise Server without the endpoint — the default format is assumed, with
+* a warning saying where to check it.
+*/
+function resolveOidcSubject(gh, repo, stage) {
+	const endpoint = customizationEndpoint(repo);
+	let customization;
+	try {
+		customization = JSON.parse(gh(["api", endpoint]));
+	} catch {
+		return {
+			subject: `repo:${repo}:environment:${claim(stage)}`,
+			kind: "assumed",
+			warning: `Could not read ${endpoint}, so the default subject format is assumed. Check it with: gh api ${endpoint} — a repository on the immutable subject or a custom template sends a different sub, and the role would not be assumable.`
+		};
+	}
+	if (!customization.use_default && (customization.include_claim_keys ?? []).length === 0) {
+		const [owner = ""] = repo.split("/");
+		const orgEndpoint = `orgs/${owner}/actions/oidc/customization/sub`;
+		let org;
+		try {
+			org = JSON.parse(gh(["api", orgEndpoint]));
+		} catch {
+			throw new OrgOidcTemplateUnreadable(repo, orgEndpoint);
+		}
+		customization = {
+			...customization,
+			include_claim_keys: org.include_claim_keys ?? [],
+			use_immutable_subject: customization.use_immutable_subject ?? org.use_immutable_subject
+		};
+	}
+	const facts = needsRepoFacts(customization) ? readRepoFacts(gh, repo) : void 0;
+	return oidcSubject(repo, stage, customization, facts);
+}
+function readRepoFacts(gh, repo) {
+	const raw = JSON.parse(gh(["api", `repos/${repo}`]));
+	return {
+		ownerId: raw.owner.id,
+		repoId: raw.id,
+		visibility: raw.visibility
+	};
+}
+/**
+* The repository's custom subject template includes a claim whose value
+* depends on the run — or names none — so no one subject can be trusted.
+*/
+var OidcSubjectNotSupported = class extends Error {
+	repo;
+	includeClaimKeys;
+	unsupportedKeys;
+	constructor(repo, includeClaimKeys, unsupportedKeys) {
+		super(`${repo} builds its OIDC subject from a custom template, ${JSON.stringify(includeClaimKeys)}, and ${unsupportedKeys.length > 0 ? `${unsupportedKeys.join(", ")} depend${unsupportedKeys.length === 1 ? "s" : ""} on the run` : "it names no claims"}, so the deploy role cannot trust one exact subject. Set the repository back to the default subject — gh api --method PUT ${customizationEndpoint(repo)} -F use_default=true — (or keep the immutable one by also passing -F use_immutable_subject=true), or use a template built only from ${SUPPORTED_CLAIM_KEYS.join(", ")}; then run this again.`);
+		this.repo = repo;
+		this.includeClaimKeys = includeClaimKeys;
+		this.unsupportedKeys = unsupportedKeys;
+		this.name = "OidcSubjectNotSupported";
+	}
+};
+/** The subject needs the repository's ids, and none were read. */
+var RepoFactsRequired = class extends Error {
+	repo;
+	constructor(repo) {
+		super(`The OIDC subject of ${repo} includes its owner and repository ids; read them with gh api repos/${repo} and pass them in.`);
+		this.repo = repo;
+		this.name = "RepoFactsRequired";
+	}
+};
+/**
+* The repository uses its organisation's subject template, and that template
+* could not be read — so what GitHub sends is unknown, and is not guessed.
+*/
+var OrgOidcTemplateUnreadable = class extends Error {
+	repo;
+	endpoint;
+	constructor(repo, endpoint) {
+		super(`${repo} uses its organisation's OIDC subject template, and ${endpoint} could not be read. Run this as an organisation owner (gh auth refresh -s admin:org), or set the repository back to the default subject with gh api --method PUT ${customizationEndpoint(repo)} -F use_default=true; then run this again.`);
+		this.repo = repo;
+		this.endpoint = endpoint;
+		this.name = "OrgOidcTemplateUnreadable";
+	}
+};
+//#endregion
+//#region src/deploy/githubPolicy.ts
+/**
+* What the deploy role may do in the stage's account.
+*
+* An SST stage creates its own stack, which is most of AWS, so its role gets
+* `AdministratorAccess`. A stage deployed with the `compose` target builds and
+* runs containers on a server; from AWS its deploy job needs only the stage's
+* secrets — read, and written back when a deploy generates a new one — and,
+* when the deploy state is kept in AWS, the stage's state. So a compose stage
+* gets an inline policy naming exactly those resources and nothing else.
+*
+* `--policy-arn` replaces either.
+*/
+/**
+* What SST needs to create a stack is most of AWS, so this is the default
+* outside compose — said out loud in the output, and replaceable with
+* `--policy-arn`.
+*/
+const DEFAULT_POLICY_ARN = "arn:aws:iam::aws:policy/AdministratorAccess";
+/** The name of the inline policy a compose stage's role is given. */
+const SCOPED_POLICY_NAME = "gkm-deploy";
+/** Every target the stage's apps deploy through. */
+function deployTargets(workspace) {
+	const targets = /* @__PURE__ */ new Set([workspace.deploy?.default ?? "dokploy"]);
+	for (const app of Object.values(workspace.apps)) targets.add(app.resolvedDeployTarget);
+	return [...targets].sort();
+}
+/**
+* The access the stage's deploy role is given: `--policy-arn` when passed,
+* the scoped policy for a stage only the compose target deploys, and
+* `AdministratorAccess` otherwise.
+*/
+function deployAccess(workspace, stage, policyArn) {
+	if (policyArn) return {
+		kind: "managed",
+		policyArn,
+		reason: "--policy-arn"
+	};
+	const targets = deployTargets(workspace);
+	if (targets.length !== 1 || targets[0] !== "compose") return {
+		kind: "managed",
+		policyArn: DEFAULT_POLICY_ARN,
+		reason: `the ${targets.join(", ")} target${targets.length === 1 ? "" : "s"} deploy${targets.length === 1 ? "s" : ""} infrastructure; --policy-arn to narrow`
+	};
+	const project = workspace.name;
+	const store = workspace.secrets.store ?? "file";
+	const state = workspace.state;
+	if (typeof store === "object" && typeof store.provider === "object" || state !== void 0 && typeof state.provider === "object") return {
+		kind: "managed",
+		policyArn: DEFAULT_POLICY_ARN,
+		reason: `a custom ${typeof store === "object" && typeof store.provider === "object" ? "secrets store" : "state provider"} cannot be scoped; --policy-arn to narrow`
+	};
+	const describe = [];
+	const build = [];
+	if (typeof store === "object" && store.provider === "ssm") {
+		const { region } = store;
+		const name = secretsParameterName(project, stage);
+		describe.push(`read and update ${name} (SSM, ${region})`);
+		build.push((account) => [{
+			Sid: "StageSecrets",
+			Effect: "Allow",
+			Action: ["ssm:GetParameter", "ssm:PutParameter"],
+			Resource: `arn:aws:ssm:${region}:${account}:parameter${name}`
+		}]);
+	} else if (typeof store === "object" && store.provider === "secrets-manager") {
+		const { region, kmsKeyId } = store;
+		const name = secretsManagerSecretName(project, stage);
+		describe.push(`read and update ${name} (Secrets Manager, ${region})`);
+		build.push((account) => {
+			const statements = [{
+				Sid: "StageSecrets",
+				Effect: "Allow",
+				Action: [
+					"secretsmanager:GetSecretValue",
+					"secretsmanager:PutSecretValue",
+					"secretsmanager:CreateSecret"
+				],
+				Resource: `arn:aws:secretsmanager:${region}:${account}:secret:${name}-??????`
+			}];
+			if (kmsKeyId) statements.push({
+				Sid: "StageSecretsKey",
+				Effect: "Allow",
+				Action: ["kms:Decrypt", "kms:GenerateDataKey"],
+				Resource: kmsKeyId.startsWith("arn:") ? kmsKeyId : "*",
+				Condition: { StringEquals: { "kms:ViaService": `secretsmanager.${region}.amazonaws.com` } }
+			});
+			return statements;
+		});
+	}
+	if (state?.provider === "ssm") {
+		const { region } = state;
+		const path = `/gkm/${project}/${stage}/`;
+		describe.push(`read and write the deploy state under ${path} (SSM, ${region})`);
+		build.push((account) => [{
+			Sid: "StageState",
+			Effect: "Allow",
+			Action: [
+				"ssm:GetParameter",
+				"ssm:PutParameter",
+				"ssm:DeleteParameter"
+			],
+			Resource: `arn:aws:ssm:${region}:${account}:parameter${path}*`
+		}]);
+	} else if (state?.provider === "s3") {
+		const prefix = (state.prefix ?? "gkm").replace(/\/+$/, "");
+		const path = `${prefix ? `${prefix}/` : ""}${project}/${stage}/`;
+		describe.push(`read and write the deploy state under s3://${state.bucket}/${path}`);
+		build.push(() => [{
+			Sid: "StageState",
+			Effect: "Allow",
+			Action: [
+				"s3:GetObject",
+				"s3:PutObject",
+				"s3:DeleteObject"
+			],
+			Resource: `arn:aws:s3:::${state.bucket}/${path}*`
+		}, {
+			Sid: "StageStateBucket",
+			Effect: "Allow",
+			Action: ["s3:ListBucket"],
+			Resource: `arn:aws:s3:::${state.bucket}`
+		}]);
+	}
+	return {
+		kind: "scoped",
+		statements: (account) => build.flatMap((statements) => statements(account)),
+		describe
+	};
+}
+/** The scoped access as a policy document, or null when it allows nothing. */
+function scopedPolicyDocument(statements) {
+	if (statements.length === 0) return null;
+	return JSON.stringify({
+		Version: "2012-10-17",
+		Statement: statements
+	});
+}
+/** The account an IAM ARN is in: `arn:aws:iam::<account>:…`. */
+function accountOf(arn) {
+	return arn.split(":")[4] ?? "";
+}
+//#endregion
+//#region src/deploy/github.ts
+/**
+* `gkm deploy:github` — let GitHub Actions deploy one stage, with no keys.
+*
+* A stage usually lives in its own AWS account — staging in one, production in
+* another — so this runs once per stage, with that account's profile:
+*
+*   gkm deploy:github --stage staging --profile acme-dev
+*   gkm deploy:github --stage prod    --profile acme-prod
+*
+* In the stage's account it makes sure GitHub's OIDC provider exists, and a
+* role that only this repository's `<stage>` environment can assume. On
+* GitHub it creates that environment and gives it what the generated deploy
+* workflow reads: `AWS_ROLE_ARN`, and — when the stage's secrets are kept in
+* the local file — its key as `GKM_SECRETS_KEY`. With `secrets.store` set to
+* SSM or Secrets Manager the deploy job reads them with the role instead, so
+* no key is handed to GitHub, and this checks the stage's store in the same
+* account, with the same profile. Re-running it converges rather than duplicating.
+*
+* The role trusts the exact `sub` GitHub sends for the environment, read from
+* the repository's OIDC subject settings (`githubOidc.ts`) — the default, the
+* immutable subject with the owner's and repository's ids, or a custom
+* template. A re-run rewrites an existing role's trust to it, so running this
+* again repairs a role that trusted the wrong format. What the role may do is
+* `githubPolicy.ts`: `AdministratorAccess` for SST, and for a compose stage
+* only its own secrets (and deploy state, when that is in AWS).
+*/
+const logger = console;
+const GITHUB_OIDC_HOST = "token.actions.githubusercontent.com";
+const AUDIENCE = "sts.amazonaws.com";
+/**
+* The tag recording which managed policy gkm attached to the role — so a
+* re-run detaches only what gkm put there, never a policy someone else did.
+*/
+const POLICY_TAG = "gkm:policy-arn";
+const defaultGh = (args, input) => execFileSync("gh", args, {
+	encoding: "utf-8",
+	stdio: [
+		"pipe",
+		"pipe",
+		"pipe"
+	],
+	...input === void 0 ? {} : { input }
+}).trim();
+/** The role a stage deploys as: `<project>-github-<stage>`, within IAM's 64. */
+function roleName(project, stage) {
+	return `${project}-github-${stage}`.toLowerCase().replace(/[^a-z0-9+=,.@_-]/g, "-").slice(0, 64);
+}
+/**
+* Who may assume the role: a workflow job whose OIDC token carries exactly
+* `subject` — the repository's `<stage>` environment, in the format the
+* repository sends (see `githubOidc.ts`), and nothing else. Not another
+* branch's job, not another environment's: that is what keeps a staging
+* deploy from using the production role.
+*/
+function trustPolicy(providerArn, subject) {
+	return JSON.stringify({
+		Version: "2012-10-17",
+		Statement: [{
+			Effect: "Allow",
+			Principal: { Federated: providerArn },
+			Action: "sts:AssumeRoleWithWebIdentity",
+			Condition: { StringEquals: {
+				[`${GITHUB_OIDC_HOST}:aud`]: AUDIENCE,
+				[`${GITHUB_OIDC_HOST}:sub`]: subject
+			} }
+		}]
+	});
+}
+/**
+* The subject a trust policy trusts, or undefined when it names none. IAM
+* hands documents back URL-encoded.
+*/
+function trustedSubject(document) {
+	if (!document) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(safeDecode(document));
+	} catch {
+		return;
+	}
+	for (const statement of parsed.Statement ?? []) for (const operator of Object.values(statement.Condition ?? {})) {
+		const value = operator[`${GITHUB_OIDC_HOST}:sub`];
+		if (typeof value === "string") return value;
+		if (Array.isArray(value)) return value.join(", ");
+	}
+}
+function safeDecode(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+/** GitHub's OIDC provider in this account, created if it is not there. */
+async function ensureOidcProvider(iam) {
+	const { OpenIDConnectProviderList = [] } = await iam.send(new ListOpenIDConnectProvidersCommand({}));
+	const existing = OpenIDConnectProviderList.find((p) => p.Arn?.endsWith(`oidc-provider/${GITHUB_OIDC_HOST}`))?.Arn;
+	if (existing) return existing;
+	return (await iam.send(new CreateOpenIDConnectProviderCommand({
+		Url: `https://${GITHUB_OIDC_HOST}`,
+		ClientIDList: [AUDIENCE]
+	}))).OpenIDConnectProviderArn;
+}
+function isNoSuchEntity(error) {
+	return error.name === "NoSuchEntityException";
+}
+/**
+* The deploy role, created or brought back to this trust and access.
+*
+* Converges: re-running rewrites the trust, and moves the role from one access
+* to another — detaching a managed policy only when the role's
+* {@link POLICY_TAG} says gkm attached it.
+*/
+async function ensureRole(iam, name, trust, access) {
+	let arn;
+	let created = false;
+	let previousSubject;
+	let recorded;
+	try {
+		const { Role } = await iam.send(new GetRoleCommand({ RoleName: name }));
+		previousSubject = trustedSubject(Role.AssumeRolePolicyDocument);
+		await iam.send(new UpdateAssumeRolePolicyCommand({
+			RoleName: name,
+			PolicyDocument: trust
+		}));
+		arn = Role.Arn;
+		const { Tags = [] } = await iam.send(new ListRoleTagsCommand({ RoleName: name }));
+		recorded = Tags.find((tag) => tag.Key === POLICY_TAG)?.Value;
+	} catch (error) {
+		if (!isNoSuchEntity(error)) throw error;
+		const { Role } = await iam.send(new CreateRoleCommand({
+			RoleName: name,
+			AssumeRolePolicyDocument: trust,
+			Description: "Deploys from GitHub Actions (gkm deploy:github)",
+			MaxSessionDuration: 7200
+		}));
+		arn = Role.Arn;
+		created = true;
+	}
+	const detached = [];
+	const leftAttached = [];
+	const detach = async (policyArn) => {
+		try {
+			await iam.send(new DetachRolePolicyCommand({
+				RoleName: name,
+				PolicyArn: policyArn
+			}));
+			detached.push(policyArn);
+		} catch (error) {
+			if (!isNoSuchEntity(error)) throw error;
+		}
+	};
+	const deleteInline = async () => {
+		try {
+			await iam.send(new DeleteRolePolicyCommand({
+				RoleName: name,
+				PolicyName: SCOPED_POLICY_NAME
+			}));
+		} catch (error) {
+			if (!isNoSuchEntity(error)) throw error;
+		}
+	};
+	if ("managed" in access) {
+		await iam.send(new AttachRolePolicyCommand({
+			RoleName: name,
+			PolicyArn: access.managed
+		}));
+		if (recorded && recorded !== access.managed) await detach(recorded);
+		if (recorded !== access.managed) await iam.send(new TagRoleCommand({
+			RoleName: name,
+			Tags: [{
+				Key: POLICY_TAG,
+				Value: access.managed
+			}]
+		}));
+		if (!created) await deleteInline();
+		return {
+			arn,
+			created,
+			previousSubject,
+			detached,
+			leftAttached
+		};
+	}
+	if (access.inline) await iam.send(new PutRolePolicyCommand({
+		RoleName: name,
+		PolicyName: SCOPED_POLICY_NAME,
+		PolicyDocument: access.inline
+	}));
+	else if (!created) await deleteInline();
+	if (created) return {
+		arn,
+		created,
+		previousSubject,
+		detached,
+		leftAttached
+	};
+	if (recorded) {
+		await detach(recorded);
+		await iam.send(new UntagRoleCommand({
+			RoleName: name,
+			TagKeys: [POLICY_TAG]
+		}));
+	}
+	const { AttachedPolicies = [] } = await iam.send(new ListAttachedRolePoliciesCommand({ RoleName: name }));
+	for (const policy of AttachedPolicies) if (policy.PolicyArn && !detached.includes(policy.PolicyArn)) leftAttached.push(policy.PolicyArn);
+	return {
+		arn,
+		created,
+		previousSubject,
+		detached,
+		leftAttached
+	};
+}
+/**
+* An IAM client for the stage's account.
+*
+* `fromIni` for a named profile, deliberately: it resolves exactly that
+* profile — keys, assume-role, `credential_process` or SSO, whichever
+* ~/.aws/config says — and never falls back to AWS_* in the environment. The
+* provider chain checks the environment first, so exported staging keys would
+* quietly win over `--profile prod` and the production role would land in the
+* staging account.
+*/
+async function iamFor(profile, endpoint) {
+	const config = { region: "us-east-1" };
+	if (profile) {
+		const { fromIni } = await import("@aws-sdk/credential-providers");
+		config.credentials = fromIni({ profile });
+	}
+	if (endpoint) {
+		config.endpoint = endpoint;
+		config.credentials = {
+			accessKeyId: "test",
+			secretAccessKey: "test"
+		};
+	}
+	return new IAMClient(config);
+}
+async function deployGithubCommand(options, deps = {}) {
+	const gh = deps.gh ?? defaultGh;
+	const { workspace } = await loadWorkspaceConfig(deps.cwd);
+	assertDeployedStage(workspace.stages, options.stage);
+	const repo = options.repo ?? gh([
+		"repo",
+		"view",
+		"--json",
+		"nameWithOwner",
+		"-q",
+		".nameWithOwner"
+	]);
+	const role = roleName(workspace.name, options.stage);
+	const oidc = resolveOidcSubject(gh, repo, options.stage);
+	const access = deployAccess(workspace, options.stage, options.policyArn);
+	const key = await readKey(options.stage, keystoreProject(workspace));
+	const keyPath = getKeyPath(options.stage, keystoreProject(workspace));
+	const hasKey = key !== null;
+	const remote = isRemoteStore(workspace, options.stage);
+	const store = await secretsStoreFor(workspace, options.stage, { ...options.profile ? { profile: options.profile } : {} });
+	const hasSecrets = remote && await store.read(options.stage) !== null;
+	const via = options.profile ? `profile "${options.profile}"` : "the default credentials";
+	logger.log(`\n🔐 GitHub → AWS for stage "${options.stage}"\n`);
+	logger.log(`  Repository:   ${repo}`);
+	logger.log(`  AWS profile:  ${options.profile ?? "(default credentials)"}`);
+	logger.log(`  Role:         ${role}`);
+	if (access.kind === "managed") logger.log(`  Policy:       ${access.policyArn}  (${access.reason})`);
+	else if (access.describe.length > 0) {
+		logger.log(`  Policy:       inline "${SCOPED_POLICY_NAME}", scoped to the compose deploy — only:`);
+		for (const line of access.describe) logger.log(`                  ${line}`);
+	} else logger.log("  Policy:       none — a compose deploy with file secrets and local state reads nothing from AWS");
+	logger.log(`  Trusted by:   ${oidc.subject} only  (${SUBJECT_KINDS[oidc.kind]})`);
+	if (oidc.warning) logger.log(`  ⚠ ${oidc.warning}`);
+	if (remote) logger.log(`  Secrets:      ${hasSecrets ? `in the store (${store.name}), read with ${via}` : `none in the store yet — gkm secrets:set <KEY> '…' --stage ${options.stage}`}`);
+	else logger.log(`  Secrets key:  ${hasKey ? keyPath : `none at ${keyPath} — run gkm secrets:init --stage ${options.stage} first`}`);
+	if (options.dryRun) {
+		if (access.kind === "scoped") {
+			const document = scopedPolicyDocument(access.statements("<account>"));
+			if (document) logger.log(`\n  Inline policy:\n${JSON.stringify(JSON.parse(document), null, 2).replace(/^/gm, "    ")}`);
+		}
+		logger.log("\n  --dry-run: nothing changed.\n");
+		return {
+			repo,
+			subject: oidc.subject
+		};
+	}
+	const iam = deps.iam ?? await iamFor(options.profile);
+	const providerArn = await ensureOidcProvider(iam).catch((error) => {
+		if (/SSO session/i.test(String(error?.message)) && options.profile) throw new SsoSessionExpired(options.profile);
+		throw error;
+	});
+	const outcome = await ensureRole(iam, role, trustPolicy(providerArn, oidc.subject), access.kind === "managed" ? { managed: access.policyArn } : { inline: scopedPolicyDocument(access.statements(accountOf(providerArn))) });
+	const roleArn = outcome.arn;
+	logger.log(`\n  ✓ AWS: ${roleArn}${outcome.created ? " (created)" : ""}`);
+	if (!outcome.created) logger.log(outcome.previousSubject === oidc.subject ? `  ✓ Trust: unchanged, ${oidc.subject}` : `  ✓ Trust: ${outcome.previousSubject ?? "(no subject)"} → ${oidc.subject}`);
+	for (const detached of outcome.detached) logger.log(`  ✓ Detached ${detached} (attached by gkm, no longer needed)`);
+	if (access.kind === "scoped") for (const attached of outcome.leftAttached) logger.log(`  ⚠ ${attached} is still attached to ${role}. gkm has no record of attaching it, so it is left; the compose deploy does not need it. Detach it with: aws iam detach-role-policy --role-name ${role} --policy-arn ${attached}${options.profile ? ` --profile ${options.profile}` : ""}`);
+	gh([
+		"api",
+		"--method",
+		"PUT",
+		`repos/${repo}/environments/${options.stage}`
+	]);
+	gh([
+		"variable",
+		"set",
+		"AWS_ROLE_ARN",
+		"--env",
+		options.stage,
+		"--repo",
+		repo,
+		"--body",
+		roleArn
+	]);
+	logger.log(`  ✓ GitHub: environment "${options.stage}", AWS_ROLE_ARN`);
+	if (remote) {
+		if (!hasSecrets) logger.log(`  ⚠ The "${options.stage}" store holds no secrets yet; set them with gkm secrets:set <KEY> '…' --stage ${options.stage}${options.profile ? ` (AWS_PROFILE=${options.profile})` : ""}.`);
+	} else if (hasKey) {
+		gh([
+			"secret",
+			"set",
+			"GKM_SECRETS_KEY",
+			"--env",
+			options.stage,
+			"--repo",
+			repo
+		], key);
+		logger.log("  ✓ GitHub: GKM_SECRETS_KEY");
+	} else logger.log(`  ⚠ No secrets key for "${options.stage}"; run gkm secrets:init --stage ${options.stage}, then this again.`);
+	logger.log(`\n  Protect it: add required reviewers to the "${options.stage}" environment in the repository settings.\n`);
+	return {
+		roleArn,
+		repo,
+		subject: oidc.subject
+	};
+}
+const SUBJECT_KINDS = {
+	default: "the repository's default subject",
+	immutable: "the repository's immutable subject",
+	custom: "the repository's custom subject template",
+	assumed: "assumed: the default format"
+};
+/** The profile's SSO login has lapsed; the fix is one command away. */
+var SsoSessionExpired = class extends Error {
+	profile;
+	constructor(profile) {
+		super(`The SSO session for profile "${profile}" has expired or is invalid. Run: aws sso login --profile ${profile}`);
+		this.profile = profile;
+		this.name = "SsoSessionExpired";
+	}
+};
+//#endregion
+export { deployGithubCommand };
+
+//# sourceMappingURL=github-CVdbVlT5.mjs.map