@domesystems/templates 0.3.0 → 0.3.2

package/README.md

@@ -3,24 +3,37 @@
 Pull immutable Dome template releases, publish public templates from GitHub, and run an existing local directory.
 
 ```bash
-npx @domesystems/templates login --github
-npx @domesystems/templates pull dome-systems/ai-agent-for-documentation --dir ai-agent-for-documentation
+npx @domesystems/templates login --registry https://templates-registry.domesystems.ai --github
+npx @domesystems/templates pull dome-systems/ai-agent-for-documentation --registry https://templates-registry.domesystems.ai --dir ai-agent-for-documentation
 npx @domesystems/templates up --dir ai-agent-for-documentation
 ```
 
-Every remote command takes `--server <Dome application URL>`. The selected app server discovers its Registry endpoint; the CLI never derives one by rewriting hostnames. Credentials are isolated per server profile.
+Every remote command takes either `--server <Dome application URL>` or `--registry <Registry URL>`. `--server` discovers the Registry endpoint through the app server; `--registry` connects directly to an explicitly supplied Registry. A successful login makes that endpoint the default for later remote commands; either flag overrides it. Credentials are isolated per selected endpoint.
+
+Use direct Registry endpoints when the app-server discovery document is unavailable:
+
+```bash
+# Production
+npx @domesystems/templates login --registry https://templates-registry.domesystems.ai
+npx @domesystems/templates pull dome-systems/ai-agent-for-documentation --registry https://templates-registry.domesystems.ai
+
+# Development
+npx @domesystems/templates login --registry https://templates-registry-dev.domesystems.ai
+```
 
 ## Commands
 
 ```text
-templates login [--server <URL>] [--github]
-templates logout [--server <URL>]
-templates doctor <pull|up|publish> [--dir <directory>] [--server <URL>] [--json]
-templates pull <scope/package[@version]> [--dir <directory>] [--server <URL>]
+templates login [--server <URL>|--registry <URL>] [--github]
+templates logout [--server <URL>|--registry <URL>]
+templates doctor <pull|up|publish> [--dir <directory>] [--server <URL>|--registry <URL>] [--json]
+templates pull <scope/package[@version]> [--dir <directory>] [--server <URL>|--registry <URL>]
 templates up [--dir <directory>] [--port <host-port>] [--skip-provision|--provision] [--no-start] [--detach]
-templates publish [--dry-run] [--server <URL>]
+templates publish [--dry-run] [--server <URL>|--registry <URL>]
 ```
 
 `pull` only accepts scoped package names, verifies the Registry SHA-256 before extraction, accepts only the archive's `template/` root, writes `.dome-template-lock.yaml`, and never overwrites a non-empty directory. `up` is local-only and never downloads or updates a release. `publish` reads the scoped name and SemVer version from `template.yaml`, requires a clean Git checkout, and cannot replace a published version.
 
+Use `--verbose` with a command to include its diagnostic stack trace when it fails. When publishing requires a GitHub connection, the CLI opens the authorization page automatically; complete it, then run `publish` again.
+
 The CLI holds no authority over package ownership or artifact access. The Registry revalidates every publish and creates short-lived artifact URLs; it does not expose raw S3 keys.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domesystems/templates",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Pull, publish, and run versioned Dome templates.",
   "repository": {
     "type": "git",

package/src/cli.mjs

@@ -6,11 +6,11 @@ import { readManifest, readPublishManifest } from "./manifest.mjs";
 import { imageForRuntime, renderCompose } from "./runtime.mjs";
 import { extractRelease, initializeEnvironment } from "./template-files.mjs";
 import { createArchive, publishSource } from "./publish-files.mjs";
-import { DEFAULT_SERVER, deleteProfile, discover, login, normalizeServer, readProfile, registryRequest } from "./registry.mjs";
+import { DEFAULT_SERVER, clearSelectedTarget, deleteProfile, directRegistry, discover, login, normalizeServer, readProfile, readSelectedTarget, registryRequest, writeSelectedTarget } from "./registry.mjs";
 
 function ansi(code, value, options) { return options.color && process.stdout.isTTY ? `\u001B[${code}m${value}\u001B[0m` : value; }
 function line(kind, value, options) { const styles = { info: ["•", "36"], success: ["✓", "32"], warning: ["!", "33"], error: ["✗", "31"] }; const [mark, code] = styles[kind]; return `${ansi(code, mark, options)} ${value}`; }
-function usage() { return "Usage:\n  templates login [--server <Dome application URL>] [--github]\n  templates logout [--server <Dome application URL>]\n  templates doctor <pull|up|publish> [package] [--dir <directory>] [--server <URL>] [--json]\n  templates pull <scope/package[@version]> [--dir <directory>] [--server <URL>]\n  templates up [--dir <directory>] [--port <host-port>] [--skip-provision|--provision] [--no-start] [--detach] [--verbose]\n  templates publish [--dry-run] [--server <Dome application URL>]\n"; }
+function usage() { return "Usage:\n  templates login [--server <Dome application URL>|--registry <Registry URL>] [--github]\n  templates logout [--server <Dome application URL>|--registry <Registry URL>]\n  templates doctor <pull|up|publish> [package] [--dir <directory>] [--server <URL>|--registry <URL>] [--json]\n  templates pull <scope/package[@version]> [--dir <directory>] [--server <URL>|--registry <URL>]\n  templates up [--dir <directory>] [--port <host-port>] [--skip-provision|--provision] [--no-start] [--detach] [--verbose]\n  templates publish [--dry-run] [--server <Dome application URL>|--registry <Registry URL>]\n"; }
 function parse(argv) {
   if (!argv.length || argv.includes("--help") || argv.includes("-h")) return { help: true };
   const [command, ...rest] = argv;
@@ -18,21 +18,37 @@ function parse(argv) {
   const values = [];
   for (let i = 0; i < rest.length; i += 1) {
     const arg = rest[i];
-    if (arg === "--server" || arg === "--dir" || arg === "--port" || arg === "--color") { const value = rest[++i]; if (!value) throw new Error(`${arg} requires a value.`); if (arg === "--server") options.server = normalizeServer(value); else if (arg === "--dir") options.directory = value; else if (arg === "--color") { if (!["auto", "always", "never"].includes(value)) throw new Error("--color must be auto, always, or never."); options.color = value === "always" || (value === "auto" && !process.env.NO_COLOR); } else { options.port = Number(value); if (!Number.isInteger(options.port) || options.port < 1 || options.port > 65535) throw new Error("--port requires an integer from 1 to 65535."); } }
+    if (arg === "--server" || arg === "--registry" || arg === "--dir" || arg === "--port" || arg === "--color") { const value = rest[++i]; if (!value) throw new Error(`${arg} requires a value.`); if (arg === "--server") options.server = normalizeServer(value); else if (arg === "--registry") options.registry = normalizeServer(value); else if (arg === "--dir") options.directory = value; else if (arg === "--color") { if (!["auto", "always", "never"].includes(value)) throw new Error("--color must be auto, always, or never."); options.color = value === "always" || (value === "auto" && !process.env.NO_COLOR); } else { options.port = Number(value); if (!Number.isInteger(options.port) || options.port < 1 || options.port > 65535) throw new Error("--port requires an integer from 1 to 65535."); } }
     else if (arg === "--github") options.github = true; else if (arg === "--dry-run") options.dryRun = true; else if (arg === "--json") options.json = true; else if (arg === "--skip-provision") options.provision = false; else if (arg === "--provision") options.forceProvision = true; else if (arg === "--no-start") options.start = false; else if (arg === "--detach") options.detach = true; else if (arg === "--verbose") options.verbose = true; else if (arg.startsWith("-")) throw new Error(`Unknown option: ${arg}`); else values.push(arg);
   }
+  if (options.server && options.registry) throw new Error("Use either --server or --registry, not both.");
   if (!["login", "logout", "doctor", "pull", "up", "publish"].includes(command)) throw new Error(`Unknown command: ${command}`);
   return { command, values, options };
 }
+function remoteTarget(options) { return options.registry ? directRegistry(options.registry) : options.server ?? readSelectedTarget() ?? DEFAULT_SERVER; }
+function remoteLocation(options) { const target = remoteTarget(options); return typeof target === "string" ? `--server ${target}` : `--registry ${target.registry}`; }
+const githubPublishingAccessMessage = "GitHub publishing access is required.";
+function openBrowser(url) {
+  const command = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  const child = spawn(command[0], command[1], { detached: true, stdio: "ignore" });
+  child.on("error", () => {});
+  child.unref();
+}
+async function requestGitHubPublishingAccess(remote, options, output, fetchImplementation) {
+  const { body } = await registryRequest(remote, "/v1/github/link/start", { method: "POST", authenticated: true, fetchImplementation });
+  if (typeof body.url !== "string") return;
+  if (options.verbose) output(line("info", `Opening GitHub authorization: ${body.url}`, options));
+  openBrowser(body.url);
+}
 function packageReference(value) { const match = /^([a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9-]*)(?:@(.+))?$/.exec(value ?? ""); if (!match) throw new Error("Template package must be fully qualified as scope/package or scope/package@version."); return { name: match[1], version: match[2] }; }
 function destination(name, directory) { return path.resolve(process.cwd(), directory ?? name.split("/")[1]); }
 function empty(dir) { return !fs.existsSync(dir) || fs.readdirSync(dir).length === 0; }
 async function pull(name, options, output, fetchImplementation) {
   const ref = packageReference(name); const target = destination(ref.name, options.directory); if (!empty(target)) throw new Error(`${target} already exists and is not empty. Choose an empty --dir.`);
   output(line("info", `Fetching ${ref.name}@${ref.version ?? "latest"}`, options));
-  const [scope, slug] = ref.name.split("/"); const { body: release } = await registryRequest(options.server ?? DEFAULT_SERVER, `/v1/packages/${scope}/${slug}${ref.version ? `/${encodeURIComponent(ref.version)}` : ""}`, { fetchImplementation });
+  const [scope, slug] = ref.name.split("/"); const remote = remoteTarget(options); const { body: release } = await registryRequest(remote, `/v1/packages/${scope}/${slug}${ref.version ? `/${encodeURIComponent(ref.version)}` : ""}`, { fetchImplementation });
   if (!release.name || !release.version || !release.sha256 || !release.source) throw new Error("Registry returned incomplete release metadata.");
-  const { body: download } = await registryRequest(options.server ?? DEFAULT_SERVER, `/v1/packages/${scope}/${slug}/${encodeURIComponent(release.version)}/download-url`, { method: "POST", fetchImplementation });
+  const { body: download } = await registryRequest(remote, `/v1/packages/${scope}/${slug}/${encodeURIComponent(release.version)}/download-url`, { method: "POST", fetchImplementation });
   const response = await fetchImplementation(download.url, { headers: { accept: "application/zip" } }); if (!response.ok) throw new Error(`Could not download ${ref.name}: ${response.status} ${response.statusText}.`);
   fs.mkdirSync(target, { recursive: true }); await extractRelease(Buffer.from(await response.arrayBuffer()), target, release); const created = initializeEnvironment(target);
   output(line("success", `Pulled ${release.name}@${release.version}`, options)); output(`  Saved to ${target}`); if (created) output(line("success", "Created .env from .env.example", options));
@@ -41,11 +57,15 @@ function run(command, args, cwd) { const result = spawnSync(command, args, { cwd
 function configured(target) { const env = path.join(target, ".env"); return fs.existsSync(env) && ["DOME_TOKEN", "DOME_GATEWAY_URL"].every((key) => new RegExp(`^${key}=(?!\\s*$|undefined|\"\")`, "m").test(fs.readFileSync(env, "utf8"))); }
 async function up(options, output) { const target = path.resolve(process.cwd(), options.directory ?? "."); const manifest = readManifest(target); output(line("info", `Checking ${target}`, options)); fs.writeFileSync(path.join(target, ".dome-compose.yaml"), renderCompose(manifest.app.runtime, options.port)); if (options.provision && (!configured(target) || options.forceProvision)) { output(line("info", "Setting up Dome resources", options)); run("dome", ["import", "dome.tf"], target); } if (options.start) { output(line("info", `Starting app at http://localhost:${options.port}`, options)); run("docker", ["compose", "-f", ".dome-compose.yaml", "up", ...(options.detach ? ["--detach"] : [])], target); } }
 async function publish(options, output, fetchImplementation) { const target = path.resolve(process.cwd(), options.directory ?? "."); const manifest = readPublishManifest(target); const source = publishSource(target); const name = manifest.metadata.name; const [scope, slug] = name.split("/"); const archive = options.dryRun ? null : createArchive(source); output(line("info", `Checking ${name}@${manifest.metadata.version}`, options)); const payload = { name, version: manifest.metadata.version, title: manifest.metadata.title, summary: manifest.metadata.summary ?? "", sha256: archive?.sha256, size_bytes: archive?.buffer.length, source: { repository: manifest.metadata.source.repository, path: manifest.metadata.source.path, commit: source.commit, remote: source.remote, files: source.files } };
-  const { target: registry, body: attempt } = await registryRequest(options.server ?? DEFAULT_SERVER, "/v1/publish-attempts", { method: "POST", body: { ...payload, dry_run: options.dryRun }, authenticated: true, fetchImplementation });
+  const remote = remoteTarget(options); let registry; let attempt;
+  try { ({ target: registry, body: attempt } = await registryRequest(remote, "/v1/publish-attempts", { method: "POST", body: { ...payload, dry_run: options.dryRun }, authenticated: true, fetchImplementation })); } catch (caught) {
+    if (caught?.message === githubPublishingAccessMessage) await requestGitHubPublishingAccess(remote, options, output, fetchImplementation).catch(() => {});
+    throw caught;
+  }
   if (options.dryRun) { output(line("success", `Publish plan is valid for ${name}@${manifest.metadata.version}`, options)); return; }
-  try { output(line("info", "Uploading release artifact", options)); const upload = await fetchImplementation(attempt.upload_url, { method: "PUT", headers: { "content-type": "application/zip" }, body: archive.buffer }); if (!upload.ok) throw new Error(`Artifact upload failed: ${upload.status} ${upload.statusText}.`); const { body: published } = await registryRequest(registry.server, `/v1/publish-attempts/${encodeURIComponent(attempt.id)}/complete`, { method: "POST", body: { sha256: archive.sha256, size_bytes: archive.buffer.length }, authenticated: true, fetchImplementation }); output(line("success", `Published ${published.name ?? name}@${published.version ?? manifest.metadata.version}`, options)); if (published.url) output(`  ${published.url}`); } finally { archive.cleanup(); }
+  try { output(line("info", "Uploading release artifact", options)); const upload = await fetchImplementation(attempt.upload_url, { method: "PUT", headers: { "content-type": "application/zip" }, body: archive.buffer }); if (!upload.ok) throw new Error(`Artifact upload failed: ${upload.status} ${upload.statusText}.`); const { body: published } = await registryRequest(registry, `/v1/publish-attempts/${encodeURIComponent(attempt.id)}/complete`, { method: "POST", body: { sha256: archive.sha256, size_bytes: archive.buffer.length }, authenticated: true, fetchImplementation }); output(line("success", `Published ${published.name ?? name}@${published.version ?? manifest.metadata.version}`, options)); if (published.url) output(`  ${published.url}`); } finally { archive.cleanup(); }
 }
-async function doctor(subject, options, output, fetchImplementation) { const checks = []; const add = (name, passed, remediation) => checks.push({ name, passed, remediation }); try { if (subject === "pull") { await discover(options.server ?? DEFAULT_SERVER, fetchImplementation); add("Registry reachability", true); } else if (subject === "up") { const target = path.resolve(process.cwd(), options.directory ?? "."); readManifest(target); add("template.yaml", true); add("Docker Compose", spawnSync("docker", ["compose", "version"], { stdio: "ignore" }).status === 0, "Install Docker Desktop or Docker Engine with the Compose plugin."); add("Dome CLI", spawnSync("dome", ["--version"], { stdio: "ignore" }).status === 0, "Install the Dome CLI."); } else if (subject === "publish") { readPublishManifest(path.resolve(process.cwd(), options.directory ?? ".")); publishSource(path.resolve(process.cwd(), options.directory ?? ".")); const profile = readProfile(options.server ?? DEFAULT_SERVER); add("Registry sign-in", Boolean(profile?.token), `Run npx @domesystems/templates login --server ${options.server ?? DEFAULT_SERVER}`); } else throw new Error("doctor expects pull, up, or publish."); } catch (error) { add("Preflight", false, error.message); }
-  if (options.json) output(JSON.stringify({ server: options.server ?? DEFAULT_SERVER, checks })); else checks.forEach((check) => output(line(check.passed ? "success" : "error", check.passed ? check.name : `${check.name}: ${check.remediation}`, options))); if (checks.some((check) => !check.passed)) throw new Error(`Cannot continue until ${subject} checks pass.`);
+async function doctor(subject, options, output, fetchImplementation) { const checks = []; const add = (name, passed, remediation) => checks.push({ name, passed, remediation }); const remote = remoteTarget(options); try { if (subject === "pull") { if (typeof remote === "string") await discover(remote, fetchImplementation); add("Registry reachability", true); } else if (subject === "up") { const target = path.resolve(process.cwd(), options.directory ?? "."); readManifest(target); add("template.yaml", true); add("Docker Compose", spawnSync("docker", ["compose", "version"], { stdio: "ignore" }).status === 0, "Install Docker Desktop or Docker Engine with the Compose plugin."); add("Dome CLI", spawnSync("dome", ["--version"], { stdio: "ignore" }).status === 0, "Install the Dome CLI."); } else if (subject === "publish") { readPublishManifest(path.resolve(process.cwd(), options.directory ?? ".")); publishSource(path.resolve(process.cwd(), options.directory ?? ".")); const profile = readProfile(remote.server ?? remote); add("Registry sign-in", Boolean(profile?.token), `Run npx @domesystems/templates login ${remoteLocation(options)}`); } else throw new Error("doctor expects pull, up, or publish."); } catch (error) { add("Preflight", false, error.message); }
+  if (options.json) output(JSON.stringify({ server: remote.registry ?? remote, checks })); else checks.forEach((check) => output(line(check.passed ? "success" : "error", check.passed ? check.name : `${check.name}: ${check.remediation}`, options))); if (checks.some((check) => !check.passed)) throw new Error(`Cannot continue until ${subject} checks pass.`);
 }
-export async function main(argv, { output = console.log, error = console.error, fetchImplementation = globalThis.fetch, sleep } = {}) { try { const parsed = parse(argv); if (parsed.help) return output(usage()); const { command, values, options } = parsed; if (options.json) options.color = false; if (command === "login") { output(line("info", `Opening sign-in for ${options.server ?? DEFAULT_SERVER}`, options)); const session = await login(options.server ?? DEFAULT_SERVER, { github: options.github, fetchImplementation, sleep, onStart: (started) => output(`Open ${started.verification_uri} and enter ${started.user_code ?? "the displayed code"}.`) }); output(line("success", `Signed in as ${session.session.email}`, options)); return; } if (command === "logout") { const server = options.server ?? DEFAULT_SERVER; const profile = readProfile(server); if (profile?.token) await registryRequest(server, "/v1/auth/logout", { method: "POST", authenticated: true, fetchImplementation }); deleteProfile(server); output(line("success", `Signed out of ${server}`, options)); return; } if (command === "pull") return pull(values[0], options, output, fetchImplementation); if (command === "up") return up(options, output); if (command === "publish") return publish(options, output, fetchImplementation); return doctor(values[0], options, output, fetchImplementation); } catch (caught) { error(line("error", caught.message, { color: false })); process.exitCode = 1; } }
+export async function main(argv, { output = console.log, error = console.error, fetchImplementation = globalThis.fetch, sleep, exit = (code) => { process.exitCode = code; }, open = openBrowser } = {}) { let options; try { const parsed = parse(argv); if (parsed.help) return output(usage()); const { command, values } = parsed; options = parsed.options; const remote = remoteTarget(options); if (options.json) options.color = false; if (command === "login") { const destination = options.registry ?? options.server ?? (typeof remote === "string" ? remote : remote.registry); output(line("info", `Opening sign-in for ${destination}`, options)); const session = await login(remote, { github: options.github, fetchImplementation, sleep, onStart: (started) => { open(started.verification_uri); output(options.verbose ? `Opening ${started.verification_uri}.` : `If your browser didn't open, open ${started.verification_uri} and enter ${started.user_code ?? "the displayed code"}.`); } }); writeSelectedTarget(remote); output(line("success", `Signed in as ${session.session.email}`, options)); return; } if (command === "logout") { const server = remote.server ?? remote; const profile = readProfile(server); if (profile?.token) await registryRequest(remote, "/v1/auth/logout", { method: "POST", authenticated: true, fetchImplementation }); deleteProfile(server); clearSelectedTarget(remote); output(line("success", `Signed out of ${server}`, options)); return; } if (command === "pull") return await pull(values[0], options, output, fetchImplementation); if (command === "up") return await up(options, output); if (command === "publish") return await publish(options, output, fetchImplementation); return await doctor(values[0], options, output, fetchImplementation); } catch (caught) { const detail = options?.verbose && caught?.stack ? caught.stack : caught.message; error(line("info", `Error: ${detail}`, { color: false })); exit(1); } }

package/src/registry.mjs

@@ -9,12 +9,14 @@ function profileKey(server) {
   return crypto.createHash("sha256").update(new URL(server).origin).digest("hex").slice(0, 24);
 }
 
-function credentialPath(server) {
-  const root = process.env.DOME_TEMPLATES_CONFIG_HOME
+function configRoot() {
+  return process.env.DOME_TEMPLATES_CONFIG_HOME
     ?? path.join(process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config"), "dome", "templates");
-  return path.join(root, `${profileKey(server)}.json`);
 }
 
+function credentialPath(server) { return path.join(configRoot(), `${profileKey(server)}.json`); }
+function selectedTargetPath() { return path.join(configRoot(), "selected-target.json"); }
+
 export function normalizeServer(server = DEFAULT_SERVER) {
   const url = new URL(server);
   if (url.protocol !== "https:" && url.hostname !== "localhost" && url.hostname !== "127.0.0.1") {
@@ -26,6 +28,35 @@ export function normalizeServer(server = DEFAULT_SERVER) {
   return url.toString().replace(/\/$/, "");
 }
 
+export function directRegistry(server) {
+  const registry = normalizeServer(server);
+  return { server: registry, registry };
+}
+
+export function readSelectedTarget() {
+  try {
+    const selected = JSON.parse(fs.readFileSync(selectedTargetPath(), "utf8"));
+    if (selected.mode === "registry" && typeof selected.url === "string") return directRegistry(selected.url);
+    if (selected.mode === "server" && typeof selected.url === "string") return normalizeServer(selected.url);
+  } catch {}
+  return null;
+}
+
+export function writeSelectedTarget(target) {
+  const selected = typeof target === "string"
+    ? { mode: "server", url: normalizeServer(target) }
+    : { mode: "registry", url: normalizeServer(target.registry) };
+  fs.mkdirSync(configRoot(), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(selectedTargetPath(), `${JSON.stringify(selected, null, 2)}\n`, { mode: 0o600 });
+}
+
+export function clearSelectedTarget(target) {
+  const current = readSelectedTarget();
+  const currentUrl = typeof current === "string" ? current : current?.registry;
+  const targetUrl = typeof target === "string" ? normalizeServer(target) : target.registry;
+  if (currentUrl === targetUrl) fs.rmSync(selectedTargetPath(), { force: true });
+}
+
 export function readProfile(server) {
   try {
     const profile = JSON.parse(fs.readFileSync(credentialPath(server), "utf8"));
@@ -60,8 +91,12 @@ export async function discover(server, fetchImplementation = globalThis.fetch) {
   return { server: selected, registry: endpoint.toString().replace(/\/$/, "") };
 }
 
+async function targetFor(server, fetchImplementation) {
+  return typeof server === "string" ? discover(server, fetchImplementation) : server;
+}
+
 export async function registryRequest(server, pathname, { method = "GET", body, authenticated = false, fetchImplementation = globalThis.fetch } = {}) {
-  const target = await discover(server, fetchImplementation);
+  const target = await targetFor(server, fetchImplementation);
   const headers = { accept: "application/json" };
   if (body !== undefined) headers["content-type"] = "application/json";
   if (authenticated) {
@@ -76,7 +111,7 @@ export async function registryRequest(server, pathname, { method = "GET", body,
 }
 
 export async function login(server, { github = false, fetchImplementation = globalThis.fetch, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), onStart } = {}) {
-  const target = await discover(server, fetchImplementation);
+  const target = await targetFor(server, fetchImplementation);
   const response = await fetchImplementation(`${target.registry}/v1/auth/device/start`, {
     method: "POST", headers: { accept: "application/json", "content-type": "application/json" }, body: JSON.stringify({ github }),
   });