uplink-cli 0.1.38 → 0.1.39

package/cli/src/subcommands/db.ts

@@ -1,5 +1,6 @@
 import { Command } from "commander";
 import { apiRequest } from "../http";
+import { handleError, printJson } from "../utils/machine";
 
 export const dbCommand = new Command("db").description("Manage databases");
 
@@ -13,19 +14,20 @@ dbCommand
   .option("--plan <plan>", "Plan", "dev")
   .option("--json", "Output JSON", false)
   .action(async (opts) => {
-    const body = {
-      name: opts.name,
-      project: opts.project,
-      provider: opts.provider,
-      region: opts.region,
-      plan: opts.plan,
-    };
+    try {
+      const body = {
+        name: opts.name,
+        project: opts.project,
+        provider: opts.provider,
+        region: opts.region,
+        plan: opts.plan,
+      };
 
-    const result = await apiRequest("POST", "/v1/dbs", body);
-    if (opts.json) {
-      console.log(JSON.stringify(result, null, 2));
-    } else {
-      console.log(`Created DB ${result.name} (${result.id}) in ${result.region}`);
+      const result = await apiRequest("POST", "/v1/dbs", body);
+      if (opts.json) printJson(result);
+      else console.log(`Created DB ${result.name} (${result.id}) in ${result.region}`);
+    } catch (error) {
+      handleError(error, { json: opts.json });
     }
   });
 
@@ -35,16 +37,20 @@ dbCommand
   .option("--project <project>", "Project name")
   .option("--json", "Output JSON", false)
   .action(async (opts) => {
-    const query = opts.project ? `?project=${encodeURIComponent(opts.project)}` : "";
-    const result = await apiRequest("GET", `/v1/dbs${query}`);
-    if (opts.json) {
-      console.log(JSON.stringify(result, null, 2));
-    } else {
-      for (const db of result.items) {
-        console.log(
-          `${db.id}  ${db.name}  ${db.region}  ${db.status}  ready=${db.ready}`
-        );
+    try {
+      const query = opts.project ? `?project=${encodeURIComponent(opts.project)}` : "";
+      const result = await apiRequest("GET", `/v1/dbs${query}`);
+      if (opts.json) {
+        printJson(result);
+      } else {
+        for (const db of result.items || []) {
+          console.log(
+            `${db.id}  ${db.name}  ${db.region}  ${db.status}  ready=${db.ready}`
+          );
+        }
       }
+    } catch (error) {
+      handleError(error, { json: opts.json });
     }
   });
 
@@ -54,14 +60,18 @@ dbCommand
   .requiredOption("--id <id>", "Database id")
   .option("--json", "Output JSON", false)
   .action(async (opts) => {
-    const result = await apiRequest("GET", `/v1/dbs/${opts.id}`);
-    if (opts.json) {
-      console.log(JSON.stringify(result, null, 2));
-    } else {
-      console.log(`DB ${result.name} (${result.id})`);
-      console.log(`  region: ${result.region}`);
-      console.log(`  status: ${result.status}`);
-      console.log(`  engine: ${result.engine} ${result.version}`);
+    try {
+      const result = await apiRequest("GET", `/v1/dbs/${opts.id}`);
+      if (opts.json) {
+        printJson(result);
+      } else {
+        console.log(`DB ${result.name} (${result.id})`);
+        console.log(`  region: ${result.region}`);
+        console.log(`  status: ${result.status}`);
+        console.log(`  engine: ${result.engine} ${result.version}`);
+      }
+    } catch (error) {
+      handleError(error, { json: opts.json });
     }
   });
 
@@ -72,14 +82,15 @@ dbCommand
   .option("--yes", "Confirm deletion", false)
   .option("--json", "Output JSON", false)
   .action(async (opts) => {
-    if (!opts.yes) {
-      throw new Error("Refusing to delete without --yes");
-    }
-    const result = await apiRequest("DELETE", `/v1/dbs/${opts.id}`);
-    if (opts.json) {
-      console.log(JSON.stringify(result, null, 2));
-    } else {
-      console.log(`Deleted DB ${result.id}`);
+    try {
+      if (!opts.yes) {
+        throw new Error("Refusing to delete without --yes");
+      }
+      const result = await apiRequest("DELETE", `/v1/dbs/${opts.id}`);
+      if (opts.json) printJson(result);
+      else console.log(`Deleted DB ${result.id}`);
+    } catch (error) {
+      handleError(error, { json: opts.json });
     }
   });
 
@@ -91,27 +102,22 @@ dbCommand
   .requiredOption("--env-var <envVar>", "Environment variable name")
   .option("--json", "Output JSON", false)
   .action(async (opts) => {
-    const body = {
-      service: opts.service,
-      envVar: opts["env-var"],
-    };
+    try {
+      const body = {
+        service: opts.service,
+        envVar: opts.envVar,
+      };
 
-    const result = await apiRequest(
-      "POST",
-      `/v1/dbs/${opts["db-id"]}/link-service`,
-      body
-    );
+      const result = await apiRequest("POST", `/v1/dbs/${opts.dbId}/link-service`, body);
 
-    if (opts.json) {
-      console.log(JSON.stringify(result, null, 2));
-    } else {
-      console.log(
-        `Linked DB ${result.dbId} to service ${result.service} as ${result.envVar}`
-      );
+      if (opts.json) {
+        printJson(result);
+      } else {
+        console.log(
+          `Linked DB ${result.dbId} to service ${result.service} as ${result.envVar}`
+        );
+      }
+    } catch (error) {
+      handleError(error, { json: opts.json });
     }
   });
-
-
-
-
-

package/cli/src/subcommands/dev.ts

@@ -1,26 +1,33 @@
 import { Command } from "commander";
 import { spawn } from "child_process";
 import { apiRequest } from "../http";
-import path from "path";
+import { handleError, printJson } from "../utils/machine";
+import { resolveTunnelClientPath } from "./menu/effects/tunnel-clients";
 
 export const devCommand = new Command("dev")
-  .description("Run local dev with optional tunnel")
-  .option("--tunnel", "Enable tunnel")
+  .description("Run local tunnel client against a new tunnel (foreground)")
+  .option("--tunnel", "Enable tunnel", false)
   .option("--port <port>", "Local port to expose", "3000")
   .option("--json", "Output JSON", false)
-  .option("--improved", "Use improved client with auto-reconnect and better error handling", false)
   .action(async (opts) => {
     const port = Number(opts.port);
-    if (opts.tunnel) {
-      // Request tunnel from control plane
+    if (!Number.isFinite(port) || port <= 0) {
+      console.error("Invalid port. Provide a positive integer.");
+      process.exit(2);
+    }
+
+    if (!opts.tunnel) {
+      console.log("Tunnel not enabled. Provide --tunnel to expose localhost.");
+      console.log("Prefer: uplink tunnel create --port <port> --json");
+      return;
+    }
+
+    try {
       const result = await apiRequest("POST", "/v1/tunnels", { port });
       if (opts.json) {
-        console.log(JSON.stringify(result, null, 2));
+        printJson(result);
       } else {
         console.log(`Tunnel URL: ${result.url}`);
-        // If the control-plane returns an https URL for the dev.uplink.spot domain,
-        // it may not actually be reachable unless TLS is configured on the relay.
-        // Print an HTTP fallback to reduce confusion during development.
         if (
           typeof result.url === "string" &&
           result.url.startsWith("https://") &&
@@ -30,14 +37,7 @@ export const devCommand = new Command("dev")
         }
       }
 
-      // Spawn tunnel client (use improved version if requested)
-      const clientFile = opts.improved ? "client-improved.js" : "client.js";
-      const clientPath = path.join(
-        process.cwd(),
-        "scripts",
-        "tunnel",
-        clientFile
-      );
+      const clientPath = resolveTunnelClientPath();
       const ctrlHost = process.env.TUNNEL_CTRL ?? "tunnel.uplink.spot:7071";
       const args = [
         clientPath,
@@ -48,10 +48,11 @@ export const devCommand = new Command("dev")
         "--ctrl",
         ctrlHost,
       ];
-      console.log(`Starting tunnel client: node ${args.join(" ")}`);
+      if (!opts.json) {
+        console.log(`Starting tunnel client: node ${args.join(" ")}`);
+      }
       const child = spawn("node", args, { stdio: "inherit" });
 
-      // Forward Ctrl+C / termination to the child so the tunnel shuts down cleanly.
       const shutdown = () => {
         try {
           child.kill("SIGINT");
@@ -62,7 +63,6 @@ export const devCommand = new Command("dev")
       process.on("SIGINT", shutdown);
       process.on("SIGTERM", shutdown);
 
-      // Keep the CLI process alive while the tunnel client is running.
       await new Promise<void>((resolve) => {
         child.on("exit", (code, signal) => {
           process.off("SIGINT", shutdown);
@@ -78,9 +78,7 @@ export const devCommand = new Command("dev")
           resolve();
         });
       });
-    } else {
-      console.log("Tunnel not enabled. Provide --tunnel to expose localhost.");
+    } catch (error) {
+      handleError(error, { json: opts.json });
     }
   });
-
-

package/cli/src/subcommands/domains.ts

@@ -0,0 +1,268 @@
+import { Command } from "commander";
+import { launchDomainking } from "../utils/launchDomainking";
+import { handleError, printJson } from "../utils/machine";
+import {
+  adapters,
+  getAdapter,
+  isProviderId,
+  readRegistrarStore,
+  removeProvider,
+  saveProvider,
+  type DomainQuote,
+  type InventoryDomain,
+  type ProviderId,
+  type RegistrarCredentials,
+} from "../registrars";
+import { canPrompt, promptSecret, readEnvValue } from "../registrars/secret";
+
+const CHECK_ORDER: ProviderId[] = ["godaddy", "cloudflare", "hostinger", "namecheap"];
+
+function parseProvider(raw?: string): ProviderId | undefined {
+  if (!raw) return undefined;
+  const id = raw.toLowerCase();
+  if (!isProviderId(id)) throw new Error(`Unknown provider: ${raw}`);
+  return id;
+}
+
+async function credentialsFromFlags(
+  provider: ProviderId,
+  opts: { tokenEnv?: string; userEnv?: string; accountEnv?: string; json?: boolean }
+): Promise<RegistrarCredentials> {
+  const interactive = canPrompt() && !opts.json;
+
+  if (provider === "namecheap") {
+    const apiKey = opts.tokenEnv
+      ? readEnvValue(opts.tokenEnv)
+      : interactive
+        ? await promptSecret("Namecheap API key: ")
+        : "";
+    const apiUser = opts.userEnv
+      ? readEnvValue(opts.userEnv)
+      : interactive
+        ? await promptSecret("Namecheap API user: ")
+        : "";
+    if (!apiKey || !apiUser) {
+      throw new Error(
+        "Namecheap needs --token-env NAMECHEAP_API_KEY and --user-env NAMECHEAP_API_USER"
+      );
+    }
+    return { apiKey, apiUser };
+  }
+
+  const token = opts.tokenEnv
+    ? readEnvValue(opts.tokenEnv)
+    : interactive
+      ? await promptSecret(`${provider} API token: `)
+      : "";
+  if (!token) {
+    throw new Error(`${provider} needs --token-env <VAR> (do not pass the secret on the command line)`);
+  }
+  const creds: RegistrarCredentials = { token };
+  if (opts.accountEnv) creds.accountId = readEnvValue(opts.accountEnv);
+  return creds;
+}
+
+async function listInventory(providerFilter?: ProviderId): Promise<InventoryDomain[]> {
+  const store = readRegistrarStore();
+  const ids = providerFilter ? [providerFilter] : CHECK_ORDER.filter((id) => store[id]);
+  const domains: InventoryDomain[] = [];
+  const errors: string[] = [];
+  for (const id of ids) {
+    const creds = store[id];
+    if (!creds) {
+      if (providerFilter) throw new Error(`${id} is not connected`);
+      continue;
+    }
+    try {
+      const listed = await getAdapter(id).listDomains(creds);
+      domains.push(...listed);
+    } catch (error) {
+      errors.push(`${id}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (domains.length === 0 && errors.length > 0) {
+    throw new Error(errors.join("; "));
+  }
+  return domains.sort((a, b) => a.domain.localeCompare(b.domain));
+}
+
+async function quoteDomain(domain: string, providerFilter?: ProviderId): Promise<DomainQuote> {
+  const store = readRegistrarStore();
+  const inventory = await listInventory(providerFilter).catch(() => [] as InventoryDomain[]);
+  const owned = inventory.find((item) => item.domain === domain);
+  if (owned) {
+    return { domain, provider: owned.provider, status: "owned", buyable: false };
+  }
+
+  const ids = providerFilter
+    ? [providerFilter]
+    : CHECK_ORDER.filter((id) => store[id]);
+  if (ids.length === 0) {
+    throw new Error(
+      "No registrar connected. Run: uplink domains providers connect godaddy --token-env GODADDY_PAT --json"
+    );
+  }
+
+  let lastError: string | undefined;
+  for (const id of ids) {
+    const creds = store[id];
+    if (!creds) throw new Error(`${id} is not connected`);
+    try {
+      return await getAdapter(id).check(creds, domain);
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : String(error);
+    }
+  }
+  return {
+    domain,
+    provider: ids[0],
+    status: "unknown",
+    error: lastError || "check failed",
+  };
+}
+
+export const domainsCommand = new Command("domains").description(
+  "Registrar inventory, availability, and search. Attach with `uplink host domains`."
+);
+
+domainsCommand.addHelpText(
+  "after",
+  "\nWith no subcommand, opens the domain search TUI.\n"
+);
+
+domainsCommand.action(() => {
+  const message = launchDomainking();
+  if (message) console.log(message);
+});
+
+domainsCommand
+  .command("list")
+  .description("List domains owned at connected registrars")
+  .option("--provider <id>", "Only this provider (godaddy|cloudflare|hostinger|namecheap)")
+  .option("--json", "Output JSON", false)
+  .action(async (opts) => {
+    try {
+      const provider = parseProvider(opts.provider);
+      const domains = await listInventory(provider);
+      if (opts.json) {
+        printJson({ domains, count: domains.length });
+        return;
+      }
+      if (domains.length === 0) {
+        console.log("No domains. Connect a registrar: uplink domains providers connect godaddy");
+        return;
+      }
+      for (const item of domains) {
+        const expiry = item.expiresAt ? `  expires ${item.expiresAt}` : "";
+        console.log(`- ${item.domain} (${item.provider}${expiry})`);
+      }
+    } catch (error) {
+      handleError(error, { json: opts.json });
+    }
+  });
+
+domainsCommand
+  .command("check")
+  .description("Ask a connected registrar if a domain is buyable, and at what price")
+  .argument("<domain>", "Domain name (e.g. example.com)")
+  .option("--provider <id>", "Which registrar to ask")
+  .option("--json", "Output JSON", false)
+  .action(async (domainArg: string, opts) => {
+    try {
+      const domain = String(domainArg).trim().toLowerCase();
+      if (!domain.includes(".")) throw new Error("Pass a full domain like example.com");
+      const provider = parseProvider(opts.provider);
+      const quote = await quoteDomain(domain, provider);
+      if (opts.json) {
+        printJson(quote);
+        return;
+      }
+      const price = quote.priceUsd != null ? `  $${quote.priceUsd.toFixed(2)}/yr` : "";
+      const premium = quote.premium ? " premium" : "";
+      console.log(`${quote.domain}  ${quote.status}${price}${premium}  [${quote.provider}]`);
+      if (quote.error) console.log(`  ${quote.error}`);
+    } catch (error) {
+      handleError(error, { json: opts.json });
+    }
+  });
+
+const providers = domainsCommand.command("providers").description("Connect registrar accounts");
+
+providers
+  .command("list")
+  .description("Show which registrars are connected (never prints secrets)")
+  .option("--json", "Output JSON", false)
+  .action((opts) => {
+    try {
+      const store = readRegistrarStore();
+      const items = adapters.map((adapter) => ({
+        id: adapter.id,
+        label: adapter.label,
+        connected: Boolean(store[adapter.id]),
+        help: adapter.connectHelp,
+      }));
+      if (opts.json) {
+        printJson({ providers: items });
+        return;
+      }
+      for (const item of items) {
+        console.log(`- ${item.id}  ${item.connected ? "connected" : "not connected"}`);
+        if (!item.connected) console.log(`    ${item.help}`);
+      }
+    } catch (error) {
+      handleError(error, { json: opts.json });
+    }
+  });
+
+providers
+  .command("connect")
+  .description("Save a registrar credential after a live check")
+  .argument("<provider>", "godaddy | cloudflare | hostinger | namecheap")
+  .option("--token-env <name>", "Env var holding the API token or Namecheap API key")
+  .option("--user-env <name>", "Env var holding the Namecheap API user")
+  .option("--account-env <name>", "Env var holding a Cloudflare account id (optional)")
+  .option("--json", "Output JSON", false)
+  .action(async (providerArg: string, opts) => {
+    try {
+      const provider = String(providerArg).toLowerCase();
+      if (!isProviderId(provider)) {
+        throw new Error(`Unknown provider: ${providerArg}. Use godaddy, cloudflare, hostinger, or namecheap`);
+      }
+      const adapter = getAdapter(provider);
+      const creds = await credentialsFromFlags(provider, opts);
+      const verified = await adapter.verify(creds);
+      saveProvider(provider, verified);
+      const listed = await adapter.listDomains(verified).catch(() => [] as InventoryDomain[]);
+      if (opts.json) {
+        printJson({
+          provider,
+          connected: true,
+          domains: listed.length,
+        });
+        return;
+      }
+      console.log(`Connected ${adapter.label} (${listed.length} domain${listed.length === 1 ? "" : "s"})`);
+    } catch (error) {
+      handleError(error, { json: opts.json });
+    }
+  });
+
+providers
+  .command("disconnect")
+  .description("Remove a saved registrar credential")
+  .argument("<provider>", "godaddy | cloudflare | hostinger | namecheap")
+  .option("--json", "Output JSON", false)
+  .action((providerArg: string, opts) => {
+    try {
+      const provider = String(providerArg).toLowerCase();
+      if (!isProviderId(provider)) throw new Error(`Unknown provider: ${providerArg}`);
+      const removed = removeProvider(provider);
+      if (opts.json) {
+        printJson({ provider, connected: false, removed });
+        return;
+      }
+      console.log(removed ? `Disconnected ${provider}` : `${provider} was not connected`);
+    } catch (error) {
+      handleError(error, { json: opts.json });
+    }
+  });

package/cli/src/subcommands/host-domains.ts

@@ -0,0 +1,148 @@
+import { Command } from "commander";
+import { apiRequest } from "../http";
+import { handleError, printJson } from "../utils/machine";
+
+type AppDomain = {
+  id: string;
+  hostname: string;
+  verified: boolean;
+  verifiedAt: string | null;
+  createdAt: string;
+  dns?: { type: string; host: string; target: string };
+};
+type AppDomainList = { domains: AppDomain[] };
+
+async function findDomainByHostname(appId: string, hostname: string): Promise<AppDomain | null> {
+  const result = (await apiRequest("GET", `/v1/apps/${appId}/domains`)) as AppDomainList;
+  const clean = hostname.trim().toLowerCase();
+  return result.domains?.find((d) => d.hostname === clean) ?? null;
+}
+
+function printDomain(domain: AppDomain): void {
+  const status = domain.verified ? "verified" : "pending verification";
+  console.log(`- ${domain.hostname} (${status})`);
+  if (domain.dns) {
+    console.log(`  DNS needed: ${domain.dns.type} ${domain.dns.host} -> ${domain.dns.target}`);
+  }
+}
+
+/** The verify endpoint responds 409 with a reason while DNS doesn't point at the edge. */
+function extractVerifyFailure(error: unknown): { reason?: string; dns?: AppDomain["dns"] } | null {
+  if (!(error instanceof Error)) return null;
+  try {
+    const parsed = JSON.parse(error.message) as { reason?: string; dns?: AppDomain["dns"] };
+    return parsed && (parsed.reason || parsed.dns) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+export const domainsCommand = new Command("domains").description(
+  "Manage custom domains for hosted apps"
+);
+
+domainsCommand
+  .command("list")
+  .description("List custom domains attached to an app")
+  .requiredOption("--id <id>", "App id (app_...)")
+  .option("--json", "Output JSON", false)
+  .action(async (opts) => {
+    try {
+      const result = (await apiRequest("GET", `/v1/apps/${opts.id}/domains`)) as AppDomainList;
+      if (opts.json) {
+        printJson(result);
+        return;
+      }
+      if (!result.domains || result.domains.length === 0) {
+        console.log("No custom domains attached.");
+        return;
+      }
+      console.log("Custom domains:");
+      for (const domain of result.domains) printDomain(domain);
+    } catch (error) {
+      handleError(error, { json: opts.json });
+    }
+  });
+
+domainsCommand
+  .command("add")
+  .description("Attach a custom domain to an app")
+  .requiredOption("--id <id>", "App id (app_...)")
+  .requiredOption("--hostname <hostname>", "Domain to attach (e.g. example.com)")
+  .option("--json", "Output JSON", false)
+  .action(async (opts) => {
+    try {
+      const domain = (await apiRequest("POST", `/v1/apps/${opts.id}/domains`, {
+        hostname: opts.hostname,
+      })) as AppDomain;
+      if (opts.json) {
+        printJson(domain);
+        return;
+      }
+      console.log(`Attached ${domain.hostname} (pending verification)`);
+      if (domain.dns) {
+        console.log(`  1. At your registrar: ${domain.dns.type} ${domain.dns.host} -> ${domain.dns.target}`);
+      }
+      console.log(`  2. Then run: uplink host domains verify --id ${opts.id} --hostname ${domain.hostname}`);
+    } catch (error) {
+      handleError(error, { json: opts.json });
+    }
+  });
+
+domainsCommand
+  .command("verify")
+  .description("Verify a domain's DNS points at the hosting edge (enables routing + TLS)")
+  .requiredOption("--id <id>", "App id (app_...)")
+  .requiredOption("--hostname <hostname>", "Domain to verify")
+  .option("--json", "Output JSON", false)
+  .action(async (opts) => {
+    try {
+      const domain = await findDomainByHostname(opts.id, opts.hostname);
+      if (!domain) throw new Error(`Domain ${opts.hostname} is not attached to app ${opts.id}`);
+
+      try {
+        const verified = (await apiRequest(
+          "POST",
+          `/v1/apps/${opts.id}/domains/${domain.id}/verify`
+        )) as AppDomain;
+        if (opts.json) printJson(verified);
+        else {
+          console.log(`Verified ${verified.hostname}`);
+          console.log(`  Live at https://${verified.hostname} (cert issues on first request)`);
+        }
+      } catch (error) {
+        const failure = extractVerifyFailure(error);
+        if (!failure) throw error;
+        if (opts.json) {
+          printJson({ hostname: domain.hostname, verified: false, ...failure });
+          return;
+        }
+        console.log(`Not verified yet: ${failure.reason || "DNS does not point at the edge"}`);
+        if (failure.dns) {
+          console.log(`  DNS needed: ${failure.dns.type} ${failure.dns.host} -> ${failure.dns.target}`);
+        }
+        console.log("  DNS changes can take a few minutes to propagate; try again shortly.");
+        process.exitCode = 1;
+      }
+    } catch (error) {
+      handleError(error, { json: opts.json });
+    }
+  });
+
+domainsCommand
+  .command("remove")
+  .description("Detach a custom domain from an app")
+  .requiredOption("--id <id>", "App id (app_...)")
+  .requiredOption("--hostname <hostname>", "Domain to detach")
+  .option("--json", "Output JSON", false)
+  .action(async (opts) => {
+    try {
+      const domain = await findDomainByHostname(opts.id, opts.hostname);
+      if (!domain) throw new Error(`Domain ${opts.hostname} is not attached to app ${opts.id}`);
+      const result = await apiRequest("DELETE", `/v1/apps/${opts.id}/domains/${domain.id}`);
+      if (opts.json) printJson(result);
+      else console.log(`Detached ${opts.hostname}`);
+    } catch (error) {
+      handleError(error, { json: opts.json });
+    }
+  });

package/cli/src/subcommands/host.ts

@@ -13,6 +13,7 @@ import os from "os";
 import fetch from "node-fetch";
 import { spawnSync } from "child_process";
 import { getResolvedApiBase, getResolvedApiToken } from "../utils/api-base";
+import { domainsCommand } from "./host-domains";
 
 type App = { id: string; name: string; url: string; createdAt?: string; updatedAt?: string };
 type AppList = { apps: App[]; count: number };
@@ -591,6 +592,8 @@ function writeUplinkIgnore(dir: string, entries: string[]): void {
 
 export const hostCommand = new Command("host").description("Host persistent web services (Dockerfile required)");
 
+hostCommand.addCommand(domainsCommand);
+
 async function resolveSqliteConfig(
   analysis: AnalysisResult,
   opts: { yes: boolean }