tessello 0.1.0 → 0.2.0

package/README.md

@@ -9,3 +9,30 @@ npx tessello validate my-module --json   # the report as JSON
 ```
 
 It checks the Module against the Tessello [Convention](https://github.com/craftskillz/tessello/blob/main/convention/CONVENTION.md) and exits with 1 when the Module is not installable, 0 otherwise. Every error and warning names the file and says what to change: fix them until there is no error left, then zip the *contents* of the folder (not the folder itself).
+
+## Publishing a Module
+
+```sh
+npx tessello publish my-module.zip --url https://me.github.io/modules/my-module-1.0.0.zip --accept-terms
+```
+
+Host the `.zip` somewhere first, then run this. `tessello publish` prepares the Marketplace listing for that exact package and opens the pull request, with no Tessello server in between. A new Module awaits the Maintainer's Approval; a new version of a listed Module is merged automatically once the CI passes.
+
+Before anything is opened it runs, on your machine, the checks the Marketplace CI will run: the package is validated, the URL must answer 200 with the same bytes as your `.zip` and send `Access-Control-Allow-Origin: *` (GitHub Pages does; GitHub Releases does not), the version must be new, and the Namespace must be yours. Every problem is printed with a `✗` and the command exits with 1.
+
+| Option | |
+| --- | --- |
+| `--url <URL>` | Where you published this exact `.zip` (required). |
+| `--accept-terms` | You have read [PUBLISHING.md](https://github.com/craftskillz/tessello-marketplace/blob/main/PUBLISHING.md) and accept its terms. Required: the pull request ticks the box in your name. |
+| `--source <repo URL>` | `https://github.com/<owner>/<repo>`, for a new Module. Default: the git remote `origin` of the current folder, when it is on GitHub. |
+| `--license <SPDX>` | For a new Module. Default: the license GitHub reports for the source. |
+| `--tag <tag>` | A tag for the listing; repeat it for several. They replace the previous tags. |
+| `--marketplace <owner/name>` | Another Marketplace repository. Default: `craftskillz/tessello-marketplace`. |
+| `--out <folder>` | Where the listing is written when no pull request is opened. Default: `./tessello-listing`. |
+| `--dry-run` | Run every check and write the listing, but open nothing. |
+
+With the [GitHub CLI](https://cli.github.com) (`gh`) installed and logged in, the pull request is opened for you: your fork of the Marketplace is created and synced if you cannot push to it, a branch `publish/<namespace>-<name>-<version>` carries the listing, and the pull request is opened from it. If an earlier run stopped half-way, running it again reuses that branch and updates the listing on it; if its pull request is already open, the command shows it. If a step fails, it says which one and keeps the listing in the `--out` folder so nothing is lost.
+
+Without `gh`, or with `--dry-run`, the listing is written to `tessello-listing/modules/<namespace>/<name>/entry.json`. Without `gh` the command also lists the steps by hand: fork the Marketplace, add that file at the same path, open a pull request, tick the box.
+
+It exits with 0 when done, 1 when a check or a step fails, and 2 on a usage error.

package/cli.js

@@ -1,15 +1,21 @@
 #!/usr/bin/env node
 import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
+import { execCommand, publishCommand } from "./publish-command.js";
 import { formatReport, validatePath } from "./validate-command.js";
 const USAGE = `Usage: tessello <command>
 
 Commands:
   validate <path> [--json]   Check a Module folder or .zip against the Tessello Convention.
-                             Exits with 1 if the Module is not installable.`;
+                             Exits with 1 if the Module is not installable.
+  publish <package.zip> --url <URL>
+                             Prepare the Marketplace listing for a package you have published
+                             at <URL> and open the pull request (run \`tessello publish\` for options).`;
 /** Runs the CLI and returns the process exit code: 0 success, 1 invalid Module, 2 usage error. */
-export async function run(args, output) {
+export async function run(args, output, deps = {}) {
     const [command, ...rest] = args;
+    if (command === "publish")
+        return publishCommand(rest, output, await publishDeps(deps));
     if (command === "validate") {
         const json = rest.includes("--json");
         const paths = rest.filter((arg) => arg !== "--json");
@@ -36,6 +42,24 @@ export async function run(args, output) {
     output.err(`Unknown command "${command}".\n\n${USAGE}`);
     return 2;
 }
+/** The real gh (when installed and logged in), the GitHub token it holds, and the process's folder; `overrides` win. */
+async function publishDeps(overrides) {
+    const realGh = (args) => execCommand("gh", args);
+    const gh = "gh" in overrides ? overrides.gh : (await realGh(["auth", "status"])).code === 0 ? realGh : null;
+    let token = process.env.GITHUB_TOKEN;
+    if (gh && !("gh" in overrides) && !overrides.github) {
+        const result = await gh(["auth", "token"]);
+        if (result.code === 0 && result.stdout.trim())
+            token = result.stdout.trim();
+    }
+    return {
+        gh,
+        github: overrides.github ?? { apiUrl: "https://api.github.com", ...(token && { token }) },
+        cwd: overrides.cwd ?? process.cwd(),
+        ...(overrides.git && { git: overrides.git }),
+        ...(overrides.wait && { wait: overrides.wait }),
+    };
+}
 // npm runs the CLI through a symbolic link (node_modules/.bin/tessello), hence the real path.
 if (process.argv[1] && realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) {
     process.exitCode = await run(process.argv.slice(2), {

package/listing.js

@@ -0,0 +1,189 @@
+import { readZip } from "@tessello/convention";
+import { checkPullRequest, parseEntry, sha256 } from "@tessello/marketplace";
+export const MARKETPLACE = "craftskillz/tessello-marketplace";
+export const TERMS = "I have read PUBLISHING.md and accept its terms.";
+const GITHUB_SOURCE = /^https:\/\/github\.com\/([A-Za-z0-9-]+)\/([A-Za-z0-9._-]+)$/;
+const DOWNLOAD_TIMEOUT_MS = 60_000;
+/** Prepares the listing a pull request would carry, and checks it locally as the Marketplace CI will. Never throws for a Creator's mistake: returns the problems. */
+export async function prepareListing(request) {
+    const fail = (...problems) => ({ ok: false, problems });
+    const doFetch = request.github.fetch ?? fetch;
+    const { report } = readZip(request.zip);
+    const errors = report.issues.filter((i) => i.severity === "error");
+    if (errors.length > 0 || !report.manifest)
+        return fail(...errors.map((i) => i.message));
+    const { id, version } = report.manifest;
+    const [namespace = "", name = ""] = id.slice(1).split("/");
+    const folder = `${namespace}/${name}`;
+    const path = `modules/${folder}/entry.json`;
+    const hash = await sha256(request.zip);
+    const hosted = await checkHosting(request.url, hash, doFetch);
+    if (hosted)
+        return fail(hosted);
+    try {
+        const api = githubReader(request.github, request.marketplace);
+        const previousBytes = await api.raw(path);
+        let entry;
+        let change;
+        const listed = { version, url: request.url, sha256: hash };
+        if (previousBytes === null) {
+            change = "new-module";
+            if (!request.source)
+                return fail("This Module is not listed yet: pass --source https://github.com/<owner>/<repo>, the public repository of its source.");
+            const match = GITHUB_SOURCE.exec(request.source);
+            if (!match)
+                return fail(`--source must be exactly https://github.com/<owner>/<repo>, got "${request.source}".`);
+            const license = request.license ?? (await api.licenseOf(match[1], match[2]));
+            if (!license)
+                return fail(`GitHub reports no license for ${request.source}: add one to the repository, or pass --license <SPDX identifier>.`);
+            entry = { id, source: request.source, license, ...(request.tags && { tags: request.tags }), versions: [listed] };
+        }
+        else {
+            change = "new-version";
+            const parsed = parseEntry(JSON.parse(new TextDecoder().decode(previousBytes)));
+            if (!parsed.entry)
+                return fail(`The listing ${path} in ${request.marketplace} is not valid: ${parsed.issues.map((i) => i.message).join(" ")}`);
+            const previous = parsed.entry;
+            const existing = previous.versions.find((v) => v.version === version);
+            if (existing) {
+                return fail(existing.url === request.url && existing.sha256 === hash ? `Version ${version} of ${id} is already listed.` : `Version ${version} of ${id} is already listed with another package: a published version cannot change. Publish a new version instead.`);
+            }
+            if (request.source !== undefined && request.source !== previous.source)
+                return fail(`${id} is listed with the source ${previous.source}: only the Maintainer changes it, by hand.`);
+            if (request.license !== undefined && request.license !== previous.license)
+                return fail(`${id} is listed with the license ${previous.license}: only the Maintainer changes it, by hand.`);
+            entry = { ...previous, ...(request.tags && { tags: request.tags }), versions: [...previous.versions, listed] };
+        }
+        const json = `${JSON.stringify(entry, null, 2)}\n`;
+        const notes = [];
+        let author = request.author;
+        if (!author) {
+            const account = await api.account(namespace);
+            author = { login: account?.login ?? namespace, id: account?.id ?? 0 };
+            notes.push("Namespace ownership is checked by the CI: the GitHub account that opens the pull request is not known here.");
+        }
+        const check = await checkPullRequest({
+            author,
+            body: `- [x] ${TERMS}`,
+            source: pullRequestSource({ api, path, json, downloads: new Map([[request.url, request.zip]]), doFetch }),
+        });
+        const issues = request.author ? check.issues : check.issues.filter((i) => !i.code.startsWith("namespace/not-owner"));
+        if (issues.length > 0)
+            return fail(...issues.map((i) => i.message));
+        return { ok: true, listing: { folder, path, entry, json, change, decision: check.decision, version, notes } };
+    }
+    catch (error) {
+        return fail(`Could not read GitHub: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/** The problem with the URL, or null when it serves exactly these bytes to any web page. */
+async function checkHosting(url, hash, doFetch) {
+    let response;
+    let bytes;
+    try {
+        response = await doFetch(url, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) });
+        if (response.status !== 200) {
+            await response.body?.cancel();
+            return `${url} answered ${response.status}: the package must be published there before it is listed.`;
+        }
+        bytes = new Uint8Array(await response.arrayBuffer());
+    }
+    catch (error) {
+        return `Could not download ${url}: ${error instanceof Error ? error.message : String(error)}`;
+    }
+    if ((await sha256(bytes)) !== hash)
+        return `${url} serves other bytes than this .zip: publish this exact file there.`;
+    if (response.headers.get("access-control-allow-origin") !== "*") {
+        return `${url} does not send the header "Access-Control-Allow-Origin: *", so the Host could not download it from a web page. GitHub Pages sends it; GitHub Releases does not.`;
+    }
+    return null;
+}
+function githubReader(access, marketplace) {
+    const doFetch = access.fetch ?? fetch;
+    const headers = { Accept: "application/vnd.github+json", "X-GitHub-Api-Version": "2022-11-28", "User-Agent": "tessello-cli", ...(access.token && { Authorization: `Bearer ${access.token}` }) };
+    /** The response, or null on 404. Any other failure throws. */
+    const get = async (url, accept) => {
+        const response = await doFetch(url, { headers: accept ? { ...headers, Accept: accept } : headers });
+        if (response.status === 404) {
+            await response.body?.cancel();
+            return null;
+        }
+        if (!response.ok)
+            throw new Error(`GitHub answered ${response.status} to GET ${url}`);
+        return response;
+    };
+    const json = async (endpoint) => (await get(`${access.apiUrl}${endpoint}`))?.json() ?? null;
+    return {
+        repo: `/repos/${marketplace}`,
+        async raw(path) {
+            const response = await get(`${access.apiUrl}/repos/${marketplace}/contents/${path.split("/").map(encodeURIComponent).join("/")}?ref=main`, "application/vnd.github.raw+json");
+            return response && new Uint8Array(await response.arrayBuffer());
+        },
+        json,
+        async account(login) {
+            const found = await json(`/users/${encodeURIComponent(login)}`);
+            return found && { login: found.login, id: found.id, type: found.type === "Organization" ? "Organization" : "User" };
+        },
+        async licenseOf(owner, name) {
+            const found = await json(`/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}`);
+            const license = found?.license?.spdx_id;
+            return license && license !== "NOASSERTION" ? license : null;
+        },
+        async ok(endpoint) {
+            try {
+                const response = await doFetch(`${access.apiUrl}${endpoint}`, { headers });
+                await response.body?.cancel();
+                return response.ok;
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+}
+/** The Marketplace's main branch as the base, and the same with the new entry.json as the head. */
+function pullRequestSource(input) {
+    const { api, path: listingPath, json, downloads } = input;
+    const bytes = new TextEncoder().encode(json);
+    const listingFolder = listingPath.slice(0, listingPath.lastIndexOf("/"));
+    const contents = (folder) => `${api.repo}/contents/${folder.split("/").map(encodeURIComponent).join("/")}?ref=main`;
+    return {
+        async changedFiles() {
+            return [{ path: listingPath }];
+        },
+        async file(side, path) {
+            return side === "head" && path === listingPath ? bytes : api.raw(path);
+        },
+        async folder(side, path) {
+            const found = await api.json(contents(path));
+            const files = new Map();
+            const others = [];
+            for (const item of Array.isArray(found) ? found : []) {
+                const content = item.type === "file" ? await api.raw(item.path) : null;
+                if (content)
+                    files.set(item.name, content);
+                else
+                    others.push(item.name);
+            }
+            if (side === "head" && path === listingFolder)
+                files.set("entry.json", bytes);
+            return { files, others };
+        },
+        account: (login) => api.account(login),
+        isPublicMember: (organization, login) => api.ok(`/orgs/${encodeURIComponent(organization)}/public_members/${encodeURIComponent(login)}`),
+        async isMaintainer(login) {
+            const found = await api.json(`${api.repo}/collaborators/${encodeURIComponent(login)}/permission`).catch(() => null);
+            return ["admin", "maintain", "write"].includes(found?.permission);
+        },
+        async repository(owner, name) {
+            const found = await api.json(`/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}`);
+            if (!found)
+                return null;
+            const license = found.license?.spdx_id;
+            return { private: found.private, license: license && license !== "NOASSERTION" ? license : null };
+        },
+        async download(url) {
+            return downloads.get(url) ?? null;
+        },
+    };
+}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "tessello",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Tessello command-line tool.",
   "license": "MIT",
   "type": "module",
   "dependencies": {
-    "@tessello/convention": "0.1.0"
+    "@tessello/convention": "0.1.0",
+    "@tessello/marketplace": "0.1.0"
   },
   "bin": {
     "tessello": "./cli.js"

package/publish-command.js

@@ -0,0 +1,206 @@
+import { execFile } from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { parseArgs } from "node:util";
+import { MARKETPLACE, prepareListing, TERMS } from "./listing.js";
+export const PUBLISH_USAGE = `Usage: tessello publish <package.zip> --url <URL> [options]
+
+Options:
+  --url <URL>               Where you published this exact .zip (required).
+  --source <repo URL>       https://github.com/<owner>/<repo>, for a new Module (default: the git remote "origin").
+  --license <SPDX>          For a new Module (default: the license GitHub reports for the source).
+  --tag <tag>               A tag for the listing; repeat it for several. Replaces the previous tags.
+  --marketplace <owner/name> The Marketplace repository (default: ${MARKETPLACE}).
+  --accept-terms            You have read PUBLISHING.md and accept its terms.
+  --out <folder>            Where to write the listing when no pull request is opened (default: ./tessello-listing).
+  --dry-run                 Check everything and write the listing, but open no pull request.`;
+/** What happens to the pull request, from the decision of the same check as the CI. */
+const NEXT = {
+    approval: "a new Module, so the pull request awaits the Maintainer's Approval; it is listed once approved.",
+    merge: "the pull request is merged automatically once the CI passes.",
+    maintainer: "this change goes to the Maintainer, who merges it by hand.",
+    refuse: "the CI would refuse this pull request.",
+};
+/** Prepares or updates a listing and opens the pull request. Exit code: 0 done, 1 refused or failed, 2 usage error. */
+export async function publishCommand(args, output, deps) {
+    let parsed;
+    try {
+        parsed = parseArgs({
+            args,
+            allowPositionals: true,
+            options: {
+                url: { type: "string" },
+                source: { type: "string" },
+                license: { type: "string" },
+                tag: { type: "string", multiple: true },
+                marketplace: { type: "string" },
+                "accept-terms": { type: "boolean" },
+                out: { type: "string" },
+                "dry-run": { type: "boolean" },
+            },
+        });
+    }
+    catch (e) {
+        output.err(`${e.message}\n\n${PUBLISH_USAGE}`);
+        return 2;
+    }
+    const { values, positionals } = parsed;
+    if (positionals.length !== 1 || !values.url) {
+        output.err(PUBLISH_USAGE);
+        return 2;
+    }
+    const marketplace = values.marketplace ?? MARKETPLACE;
+    if (!values["accept-terms"]) {
+        output.err(`Publishing means accepting the terms: read https://github.com/${marketplace}/blob/main/PUBLISHING.md, then run this command again with --accept-terms (ticking the box in the pull request is your acceptance).`);
+        return 2;
+    }
+    let zip;
+    try {
+        zip = new Uint8Array(await readFile(resolve(deps.cwd, positionals[0])));
+    }
+    catch (e) {
+        output.err(`Cannot read "${positionals[0]}": ${e.message}`);
+        return 2;
+    }
+    const author = await authorOf(deps.gh);
+    const prepared = await prepareListing({ zip, url: values.url, marketplace, author, github: deps.github, source: values.source ?? (await sourceFromGit(deps)), license: values.license, tags: values.tag });
+    if (!prepared.ok) {
+        for (const problem of prepared.problems)
+            output.err(`✗ ${problem}`);
+        return 1;
+    }
+    const { listing } = prepared;
+    for (const note of listing.notes)
+        output.out(`Note: ${note}`);
+    output.out(`${listing.entry.id} ${listing.version}: ${NEXT[listing.decision]}`);
+    const outFolder = resolve(deps.cwd, values.out ?? "tessello-listing");
+    if (deps.gh && !values["dry-run"]) {
+        return openPullRequest({ gh: deps.gh, marketplace, listing, author, output, save: () => writeListing(outFolder, listing), wait: deps.wait ?? ((ms) => new Promise((done) => setTimeout(done, ms))) });
+    }
+    const written = await writeListing(outFolder, listing);
+    output.out(`Listing written to ${written}`);
+    if (!deps.gh) {
+        output.out([
+            "To publish it by hand:",
+            `  1. fork ${marketplace} on GitHub;`,
+            `  2. add that file at ${listing.path} in your fork;`,
+            `  3. open a pull request to ${marketplace};`,
+            "  4. tick the box saying you have read PUBLISHING.md and accept its terms.",
+        ].join("\n"));
+    }
+    return 0;
+}
+async function writeListing(folder, listing) {
+    const file = join(folder, listing.path);
+    await mkdir(dirname(file), { recursive: true });
+    await writeFile(file, listing.json);
+    return file;
+}
+/** The GitHub account gh is logged in with, or null without gh. */
+async function authorOf(gh) {
+    if (!gh)
+        return null;
+    const result = await gh(["api", "user"]);
+    if (result.code !== 0)
+        return null;
+    try {
+        const { login, id } = JSON.parse(result.stdout);
+        return typeof login === "string" && typeof id === "number" ? { login, id } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** A new fork is tried this many times, this long apart: 30 s in all. */
+const FORK_TRIES = 10;
+const FORK_WAIT_MS = 3000;
+/** Opens the pull request through gh, only with `gh api`, `gh repo` and `gh pr`. */
+async function openPullRequest(opening) {
+    const { gh, marketplace, listing, author, output } = opening;
+    const stop = async (step, result) => {
+        output.err(`✗ ${step} failed: ${result.stderr.trim() || result.stdout.trim() || `gh exited with ${result.code}`}`);
+        output.err(`The listing was written to ${await opening.save()} so nothing is lost.`);
+        return 1;
+    };
+    if (!author)
+        return stop("Reading your GitHub account with `gh api user`", { code: 1, stdout: "", stderr: "run `gh auth login`, or use --dry-run" });
+    const login = author.login;
+    const repoName = marketplace.split("/")[1] ?? marketplace;
+    const pushed = await gh(["api", `repos/${marketplace}`, "--jq", ".permissions.push"]);
+    if (pushed.code !== 0)
+        return stop("Reading your permissions on the Marketplace", pushed);
+    const push = pushed.stdout.trim() === "true";
+    const target = push ? marketplace : `${login}/${repoName}`;
+    if (!push) {
+        const fork = await gh(["repo", "fork", marketplace, "--clone=false", "--default-branch-only"]);
+        if (fork.code !== 0)
+            return stop(`Forking ${marketplace}`, fork);
+        // GitHub creates a new fork in the background: it is synced again until it is ready.
+        let sync = await gh(["repo", "sync", target, "--source", marketplace, "--branch", "main"]);
+        for (let tries = 1; sync.code !== 0 && tries < FORK_TRIES; tries++) {
+            await opening.wait(FORK_WAIT_MS);
+            sync = await gh(["repo", "sync", target, "--source", marketplace, "--branch", "main"]);
+        }
+        if (sync.code !== 0)
+            return stop(`Syncing ${target} with ${marketplace}`, sync);
+    }
+    const base = await gh(["api", `repos/${target}/git/ref/heads/main`, "--jq", ".object.sha"]);
+    if (base.code !== 0)
+        return stop(`Reading the main branch of ${target}`, base);
+    const branch = `publish/${listing.folder.replace("/", "-")}-${listing.version}`;
+    const created = await gh(["api", "-X", "POST", `repos/${target}/git/refs`, "-f", `ref=refs/heads/${branch}`, "-f", `sha=${base.stdout.trim()}`]);
+    // The branch of an earlier run that stopped half-way is reused: the listing on it is updated.
+    if (created.code !== 0 && !/already exists/i.test(created.stderr))
+        return stop(`Creating the branch ${branch} in ${target}`, created);
+    const existing = await gh(["api", `repos/${target}/contents/${listing.path}?ref=${branch}`, "--jq", ".sha"]);
+    const fileSha = existing.code === 0 ? existing.stdout.trim() : "";
+    const title = `${listing.entry.id} ${listing.version}`;
+    const put = await gh([
+        "api", "-X", "PUT", `repos/${target}/contents/${listing.path}`,
+        "-f", `message=${title}`,
+        "-f", `content=${Buffer.from(listing.json).toString("base64")}`,
+        "-f", `branch=${branch}`,
+        ...(fileSha ? ["-f", `sha=${fileSha}`] : []),
+    ]);
+    if (put.code !== 0)
+        return stop(`Adding ${listing.path} to ${target}`, put);
+    const what = listing.change === "new-module" ? "a new Module" : `a new version (${listing.version})`;
+    const body = [
+        "<!-- One pull request changes one listing folder, modules/<namespace>/<name>/, and nothing else. -->",
+        "",
+        `**Module:** \`${listing.entry.id}\``,
+        "",
+        `**What this pull request does:** ${what}`,
+        "",
+        `- [x] ${TERMS}`,
+        "",
+        "Opened with `tessello publish`.",
+    ].join("\n");
+    const pr = await gh(["pr", "create", "--repo", marketplace, "--base", "main", "--head", push ? branch : `${login}:${branch}`, "--title", title, "--body", body]);
+    const open = /already exists:\s*(\S+)/.exec(pr.stderr);
+    if (pr.code !== 0 && open)
+        output.out(`A pull request for this version is already open: ${open[1]}`);
+    else if (pr.code !== 0)
+        return stop("Opening the pull request", pr);
+    else
+        output.out(pr.stdout.trim());
+    output.out(`Next: ${NEXT[listing.decision]}`);
+    return 0;
+}
+/** The GitHub repository of the git remote "origin" in cwd, as https://github.com/<owner>/<repo>, or undefined. */
+async function sourceFromGit(deps) {
+    const git = deps.git ?? ((args) => execCommand("git", args, deps.cwd));
+    const result = await git(["remote", "get-url", "origin"]).catch(() => null);
+    if (!result || result.code !== 0)
+        return undefined;
+    const match = /^(?:git@github\.com:|https:\/\/github\.com\/)([A-Za-z0-9-]+)\/([A-Za-z0-9._-]+?)(?:\.git)?\/?$/.exec(result.stdout.trim());
+    return match ? `https://github.com/${match[1]}/${match[2]}` : undefined;
+}
+/** Runs a program with these arguments, never through a shell. Resolves with its exit code and output. */
+export function execCommand(file, args, cwd) {
+    return new Promise((done) => {
+        execFile(file, args, { cwd }, (error, stdout, stderr) => {
+            done({ code: error ? (typeof error.code === "number" ? error.code : 1) : 0, stdout, stderr });
+        });
+    });
+}