@valbuild/cli 0.144.4 → 0.144.5

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @valbuild/cli
 
+## 0.144.5
+
+### Patch Changes
+
+- [#830](https://github.com/valbuild/val/pull/830) [`0ee047a`](https://github.com/valbuild/val/commit/0ee047a5c527f0122b4aa1aa167a0fbe4849fc37) Thanks [@freekh](https://github.com/freekh)! - `val connect` now opens [admin.val.build/new](https://admin.val.build/new?hosting=own) in your browser, on "your own hosting", with the GitHub repository and the `val.config.ts` project it found filled in. It says what it found, and prints the link too, for when no browser opens.
+
+  `npm create @valbuild` now ends by saying how to connect the new project: push it to GitHub, then pick it on admin.val.build/new or run `val connect`. `@valbuild/init` links to the same page, and now reads the GitHub repository from `origin` correctly.
+
+- Updated dependencies [[`39e8db3`](https://github.com/valbuild/val/commit/39e8db34cf56c6c43ffff0d3acfe8e0839fa55a9)]:
+  - @valbuild/server@0.144.5
+  - @valbuild/shared@0.144.5
+  - @valbuild/language-server@0.144.5
+
 ## 0.144.4
 
 ### Patch Changes

package/cli/dist/valbuild-cli-cli.cjs.dev.js

@@ -11,6 +11,7 @@ var fs = require('fs/promises');
 var internal = require('@valbuild/shared/internal');
 var fs$1 = require('fs');
 var ts = require('typescript');
+var child_process = require('child_process');
 var JSZip = require('jszip');
 var readline = require('readline');
 var crypto = require('crypto');
@@ -1169,25 +1170,83 @@ function requireVersion(packageName, key) {
 }
 
 const host = process.env.VAL_BUILD_URL || "https://admin.val.build";
+
+/**
+ * `val connect`: opens admin's `/new` on "your own hosting", with what it can
+ * tell from here filled in -- the project `val.config.ts` names and the
+ * GitHub repository `origin` points at -- so the person only confirms. The
+ * link is printed too, for when no browser opens (over SSH, in a container).
+ */
 async function connect(options) {
   const {
     root
   } = options;
   const projectRoot = root ? path__default["default"].resolve(root) : process.cwd();
-  const maybeProject = await tryGetProject(projectRoot);
-  const maybeGitRemote = await tryGetGitRemote(projectRoot);
-  const maybeGitOwnerAndRepo = maybeGitRemote !== null ? getGitHubOwnerAndRepo(maybeGitRemote) : null;
-  const params = new URLSearchParams();
-  params.set("step", "create-project");
-  if (maybeProject) {
-    params.set("org", maybeProject.orgName);
-    params.set("project", maybeProject.projectName);
-  }
-  if (maybeGitOwnerAndRepo) {
-    params.set("github_repo", [maybeGitOwnerAndRepo.owner, maybeGitOwnerAndRepo.repo].join("/"));
-  }
-  const url = `${host}/connect?${params.toString()}`;
-  console.log(pc__default["default"].dim(`\nFollow the instructions in your browser to complete the setup:\n${pc__default["default"].cyan(url)}\n`));
+  const project = await tryGetProject(projectRoot);
+  const gitRemote = await tryGetGitRemote(projectRoot);
+  const repo = gitRemote !== null ? getGitHubOwnerAndRepo(gitRemote) : null;
+  console.log("");
+  if (project) {
+    console.log(`Found ${pc__default["default"].bold(`${project.orgName}/${project.projectName}`)} in val.config.ts`);
+  }
+  if (repo) {
+    console.log(`Found ${pc__default["default"].bold(`${repo.owner}/${repo.repo}`)} on GitHub (git remote "origin")`);
+  } else {
+    console.log(pc__default["default"].dim("No GitHub repository found: push this project to GitHub, or pick or create one in the browser."));
+  }
+  const url = connectUrl(host, {
+    project,
+    repo
+  });
+  const opened = openInBrowser(url);
+  console.log(`\n${opened ? "Finish in your browser. If it did not open, go to:" : "Finish in your browser:"}\n${pc__default["default"].cyan(url)}\n`);
+}
+
+/**
+ * Where `val connect` sends the person: `/new` on "your own hosting"
+ * (`hosting=own`), with the repository and the project's names when they are
+ * known. Older CLIs go to `/connect`, which redirects here.
+ */
+function connectUrl(host, found) {
+  const params = new URLSearchParams({
+    hosting: "own"
+  });
+  if (found.repo) {
+    params.set("repo", `${found.repo.owner}/${found.repo.repo}`);
+  }
+  if (found.project) {
+    params.set("org", found.project.orgName);
+    params.set("project", found.project.projectName);
+  }
+  return `${host.replace(/\/+$/, "")}/new?${params.toString()}`;
+}
+
+/**
+ * Opens `url` in the default browser, without waiting for it. False when
+ * there is clearly none to open (CI, no terminal), so the caller can say so;
+ * a browser that fails to start later is covered by the printed link.
+ */
+function openInBrowser(url) {
+  if (process.env.CI || !process.stdout.isTTY) return false;
+  const windows = process.platform === "win32";
+  const [command, args] = process.platform === "darwin" ? ["open", [url]] : windows ?
+  // `start` is a cmd built-in: its first quoted argument is a window
+  // title, and `&` would end the command unless escaped.
+  ["cmd", ["/c", "start", '""', url.replace(/&/g, "^&")]] : ["xdg-open", [url]];
+  try {
+    const child = child_process.spawn(command, args, {
+      detached: true,
+      stdio: "ignore",
+      windowsVerbatimArguments: windows
+    });
+    child.on("error", () => {
+      // No opener installed: the printed link is the way in.
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
 }
 async function tryGetProject(projectRoot) {
   const valConfigFile = await server.findAndEvalValConfigFile(projectRoot);
@@ -1205,22 +1264,18 @@ async function tryGetProject(projectRoot) {
   }
   return null;
 }
+
+/**
+ * The GitHub repository a remote URL names: `git@github.com:acme/site.git`,
+ * `ssh://git@github.com/acme/site.git` or `https://[user@]github.com/acme/site`.
+ * Null for any other host.
+ */
 function getGitHubOwnerAndRepo(gitRemote) {
-  const sshMatch = gitRemote.match(/git@github\.com:(.+?)\/(.+?)(\.git)?$/);
-  if (sshMatch) {
-    return {
-      owner: sshMatch[1],
-      repo: sshMatch[2]
-    };
-  }
-  const httpsMatch = gitRemote.match(/https:\/\/github\.com\/(.+?)\/(.+?)(\.git)?$/);
-  if (httpsMatch) {
-    return {
-      owner: httpsMatch[1],
-      repo: httpsMatch[2]
-    };
-  }
-  return null;
+  const match = gitRemote.trim().match(/^(?:git@github\.com:|ssh:\/\/git@github\.com\/|https:\/\/(?:[^@/\s]+@)?github\.com\/)([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/i);
+  return match ? {
+    owner: match[1],
+    repo: match[2]
+  } : null;
 }
 async function tryGetGitRemote(root) {
   try {
@@ -4082,7 +4137,8 @@ async function main() {
 
 
       Command: connect
-      Description: connect your local project to a Val Build project at admin.val.build
+      Description: open admin.val.build to connect this project, with its repository
+                   and val.config.ts project filled in
       Options:
         --root [root], -r [root] Set project root directory (default process.cwd())
 

package/cli/dist/valbuild-cli-cli.cjs.prod.js

@@ -11,6 +11,7 @@ var fs = require('fs/promises');
 var internal = require('@valbuild/shared/internal');
 var fs$1 = require('fs');
 var ts = require('typescript');
+var child_process = require('child_process');
 var JSZip = require('jszip');
 var readline = require('readline');
 var crypto = require('crypto');
@@ -1169,25 +1170,83 @@ function requireVersion(packageName, key) {
 }
 
 const host = process.env.VAL_BUILD_URL || "https://admin.val.build";
+
+/**
+ * `val connect`: opens admin's `/new` on "your own hosting", with what it can
+ * tell from here filled in -- the project `val.config.ts` names and the
+ * GitHub repository `origin` points at -- so the person only confirms. The
+ * link is printed too, for when no browser opens (over SSH, in a container).
+ */
 async function connect(options) {
   const {
     root
   } = options;
   const projectRoot = root ? path__default["default"].resolve(root) : process.cwd();
-  const maybeProject = await tryGetProject(projectRoot);
-  const maybeGitRemote = await tryGetGitRemote(projectRoot);
-  const maybeGitOwnerAndRepo = maybeGitRemote !== null ? getGitHubOwnerAndRepo(maybeGitRemote) : null;
-  const params = new URLSearchParams();
-  params.set("step", "create-project");
-  if (maybeProject) {
-    params.set("org", maybeProject.orgName);
-    params.set("project", maybeProject.projectName);
-  }
-  if (maybeGitOwnerAndRepo) {
-    params.set("github_repo", [maybeGitOwnerAndRepo.owner, maybeGitOwnerAndRepo.repo].join("/"));
-  }
-  const url = `${host}/connect?${params.toString()}`;
-  console.log(pc__default["default"].dim(`\nFollow the instructions in your browser to complete the setup:\n${pc__default["default"].cyan(url)}\n`));
+  const project = await tryGetProject(projectRoot);
+  const gitRemote = await tryGetGitRemote(projectRoot);
+  const repo = gitRemote !== null ? getGitHubOwnerAndRepo(gitRemote) : null;
+  console.log("");
+  if (project) {
+    console.log(`Found ${pc__default["default"].bold(`${project.orgName}/${project.projectName}`)} in val.config.ts`);
+  }
+  if (repo) {
+    console.log(`Found ${pc__default["default"].bold(`${repo.owner}/${repo.repo}`)} on GitHub (git remote "origin")`);
+  } else {
+    console.log(pc__default["default"].dim("No GitHub repository found: push this project to GitHub, or pick or create one in the browser."));
+  }
+  const url = connectUrl(host, {
+    project,
+    repo
+  });
+  const opened = openInBrowser(url);
+  console.log(`\n${opened ? "Finish in your browser. If it did not open, go to:" : "Finish in your browser:"}\n${pc__default["default"].cyan(url)}\n`);
+}
+
+/**
+ * Where `val connect` sends the person: `/new` on "your own hosting"
+ * (`hosting=own`), with the repository and the project's names when they are
+ * known. Older CLIs go to `/connect`, which redirects here.
+ */
+function connectUrl(host, found) {
+  const params = new URLSearchParams({
+    hosting: "own"
+  });
+  if (found.repo) {
+    params.set("repo", `${found.repo.owner}/${found.repo.repo}`);
+  }
+  if (found.project) {
+    params.set("org", found.project.orgName);
+    params.set("project", found.project.projectName);
+  }
+  return `${host.replace(/\/+$/, "")}/new?${params.toString()}`;
+}
+
+/**
+ * Opens `url` in the default browser, without waiting for it. False when
+ * there is clearly none to open (CI, no terminal), so the caller can say so;
+ * a browser that fails to start later is covered by the printed link.
+ */
+function openInBrowser(url) {
+  if (process.env.CI || !process.stdout.isTTY) return false;
+  const windows = process.platform === "win32";
+  const [command, args] = process.platform === "darwin" ? ["open", [url]] : windows ?
+  // `start` is a cmd built-in: its first quoted argument is a window
+  // title, and `&` would end the command unless escaped.
+  ["cmd", ["/c", "start", '""', url.replace(/&/g, "^&")]] : ["xdg-open", [url]];
+  try {
+    const child = child_process.spawn(command, args, {
+      detached: true,
+      stdio: "ignore",
+      windowsVerbatimArguments: windows
+    });
+    child.on("error", () => {
+      // No opener installed: the printed link is the way in.
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
 }
 async function tryGetProject(projectRoot) {
   const valConfigFile = await server.findAndEvalValConfigFile(projectRoot);
@@ -1205,22 +1264,18 @@ async function tryGetProject(projectRoot) {
   }
   return null;
 }
+
+/**
+ * The GitHub repository a remote URL names: `git@github.com:acme/site.git`,
+ * `ssh://git@github.com/acme/site.git` or `https://[user@]github.com/acme/site`.
+ * Null for any other host.
+ */
 function getGitHubOwnerAndRepo(gitRemote) {
-  const sshMatch = gitRemote.match(/git@github\.com:(.+?)\/(.+?)(\.git)?$/);
-  if (sshMatch) {
-    return {
-      owner: sshMatch[1],
-      repo: sshMatch[2]
-    };
-  }
-  const httpsMatch = gitRemote.match(/https:\/\/github\.com\/(.+?)\/(.+?)(\.git)?$/);
-  if (httpsMatch) {
-    return {
-      owner: httpsMatch[1],
-      repo: httpsMatch[2]
-    };
-  }
-  return null;
+  const match = gitRemote.trim().match(/^(?:git@github\.com:|ssh:\/\/git@github\.com\/|https:\/\/(?:[^@/\s]+@)?github\.com\/)([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/i);
+  return match ? {
+    owner: match[1],
+    repo: match[2]
+  } : null;
 }
 async function tryGetGitRemote(root) {
   try {
@@ -4082,7 +4137,8 @@ async function main() {
 
 
       Command: connect
-      Description: connect your local project to a Val Build project at admin.val.build
+      Description: open admin.val.build to connect this project, with its repository
+                   and val.config.ts project filled in
       Options:
         --root [root], -r [root] Set project root directory (default process.cwd())
 

package/cli/dist/valbuild-cli-cli.esm.js

@@ -9,6 +9,7 @@ import fs from 'fs/promises';
 import { resolveSchemaSourceFixes, traverseSchemaSource, parseBuildTarget, parseDeclare, parseArtifacts, parseVerify, parsePromote, parseStatus, parsePublishToken, PublishProtocolError, parseProblems } from '@valbuild/shared/internal';
 import fs$1 from 'fs';
 import ts from 'typescript';
+import { spawn } from 'child_process';
 import JSZip from 'jszip';
 import readline from 'readline';
 import crypto from 'crypto';
@@ -1134,25 +1135,83 @@ function requireVersion(packageName, key) {
 }
 
 const host = process.env.VAL_BUILD_URL || "https://admin.val.build";
+
+/**
+ * `val connect`: opens admin's `/new` on "your own hosting", with what it can
+ * tell from here filled in -- the project `val.config.ts` names and the
+ * GitHub repository `origin` points at -- so the person only confirms. The
+ * link is printed too, for when no browser opens (over SSH, in a container).
+ */
 async function connect(options) {
   const {
     root
   } = options;
   const projectRoot = root ? path.resolve(root) : process.cwd();
-  const maybeProject = await tryGetProject(projectRoot);
-  const maybeGitRemote = await tryGetGitRemote(projectRoot);
-  const maybeGitOwnerAndRepo = maybeGitRemote !== null ? getGitHubOwnerAndRepo(maybeGitRemote) : null;
-  const params = new URLSearchParams();
-  params.set("step", "create-project");
-  if (maybeProject) {
-    params.set("org", maybeProject.orgName);
-    params.set("project", maybeProject.projectName);
-  }
-  if (maybeGitOwnerAndRepo) {
-    params.set("github_repo", [maybeGitOwnerAndRepo.owner, maybeGitOwnerAndRepo.repo].join("/"));
-  }
-  const url = `${host}/connect?${params.toString()}`;
-  console.log(pc.dim(`\nFollow the instructions in your browser to complete the setup:\n${pc.cyan(url)}\n`));
+  const project = await tryGetProject(projectRoot);
+  const gitRemote = await tryGetGitRemote(projectRoot);
+  const repo = gitRemote !== null ? getGitHubOwnerAndRepo(gitRemote) : null;
+  console.log("");
+  if (project) {
+    console.log(`Found ${pc.bold(`${project.orgName}/${project.projectName}`)} in val.config.ts`);
+  }
+  if (repo) {
+    console.log(`Found ${pc.bold(`${repo.owner}/${repo.repo}`)} on GitHub (git remote "origin")`);
+  } else {
+    console.log(pc.dim("No GitHub repository found: push this project to GitHub, or pick or create one in the browser."));
+  }
+  const url = connectUrl(host, {
+    project,
+    repo
+  });
+  const opened = openInBrowser(url);
+  console.log(`\n${opened ? "Finish in your browser. If it did not open, go to:" : "Finish in your browser:"}\n${pc.cyan(url)}\n`);
+}
+
+/**
+ * Where `val connect` sends the person: `/new` on "your own hosting"
+ * (`hosting=own`), with the repository and the project's names when they are
+ * known. Older CLIs go to `/connect`, which redirects here.
+ */
+function connectUrl(host, found) {
+  const params = new URLSearchParams({
+    hosting: "own"
+  });
+  if (found.repo) {
+    params.set("repo", `${found.repo.owner}/${found.repo.repo}`);
+  }
+  if (found.project) {
+    params.set("org", found.project.orgName);
+    params.set("project", found.project.projectName);
+  }
+  return `${host.replace(/\/+$/, "")}/new?${params.toString()}`;
+}
+
+/**
+ * Opens `url` in the default browser, without waiting for it. False when
+ * there is clearly none to open (CI, no terminal), so the caller can say so;
+ * a browser that fails to start later is covered by the printed link.
+ */
+function openInBrowser(url) {
+  if (process.env.CI || !process.stdout.isTTY) return false;
+  const windows = process.platform === "win32";
+  const [command, args] = process.platform === "darwin" ? ["open", [url]] : windows ?
+  // `start` is a cmd built-in: its first quoted argument is a window
+  // title, and `&` would end the command unless escaped.
+  ["cmd", ["/c", "start", '""', url.replace(/&/g, "^&")]] : ["xdg-open", [url]];
+  try {
+    const child = spawn(command, args, {
+      detached: true,
+      stdio: "ignore",
+      windowsVerbatimArguments: windows
+    });
+    child.on("error", () => {
+      // No opener installed: the printed link is the way in.
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
 }
 async function tryGetProject(projectRoot) {
   const valConfigFile = await findAndEvalValConfigFile(projectRoot);
@@ -1170,22 +1229,18 @@ async function tryGetProject(projectRoot) {
   }
   return null;
 }
+
+/**
+ * The GitHub repository a remote URL names: `git@github.com:acme/site.git`,
+ * `ssh://git@github.com/acme/site.git` or `https://[user@]github.com/acme/site`.
+ * Null for any other host.
+ */
 function getGitHubOwnerAndRepo(gitRemote) {
-  const sshMatch = gitRemote.match(/git@github\.com:(.+?)\/(.+?)(\.git)?$/);
-  if (sshMatch) {
-    return {
-      owner: sshMatch[1],
-      repo: sshMatch[2]
-    };
-  }
-  const httpsMatch = gitRemote.match(/https:\/\/github\.com\/(.+?)\/(.+?)(\.git)?$/);
-  if (httpsMatch) {
-    return {
-      owner: httpsMatch[1],
-      repo: httpsMatch[2]
-    };
-  }
-  return null;
+  const match = gitRemote.trim().match(/^(?:git@github\.com:|ssh:\/\/git@github\.com\/|https:\/\/(?:[^@/\s]+@)?github\.com\/)([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/i);
+  return match ? {
+    owner: match[1],
+    repo: match[2]
+  } : null;
 }
 async function tryGetGitRemote(root) {
   try {
@@ -4047,7 +4102,8 @@ async function main() {
 
 
       Command: connect
-      Description: connect your local project to a Val Build project at admin.val.build
+      Description: open admin.val.build to connect this project, with its repository
+                   and val.config.ts project filled in
       Options:
         --root [root], -r [root] Set project root directory (default process.cwd())
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@valbuild/cli",
   "private": false,
-  "version": "0.144.4",
+  "version": "0.144.5",
   "description": "Val CLI tools",
   "repository": {
     "type": "git",
@@ -28,9 +28,9 @@
     "zod-validation-error": "^5.0.0",
     "@valbuild/core": "0.144.0",
     "@valbuild/eslint-plugin": "0.125.0",
-    "@valbuild/language-server": "0.144.4",
-    "@valbuild/server": "0.144.4",
-    "@valbuild/shared": "0.144.4"
+    "@valbuild/language-server": "0.144.5",
+    "@valbuild/server": "0.144.5",
+    "@valbuild/shared": "0.144.5"
   },
   "peerDependencies": {
     "prettier": "*",

package/src/cli.ts

@@ -47,7 +47,8 @@ async function main(): Promise<void> {
 
 
       Command: connect
-      Description: connect your local project to a Val Build project at admin.val.build
+      Description: open admin.val.build to connect this project, with its repository
+                   and val.config.ts project filled in
       Options:
         --root [root], -r [root] Set project root directory (default process.cwd())
 

package/src/connect.test.ts

@@ -0,0 +1,49 @@
+import { connectUrl, getGitHubOwnerAndRepo } from "./connect";
+
+describe("val connect", () => {
+  test("opens /new on your own hosting, with the repository and the project filled in", () => {
+    const url = new URL(
+      connectUrl("https://admin.val.build", {
+        project: { orgName: "acme", projectName: "website" },
+        repo: { owner: "acme-gh", repo: "site" },
+      }),
+    );
+    expect(url.origin + url.pathname).toBe("https://admin.val.build/new");
+    expect(Object.fromEntries(url.searchParams)).toEqual({
+      hosting: "own",
+      repo: "acme-gh/site",
+      org: "acme",
+      project: "website",
+    });
+  });
+
+  test("with nothing found, it is /new on your own hosting alone", () => {
+    expect(
+      connectUrl("http://localhost:3000/", { project: null, repo: null }),
+    ).toBe("http://localhost:3000/new?hosting=own");
+  });
+
+  test("the repository is read from origin over ssh or https", () => {
+    expect(getGitHubOwnerAndRepo("git@github.com:acme/site.git")).toEqual({
+      owner: "acme",
+      repo: "site",
+    });
+    expect(getGitHubOwnerAndRepo("https://github.com/acme/site")).toEqual({
+      owner: "acme",
+      repo: "site",
+    });
+    expect(getGitHubOwnerAndRepo("ssh://git@github.com/acme/site.git")).toEqual(
+      { owner: "acme", repo: "site" },
+    );
+    expect(
+      getGitHubOwnerAndRepo("https://me@github.com/acme/site.git"),
+    ).toEqual({ owner: "acme", repo: "site" });
+    // Host names are case-insensitive.
+    expect(getGitHubOwnerAndRepo("https://GitHub.com/acme/site.git")).toEqual({
+      owner: "acme",
+      repo: "site",
+    });
+    expect(getGitHubOwnerAndRepo("git@gitlab.com:acme/site.git")).toBeNull();
+    expect(getGitHubOwnerAndRepo("git@notgithub.com:acme/site.git")).toBeNull();
+  });
+});

package/src/connect.ts

@@ -1,40 +1,105 @@
 import pc from "picocolors";
 import fs from "fs";
 import path from "path";
+import { spawn } from "child_process";
 import { findAndEvalValConfigFile } from "./utils/evalValConfigFile";
 
 const host = process.env.VAL_BUILD_URL || "https://admin.val.build";
 
+/**
+ * `val connect`: opens admin's `/new` on "your own hosting", with what it can
+ * tell from here filled in -- the project `val.config.ts` names and the
+ * GitHub repository `origin` points at -- so the person only confirms. The
+ * link is printed too, for when no browser opens (over SSH, in a container).
+ */
 export async function connect(options: { root?: string }) {
   const { root } = options;
   const projectRoot = root ? path.resolve(root) : process.cwd();
 
-  const maybeProject = await tryGetProject(projectRoot);
-  const maybeGitRemote = await tryGetGitRemote(projectRoot);
-  const maybeGitOwnerAndRepo =
-    maybeGitRemote !== null ? getGitHubOwnerAndRepo(maybeGitRemote) : null;
+  const project = await tryGetProject(projectRoot);
+  const gitRemote = await tryGetGitRemote(projectRoot);
+  const repo = gitRemote !== null ? getGitHubOwnerAndRepo(gitRemote) : null;
 
-  const params = new URLSearchParams();
-  params.set("step", "create-project");
-  if (maybeProject) {
-    params.set("org", maybeProject.orgName);
-    params.set("project", maybeProject.projectName);
+  console.log("");
+  if (project) {
+    console.log(
+      `Found ${pc.bold(`${project.orgName}/${project.projectName}`)} in val.config.ts`,
+    );
   }
-  if (maybeGitOwnerAndRepo) {
-    params.set(
-      "github_repo",
-      [maybeGitOwnerAndRepo.owner, maybeGitOwnerAndRepo.repo].join("/"),
+  if (repo) {
+    console.log(
+      `Found ${pc.bold(`${repo.owner}/${repo.repo}`)} on GitHub (git remote "origin")`,
+    );
+  } else {
+    console.log(
+      pc.dim(
+        "No GitHub repository found: push this project to GitHub, or pick or create one in the browser.",
+      ),
     );
   }
-  const url = `${host}/connect?${params.toString()}`;
 
+  const url = connectUrl(host, { project, repo });
+  const opened = openInBrowser(url);
   console.log(
-    pc.dim(
-      `\nFollow the instructions in your browser to complete the setup:\n${pc.cyan(url)}\n`,
-    ),
+    `\n${opened ? "Finish in your browser. If it did not open, go to:" : "Finish in your browser:"}\n${pc.cyan(url)}\n`,
   );
 }
 
+/**
+ * Where `val connect` sends the person: `/new` on "your own hosting"
+ * (`hosting=own`), with the repository and the project's names when they are
+ * known. Older CLIs go to `/connect`, which redirects here.
+ */
+export function connectUrl(
+  host: string,
+  found: {
+    project: { orgName: string; projectName: string } | null;
+    repo: { owner: string; repo: string } | null;
+  },
+): string {
+  const params = new URLSearchParams({ hosting: "own" });
+  if (found.repo) {
+    params.set("repo", `${found.repo.owner}/${found.repo.repo}`);
+  }
+  if (found.project) {
+    params.set("org", found.project.orgName);
+    params.set("project", found.project.projectName);
+  }
+  return `${host.replace(/\/+$/, "")}/new?${params.toString()}`;
+}
+
+/**
+ * Opens `url` in the default browser, without waiting for it. False when
+ * there is clearly none to open (CI, no terminal), so the caller can say so;
+ * a browser that fails to start later is covered by the printed link.
+ */
+function openInBrowser(url: string): boolean {
+  if (process.env.CI || !process.stdout.isTTY) return false;
+  const windows = process.platform === "win32";
+  const [command, args] =
+    process.platform === "darwin"
+      ? ["open", [url]]
+      : windows
+        ? // `start` is a cmd built-in: its first quoted argument is a window
+          // title, and `&` would end the command unless escaped.
+          ["cmd", ["/c", "start", '""', url.replace(/&/g, "^&")]]
+        : ["xdg-open", [url]];
+  try {
+    const child = spawn(command, args, {
+      detached: true,
+      stdio: "ignore",
+      windowsVerbatimArguments: windows,
+    });
+    child.on("error", () => {
+      // No opener installed: the printed link is the way in.
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function tryGetProject(projectRoot: string): Promise<{
   orgName: string;
   projectName: string;
@@ -60,20 +125,20 @@ async function tryGetProject(projectRoot: string): Promise<{
   return null;
 }
 
-function getGitHubOwnerAndRepo(
+/**
+ * The GitHub repository a remote URL names: `git@github.com:acme/site.git`,
+ * `ssh://git@github.com/acme/site.git` or `https://[user@]github.com/acme/site`.
+ * Null for any other host.
+ */
+export function getGitHubOwnerAndRepo(
   gitRemote: string,
 ): { owner: string; repo: string } | null {
-  const sshMatch = gitRemote.match(/git@github\.com:(.+?)\/(.+?)(\.git)?$/);
-  if (sshMatch) {
-    return { owner: sshMatch[1], repo: sshMatch[2] };
-  }
-  const httpsMatch = gitRemote.match(
-    /https:\/\/github\.com\/(.+?)\/(.+?)(\.git)?$/,
-  );
-  if (httpsMatch) {
-    return { owner: httpsMatch[1], repo: httpsMatch[2] };
-  }
-  return null;
+  const match = gitRemote
+    .trim()
+    .match(
+      /^(?:git@github\.com:|ssh:\/\/git@github\.com\/|https:\/\/(?:[^@/\s]+@)?github\.com\/)([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/i,
+    );
+  return match ? { owner: match[1], repo: match[2] } : null;
 }
 
 async function tryGetGitRemote(root: string): Promise<string | null> {