jsii-release 0.3.0 → 0.3.1

package/README.md

@@ -48,6 +48,7 @@ You can also execute individual publishers:
 * `publib-npm`
 * `publib-pypi`
 * `publib-golang`
+* `publib-github`
 
 ## Dry Run
 
@@ -305,6 +306,34 @@ Repository tags will be in the following format:
 | `GIT_CLONE_DEPTH`                                     | Optional                                         | The git clone depth. Usually only the latest commit is required. Defaults to 1.                                                                                                                                                                      |
 | `DRYRUN`                                              | Optional                                         | Deprecated. Use `PUBLIB_DRYRUN` instead. Set to "true" for a dry run.                                                                                                                                                                                |
 
+## GitHub Releases
+
+Creates a [GitHub release](https://docs.github.com/en/repositories/releasing-projects-on-github/about-releases) for a tag.
+
+If a release for the tag already exists, the command succeeds without touching
+the existing release, so that re-running a (partially failed) release workflow
+is a no-op rather than a failure.
+
+**Usage:**
+
+```shell
+npx publib-github
+```
+
+**Options (environment variables):**
+
+| Option                    | Required                                             | Description                                                                                                                                                                                             |
+| ------------------------- | ---------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `GITHUB_TOKEN`            | Required                                             | Token used to authenticate against the GitHub API. Requires `contents: write` permission.                                                                                                               |
+| `GITHUB_REPOSITORY`       | Required                                             | The repository to release to, in `owner/repo` format. Set automatically in [GitHub Actions workflows](https://docs.github.com/en/actions/learn-github-actions/variables#default-environment-variables). |
+| `GITHUB_RELEASE_TAG`      | Either this or `GITHUB_RELEASE_TAG_FILE` is required | The tag to release (e.g. `v1.2.3`).                                                                                                                                                                     |
+| `GITHUB_RELEASE_TAG_FILE` | Either this or `GITHUB_RELEASE_TAG` is required      | A file containing the tag to release (e.g. `dist/releasetag.txt`).                                                                                                                                      |
+| `GITHUB_CHANGELOG_FILE`   | Optional                                             | A markdown file used as the release notes (e.g. `dist/changelog.md`).                                                                                                                                   |
+| `GITHUB_SHA`              | Optional                                             | The commit to tag if the tag doesn't exist yet. Ignored if the tag already exists. Defaults to the repository's default branch. Set automatically in GitHub Actions workflows.                          |
+| `GITHUB_PRERELEASE`       | Optional                                             | Set to "true" to mark the release as a prerelease.                                                                                                                                                      |
+| `GITHUB_MARK_LATEST`      | Optional                                             | `true` to explicitly mark the release as the latest release, `false` to explicitly not mark it as latest. Defaults to GitHub determining the latest release.                                            |
+| `GITHUB_API_URL`          | Optional                                             | Base URL of the GitHub API, for GitHub Enterprise instances. Defaults to `https://api.github.com`. Set automatically in GitHub Actions workflows.                                                       |
+
 ## Publish to CodeArtifact for testing
 
 This package contains the `publib-ca` CLI tool which is intended to use to publish

package/bin/publib-github

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../lib/bin/publib-github.js');

package/lib/bin/publib-github.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/bin/publib-github.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Creates a GitHub release, tolerating a release that already exists so that
+ * re-running a release is a no-op rather than a failure.
+ *
+ * Usage: publib-github
+ *
+ * GITHUB_TOKEN (required): token used to authenticate against the GitHub API
+ * GITHUB_RELEASE_TAG (optional): the tag to release; either this or GITHUB_RELEASE_TAG_FILE is required
+ * GITHUB_RELEASE_TAG_FILE (optional): a file containing the tag to release
+ * GITHUB_CHANGELOG_FILE (optional): a markdown file used as the release notes
+ * GITHUB_REPOSITORY (optional): the repository to release to, in `owner/repo` format (defaults to the repository of the "origin" remote in the current directory)
+ * GITHUB_SHA (optional): the commit to tag if the tag doesn't exist yet (defaults to the current git HEAD, or the repository's default branch when not in a git repository)
+ * GITHUB_PRERELEASE (optional): set to "true" to mark the release as a prerelease
+ * GITHUB_MARK_LATEST (optional): "true" to explicitly mark the release as the latest release, "false" to explicitly not mark it as latest (defaults to GitHub determining the latest release)
+ * GITHUB_API_URL (optional): base URL of the GitHub API (defaults to "https://api.github.com"; set automatically in GitHub Actions)
+ * PUBLIB_DRYRUN (optional): set to "true" to print what would be done without creating a release
+ */
+const fs_1 = require("fs");
+const git = __importStar(require("../help/git"));
+const github_1 = require("../targets/github");
+async function main() {
+    const repository = optionalEnv('GITHUB_REPOSITORY') ?? git.repositorySlug();
+    if (!repository) {
+        throw new Error('GITHUB_REPOSITORY is required, could not infer the repository from the "origin" remote');
+    }
+    const tag = releaseTag();
+    const changelogFile = optionalEnv('GITHUB_CHANGELOG_FILE');
+    const body = changelogFile ? (0, fs_1.readFileSync)(changelogFile, 'utf-8') : undefined;
+    const target = optionalEnv('GITHUB_SHA') ?? git.head();
+    const prerelease = (optionalEnv('GITHUB_PRERELEASE') ?? 'false').toLowerCase() === 'true';
+    const latest = parseMarkLatest(optionalEnv('GITHUB_MARK_LATEST'));
+    const dryRun = (process.env.PUBLIB_DRYRUN ?? process.env.DRYRUN ?? 'false').toLowerCase() === 'true';
+    if (dryRun) {
+        console.log(`🏜️ Dry run: would create GitHub release ${tag}${prerelease ? ' (prerelease)' : ''} in ${repository}${target ? ` at ${target}` : ''}`);
+        console.log('SUCCESS (dry run)');
+        return;
+    }
+    const result = await (0, github_1.createGitHubRelease)({
+        tag,
+        repository,
+        body,
+        target,
+        prerelease,
+        latest,
+        token: requireEnv('GITHUB_TOKEN'),
+        apiUrl: optionalEnv('GITHUB_API_URL'),
+    });
+    if (result === 'already_exists') {
+        console.log(`SKIPPING: release ${tag} already exists`);
+    }
+    else {
+        console.log(`SUCCESS: created release ${tag}`);
+    }
+}
+function releaseTag() {
+    const explicitTag = optionalEnv('GITHUB_RELEASE_TAG');
+    if (explicitTag) {
+        return explicitTag;
+    }
+    const tagFile = optionalEnv('GITHUB_RELEASE_TAG_FILE');
+    if (!tagFile) {
+        throw new Error('GITHUB_RELEASE_TAG or GITHUB_RELEASE_TAG_FILE is required');
+    }
+    const tag = (0, fs_1.readFileSync)(tagFile, 'utf-8').trim();
+    if (!tag) {
+        throw new Error(`release tag file ${tagFile} is empty`);
+    }
+    return tag;
+}
+function parseMarkLatest(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === 'true' || value === 'false') {
+        return value === 'true';
+    }
+    throw new Error(`GITHUB_MARK_LATEST must be "true" or "false", got: "${value}"`);
+}
+/**
+ * Returns the value of the environment variable, treating an empty string as
+ * not set.
+ */
+function optionalEnv(name) {
+    return process.env[name] ? process.env[name] : undefined;
+}
+function requireEnv(name) {
+    const value = process.env[name];
+    if (!value) {
+        throw new Error(`${name} is required`);
+    }
+    return value;
+}
+main().catch((error) => {
+    console.error(`ERROR: ${error.message}`);
+    process.exit(1);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"publib-github.js","sourceRoot":"","sources":["../../src/bin/publib-github.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n/**\n * Creates a GitHub release, tolerating a release that already exists so that\n * re-running a release is a no-op rather than a failure.\n *\n * Usage: publib-github\n *\n * GITHUB_TOKEN (required): token used to authenticate against the GitHub API\n * GITHUB_RELEASE_TAG (optional): the tag to release; either this or GITHUB_RELEASE_TAG_FILE is required\n * GITHUB_RELEASE_TAG_FILE (optional): a file containing the tag to release\n * GITHUB_CHANGELOG_FILE (optional): a markdown file used as the release notes\n * GITHUB_REPOSITORY (optional): the repository to release to, in `owner/repo` format (defaults to the repository of the \"origin\" remote in the current directory)\n * GITHUB_SHA (optional): the commit to tag if the tag doesn't exist yet (defaults to the current git HEAD, or the repository's default branch when not in a git repository)\n * GITHUB_PRERELEASE (optional): set to \"true\" to mark the release as a prerelease\n * GITHUB_MARK_LATEST (optional): \"true\" to explicitly mark the release as the latest release, \"false\" to explicitly not mark it as latest (defaults to GitHub determining the latest release)\n * GITHUB_API_URL (optional): base URL of the GitHub API (defaults to \"https://api.github.com\"; set automatically in GitHub Actions)\n * PUBLIB_DRYRUN (optional): set to \"true\" to print what would be done without creating a release\n */\nimport { readFileSync } from 'fs';\nimport * as git from '../help/git';\nimport { createGitHubRelease } from '../targets/github';\n\nasync function main() {\n  const repository = optionalEnv('GITHUB_REPOSITORY') ?? git.repositorySlug();\n  if (!repository) {\n    throw new Error('GITHUB_REPOSITORY is required, could not infer the repository from the \"origin\" remote');\n  }\n  const tag = releaseTag();\n  const changelogFile = optionalEnv('GITHUB_CHANGELOG_FILE');\n  const body = changelogFile ? readFileSync(changelogFile, 'utf-8') : undefined;\n  const target = optionalEnv('GITHUB_SHA') ?? git.head();\n  const prerelease = (optionalEnv('GITHUB_PRERELEASE') ?? 'false').toLowerCase() === 'true';\n  const latest = parseMarkLatest(optionalEnv('GITHUB_MARK_LATEST'));\n  const dryRun = (process.env.PUBLIB_DRYRUN ?? process.env.DRYRUN ?? 'false').toLowerCase() === 'true';\n\n  if (dryRun) {\n    console.log(\n      `🏜️ Dry run: would create GitHub release ${tag}${prerelease ? ' (prerelease)' : ''} in ${repository}${target ? ` at ${target}` : ''}`,\n    );\n    console.log('SUCCESS (dry run)');\n    return;\n  }\n\n  const result = await createGitHubRelease({\n    tag,\n    repository,\n    body,\n    target,\n    prerelease,\n    latest,\n    token: requireEnv('GITHUB_TOKEN'),\n    apiUrl: optionalEnv('GITHUB_API_URL'),\n  });\n\n  if (result === 'already_exists') {\n    console.log(`SKIPPING: release ${tag} already exists`);\n  } else {\n    console.log(`SUCCESS: created release ${tag}`);\n  }\n}\n\nfunction releaseTag(): string {\n  const explicitTag = optionalEnv('GITHUB_RELEASE_TAG');\n  if (explicitTag) {\n    return explicitTag;\n  }\n  const tagFile = optionalEnv('GITHUB_RELEASE_TAG_FILE');\n  if (!tagFile) {\n    throw new Error('GITHUB_RELEASE_TAG or GITHUB_RELEASE_TAG_FILE is required');\n  }\n  const tag = readFileSync(tagFile, 'utf-8').trim();\n  if (!tag) {\n    throw new Error(`release tag file ${tagFile} is empty`);\n  }\n  return tag;\n}\n\nfunction parseMarkLatest(value: string | undefined): boolean | undefined {\n  if (value === undefined) {\n    return undefined;\n  }\n  if (value === 'true' || value === 'false') {\n    return value === 'true';\n  }\n  throw new Error(`GITHUB_MARK_LATEST must be \"true\" or \"false\", got: \"${value}\"`);\n}\n\n/**\n * Returns the value of the environment variable, treating an empty string as\n * not set.\n */\nfunction optionalEnv(name: string): string | undefined {\n  return process.env[name] ? process.env[name] : undefined;\n}\n\nfunction requireEnv(name: string): string {\n  const value = process.env[name];\n  if (!value) {\n    throw new Error(`${name} is required`);\n  }\n  return value;\n}\n\nmain().catch((error: Error) => {\n  console.error(`ERROR: ${error.message}`);\n  process.exit(1);\n});\n"]}

package/lib/help/git.d.ts

@@ -113,3 +113,24 @@ export declare function identify(user: string, address: string): void;
  * Does the given branch exists on the remote.
  */
 export declare function branchExistsOnRemote(repositoryUrl: string, branch: string): boolean;
+/**
+ * Returns the `owner/repo` slug of the `origin` remote in the current
+ * directory, or undefined if it cannot be determined (e.g. not in a git
+ * repository, or no `origin` remote configured).
+ */
+export declare function repositorySlug(): string | undefined;
+/**
+ * Extracts the `owner/repo` slug from a git remote URL.
+ *
+ * Supports HTTPS (`https://github.com/owner/repo.git`), SSH
+ * (`git@github.com:owner/repo.git`, `ssh://git@github.com/owner/repo.git`)
+ * and URLs without a `.git` suffix.
+ *
+ * @returns the `owner/repo` slug, or undefined if it cannot be determined
+ */
+export declare function parseRepositorySlug(url: string): string | undefined;
+/**
+ * Returns the commit hash of HEAD in the current directory, or undefined if
+ * it cannot be determined (e.g. not in a git repository).
+ */
+export declare function head(): string | undefined;

package/lib/help/git.js

@@ -49,6 +49,9 @@ exports.username = username;
 exports.email = email;
 exports.identify = identify;
 exports.branchExistsOnRemote = branchExistsOnRemote;
+exports.repositorySlug = repositorySlug;
+exports.parseRepositorySlug = parseRepositorySlug;
+exports.head = head;
 const shell = __importStar(require("./shell"));
 /**
  * Clones a repository from GitHub. Requires a `GITHUB_TOKEN` env variable.
@@ -259,4 +262,55 @@ function identify(user, address) {
 function branchExistsOnRemote(repositoryUrl, branch) {
     return shell.check(`git ls-remote --exit-code --heads ${tryDetectRepositoryUrl(repositoryUrl)} ${branch}`, { capture: true });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"git.js","sourceRoot":"","sources":["../../src/help/git.ts"],"names":[],"mappings":"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","sourcesContent":["import * as shell from './shell';\n\nexport interface CloneOptions {\n  /**\n   * @default 1\n   */\n  readonly depth?: number;\n\n  /**\n   * @default false\n   */\n  readonly tags?: boolean;\n\n  /**\n   * @default - default branch\n   */\n  readonly branch?: string;\n}\n\n/**\n * Clones a repository from GitHub. Requires a `GITHUB_TOKEN` env variable.\n *\n * @param repositoryUrl the repository to clone.\n * @param targetDir the clone directory.\n */\nexport function clone(repositoryUrl: string, targetDir: string, { depth = 1, tags = false, branch }: CloneOptions = {}) {\n  const cmd = ['git', 'clone'];\n\n  if (depth) {\n    cmd.push(`--depth ${depth}`);\n  }\n\n  if (branch) {\n    cmd.push(`--branch ${branch}`);\n  }\n\n  if (tags) {\n    cmd.push('--tags');\n  }\n\n  cmd.push(tryDetectRepositoryUrl(repositoryUrl));\n  cmd.push(targetDir);\n\n  shell.run(cmd.join(' '));\n}\n\nfunction tryDetectRepositoryUrl(repositoryUrl: string): string {\n  const gitHubUseSsh = detectSSH();\n  if (gitHubUseSsh) {\n    const sshRepositoryUrl = repositoryUrl.replace('/', ':');\n    return `git@${sshRepositoryUrl}.git`;\n  }\n\n  const gitHubToken = getToken(detectGHE());\n  if (!gitHubToken) {\n    throw new Error('GITHUB_TOKEN env variable is required when GITHUB_USE_SSH env variable is not used');\n  }\n  return `https://${gitHubToken}@${repositoryUrl}.git`;\n}\n\n/**\n * Checks if the current environment is an GHE environment.\n *\n * This check is using GITHUB_API_URL set in GitHub Actions workflow, as well as common gh cli env variables.\n * https://docs.github.com/en/actions/learn-github-actions/variables#default-environment-variables\n * https://cli.github.com/manual/gh_help_environment\n *\n * @return - `true` if GH_HOST or GITHUB_API_URL env var are defined and not equal to the public github endpoint, otherwise `false`\n */\nexport function detectGHE(): boolean {\n  const githubApiUrl = process.env.GITHUB_API_URL;\n  const ghHost = process.env.GH_HOST;\n\n  return (Boolean(ghHost) && ghHost!.trim().toLowerCase() != 'github.com')\n    || (Boolean(githubApiUrl) && githubApiUrl!.trim().toLowerCase() != 'https://api.github.com');\n}\n\n/**\n * Returns an appropriate github token from the environment.\n *\n * @return GH_ENTERPRISE_TOKEN or GITHUB_ENTERPRISE_TOKEN or GITHUB_TOKEN if in an GHE environment, otherwise GITHUB_TOKEN\n */\n\nexport function getToken(isGHE: boolean): (string | undefined) {\n  if (isGHE) {\n    const githubEnterpiseToken = process.env.GH_ENTERPRISE_TOKEN ?? process.env.GITHUB_ENTERPRISE_TOKEN ?? process.env.GITHUB_TOKEN;\n    return githubEnterpiseToken;\n  }\n  return process.env.GITHUB_TOKEN;\n}\n\n/**\n * Checks if SSH should be used to clone repo.\n * This checks the presence and values of the GIT_USE_SSH env variable and the deprecated GITHUB_USE_SSH for legacy reason. Returns true if either of these env vars are defined and not falsy.\n */\n\nexport function detectSSH(): boolean {\n  return Boolean(process.env.GIT_USE_SSH ?? process.env.GITHUB_USE_SSH);\n}\n\n/**\n * Query the git index for changes.\n *\n * @return True if changes exist, False otherwise.\n */\nexport function diffIndex(): boolean {\n  try {\n    shell.run('git diff-index --exit-code HEAD --');\n    return false;\n  } catch (err) {\n    return true;\n  }\n}\n\n/**\n * Add files to the index.\n *\n * @param p the path.\n */\nexport function add(p: string) {\n  shell.run(`git add ${p}`);\n}\n\n/**\n * Remove files from the working tree and from the index\n *\n * @param p the path.\n */\nexport function rm(p: string, options: { recursive?: boolean } = {}) {\n  const cmd = ['git', 'rm'];\n  if (options.recursive) {\n    cmd.push('-r');\n  }\n\n  cmd.push(p);\n\n  shell.run(cmd.join(' '));\n}\n\n/**\n * Commit.\n *\n * @param message the commit message.\n */\nexport function commit(message: string) {\n  shell.run(`git commit -m \"${message}\"`);\n}\n\n/**\n * Initialize a repository.\n */\nexport function init() {\n  shell.run('git init');\n}\n\n/**\n * Cerate a tag.\n *\n * @param name tag name.\n * @returns true if the tag was created, false if it already exists.\n */\nexport function tag(name: string): boolean {\n  try {\n    shell.run(`git tag -a ${name} -m ${name}`, { capture: true });\n    return true;\n  } catch (e) {\n    if (e instanceof Error && e.message.includes('already exists')) {\n      return false;\n    }\n    throw e;\n  }\n}\n\n/**\n * Push a ref to origin.\n *\n * @param ref the ref\n */\nexport function push(ref: string) {\n  shell.run(`git push origin ${ref}`);\n}\n\n/**\n * Checkout to a new branch. Creates a new one if `options.createIfMissing` is True and the branch doesn't exist.\n *\n * @param branch the branch.\n * @param options options.\n */\nexport function checkout(branch: string, options: { createIfMissing?: boolean } ) {\n  if (options.createIfMissing) {\n    try {\n      shell.run(`git show-branch origin/${branch}`, { capture: true });\n    } catch (e) {\n      if (e instanceof Error && e.message.includes('fatal: bad sha1 reference')) {\n        console.log('Remote branch not found, creating new branch.');\n        shell.run(`git checkout -B ${branch}`);\n        return;\n      }\n    }\n  }\n  shell.run(`git checkout ${branch}`);\n}\n\n/**\n * Fetch the configured git user name for the current directory.\n * Returns undefined if not configured.\n */\nexport function username() {\n  try {\n    return shell.run('git config user.name', { capture: true });\n  } catch (err) {\n    if (err instanceof Error) {\n      console.warn(err.message);\n    }\n    return undefined;\n  }\n}\n\n/**\n * Fetch the configured git user email for the current directory.\n * Returns undefined if not configured.\n */\nexport function email() {\n  try {\n    return shell.run('git config user.email', { capture: true });\n  } catch (err) {\n    if (err instanceof Error) {\n      console.warn(err.message);\n    }\n    return undefined;\n  }\n}\n\n/**\n * Identify the committer with a username and email.\n *\n * @param user the username.\n * @param email the email address.\n */\nexport function identify(user: string, address: string) {\n  shell.run(`git config user.name \"${user}\"`);\n  shell.run(`git config user.email \"${address}\"`);\n}\n\n/**\n * Does the given branch exists on the remote.\n */\nexport function branchExistsOnRemote(repositoryUrl: string, branch: string): boolean {\n  return shell.check(`git ls-remote --exit-code --heads ${tryDetectRepositoryUrl(repositoryUrl)} ${branch}`, { capture: true });\n}\n"]}
+/**
+ * Returns the `owner/repo` slug of the `origin` remote in the current
+ * directory, or undefined if it cannot be determined (e.g. not in a git
+ * repository, or no `origin` remote configured).
+ */
+function repositorySlug() {
+    try {
+        const url = shell.run('git remote get-url origin', { capture: true });
+        return parseRepositorySlug(url);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Extracts the `owner/repo` slug from a git remote URL.
+ *
+ * Supports HTTPS (`https://github.com/owner/repo.git`), SSH
+ * (`git@github.com:owner/repo.git`, `ssh://git@github.com/owner/repo.git`)
+ * and URLs without a `.git` suffix.
+ *
+ * @returns the `owner/repo` slug, or undefined if it cannot be determined
+ */
+function parseRepositorySlug(url) {
+    const path = url
+        .trim()
+        .replace(/\.git$/, '')
+        // drop the scheme (https://, ssh://, git+ssh://, ...)
+        .replace(/^[a-z+]+:\/\//, '')
+        // normalize scp-like ssh syntax (git@host:owner/repo) to a path
+        .replace(/^git@[^:/]+[:/]/, '')
+        // strip a leading host segment (github.com/owner/repo)
+        .replace(/^[^/]+\.[^/]+\//, '');
+    const parts = path.split('/').filter(Boolean);
+    if (parts.length !== 2) {
+        return undefined;
+    }
+    return parts.join('/');
+}
+/**
+ * Returns the commit hash of HEAD in the current directory, or undefined if
+ * it cannot be determined (e.g. not in a git repository).
+ */
+function head() {
+    try {
+        return shell.run('git rev-parse HEAD', { capture: true });
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"git.js","sourceRoot":"","sources":["../../src/help/git.ts"],"names":[],"mappings":"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","sourcesContent":["import * as shell from './shell';\n\nexport interface CloneOptions {\n  /**\n   * @default 1\n   */\n  readonly depth?: number;\n\n  /**\n   * @default false\n   */\n  readonly tags?: boolean;\n\n  /**\n   * @default - default branch\n   */\n  readonly branch?: string;\n}\n\n/**\n * Clones a repository from GitHub. Requires a `GITHUB_TOKEN` env variable.\n *\n * @param repositoryUrl the repository to clone.\n * @param targetDir the clone directory.\n */\nexport function clone(repositoryUrl: string, targetDir: string, { depth = 1, tags = false, branch }: CloneOptions = {}) {\n  const cmd = ['git', 'clone'];\n\n  if (depth) {\n    cmd.push(`--depth ${depth}`);\n  }\n\n  if (branch) {\n    cmd.push(`--branch ${branch}`);\n  }\n\n  if (tags) {\n    cmd.push('--tags');\n  }\n\n  cmd.push(tryDetectRepositoryUrl(repositoryUrl));\n  cmd.push(targetDir);\n\n  shell.run(cmd.join(' '));\n}\n\nfunction tryDetectRepositoryUrl(repositoryUrl: string): string {\n  const gitHubUseSsh = detectSSH();\n  if (gitHubUseSsh) {\n    const sshRepositoryUrl = repositoryUrl.replace('/', ':');\n    return `git@${sshRepositoryUrl}.git`;\n  }\n\n  const gitHubToken = getToken(detectGHE());\n  if (!gitHubToken) {\n    throw new Error('GITHUB_TOKEN env variable is required when GITHUB_USE_SSH env variable is not used');\n  }\n  return `https://${gitHubToken}@${repositoryUrl}.git`;\n}\n\n/**\n * Checks if the current environment is an GHE environment.\n *\n * This check is using GITHUB_API_URL set in GitHub Actions workflow, as well as common gh cli env variables.\n * https://docs.github.com/en/actions/learn-github-actions/variables#default-environment-variables\n * https://cli.github.com/manual/gh_help_environment\n *\n * @return - `true` if GH_HOST or GITHUB_API_URL env var are defined and not equal to the public github endpoint, otherwise `false`\n */\nexport function detectGHE(): boolean {\n  const githubApiUrl = process.env.GITHUB_API_URL;\n  const ghHost = process.env.GH_HOST;\n\n  return (Boolean(ghHost) && ghHost!.trim().toLowerCase() != 'github.com')\n    || (Boolean(githubApiUrl) && githubApiUrl!.trim().toLowerCase() != 'https://api.github.com');\n}\n\n/**\n * Returns an appropriate github token from the environment.\n *\n * @return GH_ENTERPRISE_TOKEN or GITHUB_ENTERPRISE_TOKEN or GITHUB_TOKEN if in an GHE environment, otherwise GITHUB_TOKEN\n */\n\nexport function getToken(isGHE: boolean): (string | undefined) {\n  if (isGHE) {\n    const githubEnterpiseToken = process.env.GH_ENTERPRISE_TOKEN ?? process.env.GITHUB_ENTERPRISE_TOKEN ?? process.env.GITHUB_TOKEN;\n    return githubEnterpiseToken;\n  }\n  return process.env.GITHUB_TOKEN;\n}\n\n/**\n * Checks if SSH should be used to clone repo.\n * This checks the presence and values of the GIT_USE_SSH env variable and the deprecated GITHUB_USE_SSH for legacy reason. Returns true if either of these env vars are defined and not falsy.\n */\n\nexport function detectSSH(): boolean {\n  return Boolean(process.env.GIT_USE_SSH ?? process.env.GITHUB_USE_SSH);\n}\n\n/**\n * Query the git index for changes.\n *\n * @return True if changes exist, False otherwise.\n */\nexport function diffIndex(): boolean {\n  try {\n    shell.run('git diff-index --exit-code HEAD --');\n    return false;\n  } catch (err) {\n    return true;\n  }\n}\n\n/**\n * Add files to the index.\n *\n * @param p the path.\n */\nexport function add(p: string) {\n  shell.run(`git add ${p}`);\n}\n\n/**\n * Remove files from the working tree and from the index\n *\n * @param p the path.\n */\nexport function rm(p: string, options: { recursive?: boolean } = {}) {\n  const cmd = ['git', 'rm'];\n  if (options.recursive) {\n    cmd.push('-r');\n  }\n\n  cmd.push(p);\n\n  shell.run(cmd.join(' '));\n}\n\n/**\n * Commit.\n *\n * @param message the commit message.\n */\nexport function commit(message: string) {\n  shell.run(`git commit -m \"${message}\"`);\n}\n\n/**\n * Initialize a repository.\n */\nexport function init() {\n  shell.run('git init');\n}\n\n/**\n * Cerate a tag.\n *\n * @param name tag name.\n * @returns true if the tag was created, false if it already exists.\n */\nexport function tag(name: string): boolean {\n  try {\n    shell.run(`git tag -a ${name} -m ${name}`, { capture: true });\n    return true;\n  } catch (e) {\n    if (e instanceof Error && e.message.includes('already exists')) {\n      return false;\n    }\n    throw e;\n  }\n}\n\n/**\n * Push a ref to origin.\n *\n * @param ref the ref\n */\nexport function push(ref: string) {\n  shell.run(`git push origin ${ref}`);\n}\n\n/**\n * Checkout to a new branch. Creates a new one if `options.createIfMissing` is True and the branch doesn't exist.\n *\n * @param branch the branch.\n * @param options options.\n */\nexport function checkout(branch: string, options: { createIfMissing?: boolean } ) {\n  if (options.createIfMissing) {\n    try {\n      shell.run(`git show-branch origin/${branch}`, { capture: true });\n    } catch (e) {\n      if (e instanceof Error && e.message.includes('fatal: bad sha1 reference')) {\n        console.log('Remote branch not found, creating new branch.');\n        shell.run(`git checkout -B ${branch}`);\n        return;\n      }\n    }\n  }\n  shell.run(`git checkout ${branch}`);\n}\n\n/**\n * Fetch the configured git user name for the current directory.\n * Returns undefined if not configured.\n */\nexport function username() {\n  try {\n    return shell.run('git config user.name', { capture: true });\n  } catch (err) {\n    if (err instanceof Error) {\n      console.warn(err.message);\n    }\n    return undefined;\n  }\n}\n\n/**\n * Fetch the configured git user email for the current directory.\n * Returns undefined if not configured.\n */\nexport function email() {\n  try {\n    return shell.run('git config user.email', { capture: true });\n  } catch (err) {\n    if (err instanceof Error) {\n      console.warn(err.message);\n    }\n    return undefined;\n  }\n}\n\n/**\n * Identify the committer with a username and email.\n *\n * @param user the username.\n * @param email the email address.\n */\nexport function identify(user: string, address: string) {\n  shell.run(`git config user.name \"${user}\"`);\n  shell.run(`git config user.email \"${address}\"`);\n}\n\n/**\n * Does the given branch exists on the remote.\n */\nexport function branchExistsOnRemote(repositoryUrl: string, branch: string): boolean {\n  return shell.check(`git ls-remote --exit-code --heads ${tryDetectRepositoryUrl(repositoryUrl)} ${branch}`, { capture: true });\n}\n\n/**\n * Returns the `owner/repo` slug of the `origin` remote in the current\n * directory, or undefined if it cannot be determined (e.g. not in a git\n * repository, or no `origin` remote configured).\n */\nexport function repositorySlug(): string | undefined {\n  try {\n    const url = shell.run('git remote get-url origin', { capture: true });\n    return parseRepositorySlug(url);\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Extracts the `owner/repo` slug from a git remote URL.\n *\n * Supports HTTPS (`https://github.com/owner/repo.git`), SSH\n * (`git@github.com:owner/repo.git`, `ssh://git@github.com/owner/repo.git`)\n * and URLs without a `.git` suffix.\n *\n * @returns the `owner/repo` slug, or undefined if it cannot be determined\n */\nexport function parseRepositorySlug(url: string): string | undefined {\n  const path = url\n    .trim()\n    .replace(/\\.git$/, '')\n    // drop the scheme (https://, ssh://, git+ssh://, ...)\n    .replace(/^[a-z+]+:\\/\\//, '')\n    // normalize scp-like ssh syntax (git@host:owner/repo) to a path\n    .replace(/^git@[^:/]+[:/]/, '')\n    // strip a leading host segment (github.com/owner/repo)\n    .replace(/^[^/]+\\.[^/]+\\//, '');\n  const parts = path.split('/').filter(Boolean);\n  if (parts.length !== 2) {\n    return undefined;\n  }\n  return parts.join('/');\n}\n\n/**\n * Returns the commit hash of HEAD in the current directory, or undefined if\n * it cannot be determined (e.g. not in a git repository).\n */\nexport function head(): string | undefined {\n  try {\n    return shell.run('git rev-parse HEAD', { capture: true });\n  } catch {\n    return undefined;\n  }\n}\n"]}

package/lib/targets/github.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Creates GitHub releases via the GitHub REST API, tolerating a release that
+ * already exists so that re-running a release is a no-op rather than a
+ * failure.
+ */
+/**
+ * Options for creating a GitHub release.
+ */
+export interface GitHubReleaseOptions {
+    /**
+     * The tag name of the release (e.g. `v1.2.3`).
+     */
+    readonly tag: string;
+    /**
+     * The repository to release to, in `owner/repo` format.
+     */
+    readonly repository: string;
+    /**
+     * The token used to authenticate against the GitHub API.
+     */
+    readonly token: string;
+    /**
+     * Markdown body of the release (release notes).
+     *
+     * @default - no release notes
+     */
+    readonly body?: string;
+    /**
+     * The commitish the release tag will point to, if the tag does not exist
+     * yet. Ignored by GitHub when the tag already exists.
+     *
+     * @default - the repository's default branch
+     */
+    readonly target?: string;
+    /**
+     * Mark the release as a prerelease.
+     *
+     * @default false
+     */
+    readonly prerelease?: boolean;
+    /**
+     * Whether this release should be explicitly marked as the latest release
+     * (`true`) or explicitly not marked as the latest release (`false`).
+     *
+     * Passed to the GitHub API as `make_latest`.
+     *
+     * @default - not sent; GitHub determines the latest release
+     */
+    readonly latest?: boolean;
+    /**
+     * Base URL of the GitHub API.
+     *
+     * @default 'https://api.github.com'
+     */
+    readonly apiUrl?: string;
+}
+/**
+ * The outcome of `createGitHubRelease`.
+ */
+export type GitHubReleaseResult = 'created' | 'already_exists';
+/**
+ * Creates a GitHub release.
+ *
+ * Returns `'already_exists'` instead of failing when a release for the tag
+ * already exists, so that a re-run of a (partially failed) release workflow is
+ * a no-op rather than a failure. The existing release is left untouched. Any
+ * other error is thrown.
+ */
+export declare function createGitHubRelease(options: GitHubReleaseOptions): Promise<GitHubReleaseResult>;

package/lib/targets/github.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * Creates GitHub releases via the GitHub REST API, tolerating a release that
+ * already exists so that re-running a release is a no-op rather than a
+ * failure.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGitHubRelease = createGitHubRelease;
+/**
+ * Creates a GitHub release.
+ *
+ * Returns `'already_exists'` instead of failing when a release for the tag
+ * already exists, so that a re-run of a (partially failed) release workflow is
+ * a no-op rather than a failure. The existing release is left untouched. Any
+ * other error is thrown.
+ */
+async function createGitHubRelease(options) {
+    const apiUrl = (options.apiUrl ?? 'https://api.github.com').replace(/\/+$/, '');
+    const response = await fetch(`${apiUrl}/repos/${options.repository}/releases`, {
+        method: 'POST',
+        headers: {
+            'Accept': 'application/vnd.github+json',
+            'Authorization': `Bearer ${options.token}`,
+            'Content-Type': 'application/json',
+            'X-GitHub-Api-Version': '2022-11-28',
+        },
+        body: JSON.stringify({
+            tag_name: options.tag,
+            name: options.tag,
+            body: options.body ?? '',
+            prerelease: options.prerelease ?? false,
+            ...(options.target ? { target_commitish: options.target } : {}),
+            ...(options.latest !== undefined ? { make_latest: String(options.latest) } : {}),
+        }),
+    });
+    if (response.ok) {
+        return 'created';
+    }
+    const body = await response.text();
+    if (response.status === 422 && releaseAlreadyExists(body)) {
+        return 'already_exists';
+    }
+    throw new Error(`GitHub release creation failed: HTTP ${response.status} ${response.statusText}: ${body}`);
+}
+/**
+ * Whether a 422 response body indicates that a release for the tag already
+ * exists.
+ *
+ * The API reports this as
+ * `{ errors: [{ resource: 'Release', code: 'already_exists', field: 'tag_name' }] }`.
+ */
+function releaseAlreadyExists(responseBody) {
+    try {
+        const parsed = JSON.parse(responseBody);
+        const errors = Array.isArray(parsed?.errors) ? parsed.errors : [];
+        return errors.some((e) => e?.resource === 'Release' && e?.code === 'already_exists');
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -8,6 +8,7 @@
   "bin": {
     "jsii-release": "./bin/jsii-release-shim",
     "jsii-release-ca": "./bin/jsii-release-shim",
+    "jsii-release-github": "./bin/jsii-release-shim",
     "jsii-release-golang": "./bin/jsii-release-shim",
     "jsii-release-maven": "./bin/jsii-release-shim",
     "jsii-release-npm": "./bin/jsii-release-shim",
@@ -16,6 +17,7 @@
     "jsii-release-shim": "bin/jsii-release-shim",
     "publib": "bin/publib",
     "publib-ca": "bin/publib-ca",
+    "publib-github": "bin/publib-github",
     "publib-golang": "bin/publib-golang",
     "publib-maven": "bin/publib-maven",
     "publib-npm": "bin/publib-npm",
@@ -97,7 +99,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.0",
+  "version": "0.3.1",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [

package/package.json.bak

@@ -8,6 +8,7 @@
   "bin": {
     "jsii-release": "./bin/jsii-release-shim",
     "jsii-release-ca": "./bin/jsii-release-shim",
+    "jsii-release-github": "./bin/jsii-release-shim",
     "jsii-release-golang": "./bin/jsii-release-shim",
     "jsii-release-maven": "./bin/jsii-release-shim",
     "jsii-release-npm": "./bin/jsii-release-shim",
@@ -16,6 +17,7 @@
     "jsii-release-shim": "bin/jsii-release-shim",
     "publib": "bin/publib",
     "publib-ca": "bin/publib-ca",
+    "publib-github": "bin/publib-github",
     "publib-golang": "bin/publib-golang",
     "publib-maven": "bin/publib-maven",
     "publib-npm": "bin/publib-npm",
@@ -97,7 +99,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.0",
+  "version": "0.3.1",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [