uplink-cli 0.1.38 → 0.1.39

package/AGENTS.md

@@ -0,0 +1,161 @@
+# Agent Integration Guide
+
+For agents (Cursor, Claude Code, Codex, Windsurf, and similar) to use Uplink **non-interactively**.
+
+Install: `npm install -g uplink-cli` or `npx uplink-cli …`  
+Package name: `uplink-cli` · Binary: `uplink`
+
+## Auth
+
+- Use `AGENTCLOUD_TOKEN` (bearer). Prefer stdin over argv:
+  ```bash
+  echo "$TOKEN" | uplink --token-stdin …
+  ```
+- API base: `--api-base https://api.uplink.spot` or `AGENTCLOUD_API_BASE`.
+
+## Signup (no auth required)
+
+```bash
+uplink signup --json
+uplink signup --label "cursor-agent" --expires-days 30 --json
+```
+
+Save `token` from the JSON — it is shown only once. Then:
+
+```bash
+export AGENTCLOUD_TOKEN='…'
+```
+
+## Machine-mode contract
+
+| Rule | Detail |
+|------|--------|
+| `--json` | stdout = JSON only; logs/errors go to stderr |
+| Exit `0` | success |
+| Exit `2` | usage / bad args |
+| Exit `10` | auth missing/invalid |
+| Exit `20` | network |
+| Exit `30` | server / unknown |
+
+Premium aliases may return `ALIAS_NOT_ENABLED` / `ALIAS_LIMIT_REACHED`.
+
+## Tunnels (share localhost)
+
+`tunnel create` **creates the API record and starts the local client** so the public URL works. Use `--api-only` only if you will start the client yourself.
+
+```bash
+# Create + start client (optional alias if enabled)
+echo "$TOKEN" | uplink --token-stdin \
+  tunnel create --port 3000 --alias myapp --json
+
+# List (includes connected status)
+echo "$TOKEN" | uplink --token-stdin tunnel list --json
+
+# Alias on an existing tunnel
+echo "$TOKEN" | uplink --token-stdin tunnel alias-set --id tun_xxx --alias myapp --json
+echo "$TOKEN" | uplink --token-stdin tunnel alias-delete --id tun_xxx --json
+
+# Stats / stop
+echo "$TOKEN" | uplink --token-stdin tunnel stats --id tun_xxx --json
+echo "$TOKEN" | uplink --token-stdin tunnel stop --id tun_xxx --json
+echo "$TOKEN" | uplink --token-stdin tunnel stop --all --json
+```
+
+JSON create shape (representative):
+
+```json
+{
+  "tunnel": { "id": "tun_…", "url": "https://abc.x.uplink.spot", "token": "…", "status": "…" },
+  "alias": "myapp",
+  "aliasError": null,
+  "url": "https://myapp.uplink.spot",
+  "client": { "pid": 12345, "started": true }
+}
+```
+
+`connected` on `tunnel list` means the local client is attached to the relay.
+
+## Hosting
+
+Use `--json`. For prompts, pass `--yes`.
+
+```bash
+echo "$TOKEN" | uplink --token-stdin host setup \
+  --path /path/to/app --name myapp --env-file /path/to/.env \
+  --wait-timeout 900 --wait-interval 5 --yes --json
+
+echo "$TOKEN" | uplink --token-stdin host deploy \
+  --path /path/to/app --name myapp --wait --json
+
+echo "$TOKEN" | uplink --token-stdin host analyze --path /path/to/app --json
+echo "$TOKEN" | uplink --token-stdin host preflight --path /path/to/app --json
+echo "$TOKEN" | uplink --token-stdin host list --json
+echo "$TOKEN" | uplink --token-stdin host status --id app_xxx --json
+echo "$TOKEN" | uplink --token-stdin host logs --id app_xxx --json
+echo "$TOKEN" | uplink --token-stdin host delete --id app_xxx --yes --json
+```
+
+Notes:
+- Next.js server hosting expects `output: "standalone"`. Vite/CRA → static `dist`/`build`.
+- Prefer a `.uplinkignore` (`node_modules`, `.next`, `dist`, `*.log`, local `.db`, …).
+- `host logs` may return `NOT_READY` until a deployment is running.
+- `host delete` requires `--yes` (or typing `DELETE` interactively).
+
+## Custom domains
+
+Registrar inventory is CLI. Attach/verify is under `host domains`.  
+The bare `uplink domains` search TUI is **optional** and not bundled with npm — use the JSON commands below.
+
+```bash
+uplink domains providers connect godaddy --token-env GODADDY_PAT --json
+uplink domains providers connect cloudflare --token-env CF_API_TOKEN --json
+uplink domains providers connect hostinger --token-env HOSTINGER_API_TOKEN --json
+uplink domains providers connect namecheap --token-env NAMECHEAP_API_KEY --user-env NAMECHEAP_API_USER --json
+uplink domains providers list --json
+uplink domains providers disconnect godaddy --json
+
+uplink domains list --json
+uplink domains check example.com --json
+
+echo "$TOKEN" | uplink --token-stdin host domains add --id app_xxx --hostname example.com --json
+echo "$TOKEN" | uplink --token-stdin host domains verify --id app_xxx --hostname example.com --json
+echo "$TOKEN" | uplink --token-stdin host domains list --id app_xxx --json
+echo "$TOKEN" | uplink --token-stdin host domains remove --id app_xxx --hostname example.com --json
+```
+
+Do not treat RDAP “available” as buyable unless `domains check` says `buyable: true`. Purchase is not wired yet.
+
+## Databases (optional)
+
+```bash
+echo "$TOKEN" | uplink --token-stdin db create --name mydb --project myproj --json
+echo "$TOKEN" | uplink --token-stdin db list --json
+echo "$TOKEN" | uplink --token-stdin db info --id db_xxx --json
+echo "$TOKEN" | uplink --token-stdin db delete --id db_xxx --yes --json
+```
+
+## Failure modes agents should expect
+
+| Symptom | Likely cause |
+|---------|----------------|
+| URL 502 / not connected | Local process on `--port` not running, or client died — re-run `tunnel create` or check `tunnel list` |
+| Auth errors | Missing/invalid `AGENTCLOUD_TOKEN`; use `--token-stdin` |
+| `ALIAS_NOT_ENABLED` | Account does not have permanent aliases |
+| Domain search TUI missing | Expected on npm — use `domains list` / `check` / `host domains *` |
+| Hosting stuck `queued` | Edge builder/runner issue — check `host status` / `host logs` |
+
+## Interactive menu
+
+Humans: `uplink` or `uplink menu` (Share · Hosting · Domains).  
+Agents should prefer the non-interactive commands above.
+
+## URLs
+
+- Ephemeral tunnels: `https://<token>.x.uplink.spot`
+- Aliases: `https://<alias>.uplink.spot`
+
+## More
+
+- Menu map: `docs/MENU_STRUCTURE.md`
+- Website: https://uplink.spot
+- npm: https://www.npmjs.com/package/uplink-cli

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 First Principle Code
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,20 +1,15 @@
 # Uplink CLI
 
-Share your local app with others for demos, testing, review, and quick feedback — without deploying.
+**Software for agents** — share localhost, host apps, and attach domains from the terminal. Built for Cursor, Claude Code, Codex, Windsurf, and humans who live in a shell.
 
 ![Uplink CLI](./assets/cli-screenshot.png)
 
 ## Key features
-- **Expose any local port**: Turn `localhost:<port>` into a public HTTPS URL like `https://abc123.x.uplink.spot`
-- **Agent-first**: Works well with Cursor, Claude Code, Codex, Windsurf (and other agentic tools)
-- **Terminal-native**: Start/stop tunnels and manage URLs from an interactive menu
-- **No browser required**: Create an account + token from the CLI (`uplink signup`), then automate everything
-- **Open source CLI**: Inspect, extend, and contribute
-
-## Why use Uplink
-- **Fastest way to share localhost**: Great for “can you look at this?” moments
-- **Works great with agents**: machine-readable `--json`, stable exit codes, and stdin token support
-- **Share links + optional permanent URLs**: Permanent URLs are available if enabled on your account
+- **Share any local port**: `localhost:<port>` → public HTTPS (`https://abc123.x.uplink.spot`)
+- **Agent-first**: `--json`, stable exit codes, `--token-stdin` (no browser required)
+- **Hosting**: deploy Next.js / Vite / static apps to Uplink
+- **Domains**: list registrar inventory and attach custom hostnames to hosted apps
+- **Interactive menu**: `uplink` for humans; CLI subcommands for agents
 
 Learn more at [uplink.spot](https://uplink.spot)
 
@@ -32,50 +27,54 @@ uplink signup --json                     # creates account + token
 export AGENTCLOUD_TOKEN=your-token-here  # save securely
 ```
 
+## Quick start (agents)
+```bash
+# Create tunnel + start local client (URL works immediately)
+echo "$AGENTCLOUD_TOKEN" | uplink --token-stdin tunnel create --port 3000 --json
+
+# List / stop
+echo "$AGENTCLOUD_TOKEN" | uplink --token-stdin tunnel list --json
+echo "$AGENTCLOUD_TOKEN" | uplink --token-stdin tunnel stop --id tun_xxx --json
+```
+
+Full contract: **[AGENTS.md](./AGENTS.md)** (also at `docs/AGENTS.md`).
+
 ## Quick start (interactive)
 ```bash
 uplink        # open menu
 ```
-- Start Tunnel → pick or enter port → get URL (e.g., https://abc123.x.uplink.spot)
-- My Tunnels → see status and permanent URL if set
-- Create Permanent URL → pick tunnel → enter alias (if premium enabled)
-
-### Hosting (interactive)
-- Hosting → Setup Wizard → analyze + create + deploy
-- Hosting → Deploy to Existing App → select app with arrow keys
-- Hosting → List Hosted Apps → select app to view ID + URL
-- Hosting → Delete Hosted App → select app, confirm options (type `DELETE` to proceed)
-- Next.js default: server hosting expects `output: "standalone"`
-- Vite / CRA: static build is supported (dist/build served as static)
-
-## Quick start (non-interactive)
-```bash
-# Create tunnel (any port: 3000, 8080, 5173, etc.)
-echo "$AGENTCLOUD_TOKEN" | uplink --token-stdin tunnel create --port 3000 --json
+- **Share** → Start tunnel → pick port → public URL
+- **Hosting** → Setup / Deploy / List / Delete
+- **Domains** → connect registrar, attach hostname to a hosted app
 
-# List tunnels
-echo "$AGENTCLOUD_TOKEN" | uplink --token-stdin tunnel list --json
+## Hosting (non-interactive)
+```bash
+echo "$AGENTCLOUD_TOKEN" | uplink --token-stdin host setup \
+  --path . --name myapp --yes --json
+```
 
-# Set alias (if enabled on account)
-echo "$AGENTCLOUD_TOKEN" | uplink --token-stdin tunnel alias-set --id tun_xxx --alias myapp --json
+## Domains (non-interactive)
+```bash
+uplink domains providers connect godaddy --token-env GODADDY_PAT --json
+uplink domains list --json
+echo "$AGENTCLOUD_TOKEN" | uplink --token-stdin \
+  host domains add --id app_xxx --hostname example.com --json
 ```
 
 ## Agent essentials
 - **`--json`**: stdout = JSON only; stderr = logs/errors
 - **`--token-stdin`**: read token once from stdin (avoid argv leaks)
 - **`--api-base`**: override API host if needed
-- **Exit codes**: 0 ok; 2 usage; 10 auth missing/invalid; 20 network; 30 server/unknown  
-See `docs/AGENTS.md` for the full contract.
+- **Exit codes**: 0 ok · 2 usage · 10 auth · 20 network · 30 server/unknown
 
 ## Key commands
 - `uplink menu` — interactive UI
-- `uplink tunnel create --port <p> [--alias <a>] [--json]`
-- `uplink tunnel list --json`
-- `uplink tunnel alias-set --id <id> --alias <a> --json`
-- `uplink tunnel alias-delete --id <id> --json`
-- `uplink tunnel stats --id <id> --json`
-- `uplink tunnel stop --id <id> --json`
-- `uplink signup --json` — create user + token (no auth)
+- `uplink signup --json`
+- `uplink tunnel create --port <p> [--alias <a>] [--json]` — starts client
+- `uplink tunnel list|stats|stop|alias-set|alias-delete --json`
+- `uplink host setup|deploy|list|status|logs|delete …`
+- `uplink host domains add|verify|list|remove …`
+- `uplink domains list|check|providers …`
 
 ## Environment
 ```bash
@@ -86,14 +85,14 @@ export TUNNEL_DOMAIN=x.uplink.spot
 ```
 
 ## Troubleshooting
-- “No running tunnel clients found” — make sure the tunnel client is still running; restart `uplink` and start a tunnel.
-- Auth errors — verify `AGENTCLOUD_TOKEN` is set/exported; use `--token-stdin`.
-- Relay errors — ensure `TUNNEL_CTRL=tunnel.uplink.spot:7071`.
+- URL not live — ensure something is listening on the port and the client started (`tunnel list` → `connected`)
+- Auth errors — verify `AGENTCLOUD_TOKEN`; prefer `--token-stdin`
+- Relay errors — `TUNNEL_CTRL=tunnel.uplink.spot:7071`
+- Domain search TUI — not bundled on npm; use `domains list` / `check` / `host domains *`
 
 ## Docs
-- Menu reference: `docs/MENU_STRUCTURE.md`
-- Agent guide: `docs/AGENTS.md`
-- Open source CLI scope vs backend: `docs/OPEN_SOURCE_CLI.md`
+- Agents: [AGENTS.md](./AGENTS.md)
+- Menu: [docs/MENU_STRUCTURE.md](./docs/MENU_STRUCTURE.md)
 
 ## License
-MIT
+MIT — see [LICENSE](./LICENSE)

package/cli/src/index.ts

@@ -8,9 +8,11 @@ import { tunnelCommand } from "./subcommands/tunnel";
 import { signupCommand } from "./subcommands/signup";
 import { systemCommand } from "./subcommands/system";
 import { hostCommand } from "./subcommands/host";
+import { domainsCommand } from "./subcommands/domains";
 import { readFileSync } from "fs";
 import { join } from "path";
 import { ensureApiBase, parseTokenEnv } from "./utils/api-base";
+import { handleError } from "./utils/machine";
 
 // Get version from package.json (CommonJS build: __dirname available)
 const pkgPath = join(__dirname, "../../package.json");
@@ -20,7 +22,7 @@ const program = new Command();
 
 program
   .name("uplink")
-  .description("Agent-friendly cloud CLI")
+  .description("Software for agents — share localhost, host apps, attach domains")
   .version(pkg.version)
   .option("--api-base <url>", "Override API base URL (default env AGENTCLOUD_API_BASE)")
   .option("--token-stdin", "Read AGENTCLOUD_TOKEN from stdin once");
@@ -33,6 +35,7 @@ program.addCommand(signupCommand);
 program.addCommand(systemCommand);
 program.addCommand(menuCommand);
 program.addCommand(hostCommand);
+program.addCommand(domainsCommand);
 
 // Global pre-action hook to apply shared options
 let cachedTokenStdin: string | null = null;
@@ -83,7 +86,6 @@ if (process.argv.length === 2) {
 }
 
 program.parseAsync(process.argv).catch((err) => {
-  console.error(err);
-  process.exit(1);
+  handleError(err);
 });
 

package/cli/src/registrars/cloudflare.ts

@@ -0,0 +1,148 @@
+import { httpError } from "./http";
+import type { DomainQuote, InventoryDomain, RegistrarAdapter, RegistrarCredentials } from "./types";
+
+const BASE = "https://api.cloudflare.com/client/v4";
+
+type CfEnvelope<T> = {
+  success?: boolean;
+  errors?: Array<{ message?: string }>;
+  result?: T;
+  result_info?: { cursor?: string };
+};
+
+async function cfFetch(
+  creds: RegistrarCredentials,
+  path: string,
+  init: RequestInit = {}
+): Promise<Response> {
+  if (!creds.token) throw new Error("Cloudflare token is missing");
+  return fetch(`${BASE}${path}`, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${creds.token}`,
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      ...(init.headers || {}),
+    },
+  });
+}
+
+async function cfJson<T>(res: Response): Promise<CfEnvelope<T>> {
+  const text = await res.text();
+  let body: CfEnvelope<T>;
+  try {
+    body = text ? (JSON.parse(text) as CfEnvelope<T>) : {};
+  } catch {
+    throw httpError(res, text);
+  }
+  if (!res.ok || body.success === false) {
+    const message = body.errors?.map((e) => e.message).filter(Boolean).join("; ") || text;
+    throw httpError(res, message);
+  }
+  return body;
+}
+
+function pickUsd(value: unknown): number | undefined {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : undefined;
+  }
+  if (value && typeof value === "object") {
+    const obj = value as { amount?: unknown; value?: unknown; usd?: unknown };
+    return pickUsd(obj.amount ?? obj.value ?? obj.usd);
+  }
+  return undefined;
+}
+
+export const cloudflareAdapter: RegistrarAdapter = {
+  id: "cloudflare",
+  label: "Cloudflare",
+  connectHelp: "API token with account read. --token-env CF_API_TOKEN (optional --account-env CF_ACCOUNT_ID)",
+  async verify(creds) {
+    const res = await cfFetch(creds, "/accounts?per_page=1");
+    const body = await cfJson<Array<{ id?: string }>>(res);
+    const accountId = creds.accountId || body.result?.[0]?.id;
+    if (!accountId) throw new Error("Cloudflare token has no accounts");
+    return { ...creds, accountId };
+  },
+  async listDomains(creds) {
+    const accountId = creds.accountId;
+    if (!accountId) throw new Error("Cloudflare account id is missing");
+    const out: InventoryDomain[] = [];
+
+    const registrations = await cfFetch(creds, `/accounts/${accountId}/registrar/registrations`);
+    if (registrations.ok) {
+      const body = await cfJson<Array<{ domain_name?: string; expires_at?: string }>>(registrations);
+      for (const item of body.result || []) {
+        if (!item.domain_name) continue;
+        out.push({
+          domain: item.domain_name.toLowerCase(),
+          provider: "cloudflare",
+          status: "owned",
+          expiresAt: item.expires_at,
+        });
+      }
+    }
+
+    if (out.length > 0) return out;
+
+    const zones = await cfFetch(creds, "/zones?per_page=50");
+    if (!zones.ok) {
+      if (!registrations.ok) throw httpError(registrations, await registrations.text());
+      return out;
+    }
+    const body = await cfJson<Array<{ name?: string }>>(zones);
+    for (const zone of body.result || []) {
+      if (!zone.name) continue;
+      out.push({ domain: zone.name.toLowerCase(), provider: "cloudflare", status: "owned" });
+    }
+    return out;
+  },
+  async check(creds, domain) {
+    const accountId = creds.accountId;
+    if (!accountId) throw new Error("Cloudflare account id is missing");
+    let res = await cfFetch(creds, `/accounts/${accountId}/registrar/domain-check`, {
+      method: "POST",
+      body: JSON.stringify({ domains: [domain] }),
+    });
+    if (res.status === 400) {
+      res = await cfFetch(creds, `/accounts/${accountId}/registrar/domain-check`, {
+        method: "POST",
+        body: JSON.stringify({ domain_names: [domain] }),
+      });
+    }
+    if (!res.ok) throw httpError(res, await res.text());
+    const body = await cfJson<unknown>(res);
+    const rows = Array.isArray(body.result) ? body.result : body.result ? [body.result] : [];
+    const row = (rows[0] || {}) as {
+      domain_name?: string;
+      registrable?: boolean;
+      available?: boolean;
+      tier?: string;
+      reason?: string;
+      fees?: { registration?: unknown };
+      prices?: { registration?: unknown };
+      price?: unknown;
+    };
+    const available = row.registrable === true || row.available === true;
+    const priceUsd = pickUsd(row.fees?.registration ?? row.prices?.registration ?? row.price);
+    if (available) {
+      return {
+        domain,
+        provider: "cloudflare",
+        status: "available",
+        buyable: row.tier !== "premium",
+        premium: row.tier === "premium",
+        priceUsd,
+      };
+    }
+    return {
+      domain,
+      provider: "cloudflare",
+      status: row.reason ? "not_for_sale" : "taken",
+      buyable: false,
+      error: row.reason,
+    };
+  },
+};

package/cli/src/registrars/godaddy.ts

@@ -0,0 +1,99 @@
+import { httpError, parseJson } from "./http";
+import type { DomainQuote, InventoryDomain, RegistrarAdapter, RegistrarCredentials } from "./types";
+
+const BASE = "https://api.godaddy.com";
+
+async function godaddyFetch(
+  creds: RegistrarCredentials,
+  path: string,
+  init: RequestInit = {}
+): Promise<Response> {
+  if (!creds.token) throw new Error("GoDaddy token is missing");
+  return fetch(`${BASE}${path}`, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${creds.token}`,
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      ...(init.headers || {}),
+    },
+  });
+}
+
+function centsToUsd(value: number): number {
+  return value / 100;
+}
+
+function microToUsd(value: number): number {
+  return value / 1_000_000;
+}
+
+export const godaddyAdapter: RegistrarAdapter = {
+  id: "godaddy",
+  label: "GoDaddy",
+  connectHelp: "Personal Access Token with domains.domain:read. --token-env GODADDY_PAT",
+  async verify(creds) {
+    const res = await godaddyFetch(creds, "/v1/domains?limit=1");
+    if (!res.ok) throw httpError(res, await res.text());
+    return creds;
+  },
+  async listDomains(creds) {
+    const out: InventoryDomain[] = [];
+    let marker: string | undefined;
+    for (;;) {
+      const params = new URLSearchParams({ limit: "100" });
+      if (marker) params.set("marker", marker);
+      const res = await godaddyFetch(creds, `/v1/domains?${params}`);
+      if (!res.ok) throw httpError(res, await res.text());
+      const batch = await parseJson<Array<{ domain?: string; expires?: string }>>(res);
+      if (!Array.isArray(batch) || batch.length === 0) break;
+      for (const item of batch) {
+        if (!item.domain) continue;
+        out.push({
+          domain: item.domain.toLowerCase(),
+          provider: "godaddy",
+          status: "owned",
+          expiresAt: item.expires,
+        });
+      }
+      if (batch.length < 100) break;
+      marker = batch[batch.length - 1]?.domain;
+      if (!marker) break;
+    }
+    return out;
+  },
+  async check(creds, domain) {
+    const v3 = await godaddyFetch(
+      creds,
+      `/v3/domains/check-availability?domain=${encodeURIComponent(domain)}`
+    );
+    if (v3.ok) {
+      const data = await parseJson<{
+        available?: boolean;
+        prices?: Array<{ period?: number; price?: { value?: number } }>;
+      }>(v3);
+      const year1 = data.prices?.find((p) => p.period === 1) ?? data.prices?.[0];
+      const priceUsd = year1?.price?.value != null ? centsToUsd(year1.price.value) : undefined;
+      if (data.available) {
+        return { domain, provider: "godaddy", status: "available", buyable: true, priceUsd };
+      }
+      return { domain, provider: "godaddy", status: "taken", buyable: false };
+    }
+
+    const v1 = await godaddyFetch(
+      creds,
+      `/v1/domains/available?domain=${encodeURIComponent(domain)}`
+    );
+    if (!v1.ok) throw httpError(v1, await v1.text());
+    const data = await parseJson<{
+      available?: boolean;
+      price?: number;
+      currency?: string;
+    }>(v1);
+    const priceUsd = data.price != null ? microToUsd(data.price) : undefined;
+    if (data.available) {
+      return { domain, provider: "godaddy", status: "available", buyable: true, priceUsd };
+    }
+    return { domain, provider: "godaddy", status: "taken", buyable: false };
+  },
+};