uplink-cli 0.1.37 → 0.1.39

package/cli/src/subcommands/host.ts

@@ -2,6 +2,7 @@ import { Command } from "commander";
 import { apiRequest } from "../http";
 import { handleError, printJson } from "../utils/machine";
 import { analyzeProject, AnalysisResult, buildRequirements } from "../utils/analyze";
+import { getFrameworkOutputCheck } from "../utils/framework-output";
 import { generateDockerfile, generateHostConfig } from "../templates";
 import { createHash } from "crypto";
 import { createReadStream, existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
@@ -12,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 };
@@ -590,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 }
@@ -651,13 +655,15 @@ function findNextConfigPath(dir: string): string | null {
   return null;
 }
 
-function hasStandaloneOutputConfig(content: string): boolean {
-  return /output\s*:\s*["']standalone["']/.test(content);
-}
-
 function applyStandaloneOutputConfig(configPath: string): boolean {
   const content = readFileSync(configPath, "utf8");
-  if (hasStandaloneOutputConfig(content)) return false;
+  const outputRegex = /output\s*:\s*["'](?:standalone|export)["']\s*,?/g;
+  if (outputRegex.test(content)) {
+    const updated = content.replace(outputRegex, 'output: "standalone",');
+    if (updated === content) return false;
+    writeFileSync(configPath, updated, "utf8");
+    return true;
+  }
   const nextConfigAssign = /(const\s+nextConfig[^=]*=\s*\{)/;
   const moduleExportsAssign = /(module\.exports\s*=\s*\{)/;
   const exportDefaultAssign = /(export\s+default\s*\{)/;
@@ -672,6 +678,26 @@ function applyStandaloneOutputConfig(configPath: string): boolean {
   return true;
 }
 
+function updateNextOutputMode(
+  analysis: AnalysisResult,
+  mode: "standalone" | "export" | "unknown",
+  configPath?: string
+): void {
+  if (analysis.framework?.name !== "nextjs") return;
+  analysis.frameworkOutput = {
+    framework: "nextjs",
+    mode,
+    distDir: analysis.frameworkOutput?.distDir,
+    configPath: configPath || analysis.frameworkOutput?.configPath,
+  };
+}
+
+function formatFrameworkOutputGuidance(analysis: AnalysisResult): string[] {
+  const outputCheck = getFrameworkOutputCheck(analysis.frameworkOutput);
+  if (!outputCheck) return [];
+  return outputCheck.guidance;
+}
+
 function dockerfileHasPrismaGenerate(dockerfilePath: string): boolean {
   if (!existsSync(dockerfilePath)) return false;
   const content = readFileSync(dockerfilePath, "utf8");
@@ -907,22 +933,23 @@ function buildPreflightChecklist(
   }
 
   if (analysis.framework?.name === "nextjs") {
-    const configPath = findNextConfigPath(dir);
-    const hasStandalone = configPath ? hasStandaloneOutputConfig(readFileSync(configPath, "utf8")) : false;
+    const outputCheck = getFrameworkOutputCheck(analysis.frameworkOutput);
     const dockerfilePath = join(dir, "Dockerfile");
-    if (analysis.dockerfile.exists && dockerfileExpectsStandalone(dockerfilePath) && !hasStandalone) {
+    const expectsStandalone = analysis.dockerfile.exists && dockerfileExpectsStandalone(dockerfilePath);
+    if (outputCheck?.mode === "export") {
       items.push({
-        level: "required",
-        title: "Next.js output is missing `standalone`",
-        detail: "Dockerfile expects .next/standalone.",
-        action: "Add `output: \"standalone\"` to your Next.js config.",
+        level: expectsStandalone ? "required" : "recommended",
+        title: "Next.js output is set to export",
+        detail: "Static export does not produce .next/standalone.",
+        action: outputCheck.guidance.join(" "),
       });
-    } else if (!analysis.dockerfile.exists && configPath && !hasStandalone) {
+    } else if (outputCheck?.mode === "unknown") {
+      const level = expectsStandalone ? "required" : "recommended";
       items.push({
-        level: "recommended",
-        title: "Next.js output is not set to `standalone`",
+        level,
+        title: "Next.js output mode not detected",
         detail: "Standalone builds reduce image size and simplify runtime.",
-        action: "Consider adding `output: \"standalone\"`.",
+        action: outputCheck.guidance.join(" "),
       });
     }
   }
@@ -1031,6 +1058,13 @@ hostCommand
         } else {
           console.log("Framework:       (not detected)");
         }
+        const outputCheck = getFrameworkOutputCheck(analysis.frameworkOutput);
+        if (outputCheck) {
+          console.log(`Output mode:     ${outputCheck.mode}`);
+          if (analysis.frameworkOutput?.distDir) {
+            console.log(`Output dir:      ${analysis.frameworkOutput.distDir}`);
+          }
+        }
 
         // Package manager
         if (analysis.packageManager) {
@@ -1190,6 +1224,13 @@ hostCommand
       } else {
         console.log("  Framework:       (not detected)");
       }
+      const outputCheck = getFrameworkOutputCheck(analysis.frameworkOutput);
+      if (outputCheck) {
+        console.log(`  Output mode:     ${outputCheck.mode}`);
+        if (analysis.frameworkOutput?.distDir) {
+          console.log(`  Output dir:      ${analysis.frameworkOutput.distDir}`);
+        }
+      }
       if (analysis.packageManager) {
         console.log(`  Package manager: ${analysis.packageManager}`);
       }
@@ -1237,8 +1278,8 @@ hostCommand
       if (interactive && analysis.framework?.name === "nextjs") {
         const configPath = findNextConfigPath(dir);
         if (configPath) {
-          const content = readFileSync(configPath, "utf8");
-          if (!hasStandaloneOutputConfig(content)) {
+          const outputMode = analysis.frameworkOutput?.mode || "unknown";
+          if (outputMode !== "standalone") {
             const answer = (await promptLine(
               `\nAdd output: "standalone" to ${basename(configPath)}? (Y/n): `
             ))
@@ -1246,7 +1287,10 @@ hostCommand
               .toLowerCase();
             if (answer === "" || answer === "y" || answer === "yes") {
               const updated = applyStandaloneOutputConfig(configPath);
-              if (updated) console.log("  Updated Next.js config for standalone output");
+              if (updated) {
+                updateNextOutputMode(analysis, "standalone", configPath);
+                console.log("  Updated Next.js config for standalone output");
+              }
             }
           }
         }
@@ -1293,6 +1337,16 @@ hostCommand
 
       // Generate Dockerfile if needed
       if (needsDockerfile) {
+        const outputGuidance = formatFrameworkOutputGuidance(analysis);
+        const outputCheck = getFrameworkOutputCheck(analysis.frameworkOutput);
+        if (analysis.framework?.name === "nextjs" && outputCheck && outputCheck.mode !== "standalone") {
+          console.log(`\n${outputCheck.summary}`);
+          for (const line of outputGuidance) {
+            console.log(`  ${line}`);
+          }
+          console.log("  Resolve this or provide a Dockerfile manually.");
+          return;
+        }
         if (analysis.nativeNodeDeps.length > 0) {
           const choice = opts.yes
             ? "y"
@@ -1337,11 +1391,11 @@ hostCommand
 
       // Next.js specific: check for standalone output
       if (analysis.framework?.name === "nextjs" && needsDockerfile) {
-        const configPath = findNextConfigPath(dir);
-        if (configPath) {
-          const content = readFileSync(configPath, "utf8");
-          if (!hasStandaloneOutputConfig(content)) {
-            console.log("\n  Note: Add `output: \"standalone\"` to your next.config for Docker builds");
+        const outputCheck = getFrameworkOutputCheck(analysis.frameworkOutput);
+        if (outputCheck && outputCheck.mode !== "standalone") {
+          console.log(`\n  Note: ${outputCheck.summary}`);
+          for (const line of outputCheck.guidance) {
+            console.log(`  ${line}`);
           }
         }
       }
@@ -1588,6 +1642,13 @@ hostCommand
       const preflight = buildPreflightChecklist(dir, analysis, extraEnv);
       if (!opts.json) {
         console.log(`    Framework: ${analysis.framework?.name || "(not detected)"}`);
+        const outputCheck = getFrameworkOutputCheck(analysis.frameworkOutput);
+        if (outputCheck) {
+          console.log(`    Output mode: ${outputCheck.mode}`);
+          if (analysis.frameworkOutput?.distDir) {
+            console.log(`    Output dir: ${analysis.frameworkOutput.distDir}`);
+          }
+        }
         const sqliteMeta = getSqliteMeta(analysis.database);
         const dbPath = sqliteMeta.path ? ` path=${sqliteMeta.path}` : "";
         const dbEnv = sqliteMeta.envVar ? ` env=${sqliteMeta.envVar}` : "";
@@ -1627,8 +1688,8 @@ hostCommand
       if (interactive && analysis.framework?.name === "nextjs") {
         const configPath = findNextConfigPath(dir);
         if (configPath) {
-          const content = readFileSync(configPath, "utf8");
-          if (!hasStandaloneOutputConfig(content)) {
+          const outputMode = analysis.frameworkOutput?.mode || "unknown";
+          if (outputMode !== "standalone") {
             const answer = (await promptLine(
               `    Add output: "standalone" to ${basename(configPath)}? (Y/n): `
             ))
@@ -1637,6 +1698,7 @@ hostCommand
             if (answer === "" || answer === "y" || answer === "yes") {
               const updated = applyStandaloneOutputConfig(configPath);
               if (updated && !opts.json) {
+                updateNextOutputMode(analysis, "standalone", configPath);
                 console.log("    Updated Next.js config for standalone output");
               }
             }
@@ -1710,6 +1772,18 @@ hostCommand
 
       // Step 2: Generate Dockerfile
       if (!analysis.dockerfile.exists) {
+        const outputGuidance = formatFrameworkOutputGuidance(analysis);
+        const outputCheck = getFrameworkOutputCheck(analysis.frameworkOutput);
+        if (analysis.framework?.name === "nextjs" && outputCheck && outputCheck.mode !== "standalone") {
+          if (!opts.json) {
+            console.log(`\n${outputCheck.summary}`);
+            for (const line of outputGuidance) {
+              console.log(`  ${line}`);
+            }
+            console.log("  Resolve this or provide a Dockerfile manually.");
+          }
+          return;
+        }
         if (analysis.nativeNodeDeps.length > 0) {
           const choice = useDefaults
             ? "y"
@@ -1756,12 +1830,12 @@ hostCommand
 
       // Next.js: check for standalone output
       if (analysis.framework?.name === "nextjs") {
-        const configPath = findNextConfigPath(dir);
-        if (configPath) {
-          const content = readFileSync(configPath, "utf8");
-          if (!hasStandaloneOutputConfig(content)) {
-            if (!opts.json) {
-              console.log("\n    Note: Your next.config may need `output: \"standalone\"` for Docker builds");
+        const outputCheck = getFrameworkOutputCheck(analysis.frameworkOutput);
+        if (outputCheck && outputCheck.mode !== "standalone") {
+          if (!opts.json) {
+            console.log(`\n    Note: ${outputCheck.summary}`);
+            for (const line of outputCheck.guidance) {
+              console.log(`    ${line}`);
             }
           }
         }

package/cli/src/subcommands/menu/colors.ts

@@ -67,5 +67,5 @@ export function colorSoftGray(text: string) {
 }
 
 export function colorAccent(text: string) {
-  return `${c.brightBlue}${text}${c.reset}`;
+  return `${c.bold}${c.brightWhite}${text}${c.reset}`;
 }

package/cli/src/subcommands/menu/effects/tunnel-clients.ts

@@ -1,8 +1,44 @@
 import { execSync, spawn } from "child_process";
+import { existsSync } from "fs";
+import path from "path";
 import { resolveProjectRoot } from "../../../utils/project-root";
 
 export type TunnelClient = { pid: number; port: number; token: string };
 
+export function resolveTunnelClientPath(): string {
+  const projectRoot = resolveProjectRoot(__dirname);
+  const clientPath = path.join(projectRoot, "scripts/tunnel/client-improved.js");
+  if (!existsSync(clientPath)) {
+    throw new Error(`Tunnel client not found at ${clientPath}`);
+  }
+  return clientPath;
+}
+
+/** Start the local tunnel client in the background (detached). */
+export function startTunnelClient(opts: {
+  token: string;
+  port: number;
+  ctrl?: string;
+}): { pid: number; clientPath: string } {
+  const projectRoot = resolveProjectRoot(__dirname);
+  const clientPath = resolveTunnelClientPath();
+  const ctrl = opts.ctrl || process.env.TUNNEL_CTRL || "tunnel.uplink.spot:7071";
+  const clientProcess = spawn(
+    "node",
+    [clientPath, "--token", opts.token, "--port", String(opts.port), "--ctrl", ctrl],
+    {
+      stdio: "ignore",
+      detached: true,
+      cwd: projectRoot,
+    }
+  );
+  clientProcess.unref();
+  if (!clientProcess.pid) {
+    throw new Error("Failed to start tunnel client process");
+  }
+  return { pid: clientProcess.pid, clientPath };
+}
+
 export function findTunnelClients(): TunnelClient[] {
   try {
     // Find processes running client-improved.js (current user, match script path to avoid false positives)
@@ -39,11 +75,23 @@ export function findTunnelClients(): TunnelClient[] {
 
 export function killTunnelClient(pid: number): boolean {
   try {
-    execSync(`kill -TERM ${pid}`, { stdio: "ignore" });
-    return true;
+    process.kill(pid, "SIGTERM");
   } catch {
     return false;
   }
+  try {
+    execSync(`kill -0 ${pid} && sleep 0.4 && kill -KILL ${pid} || true`, {
+      stdio: "ignore",
+    });
+  } catch {
+    /* process already gone */
+  }
+  try {
+    process.kill(pid, 0);
+    return false;
+  } catch {
+    return true;
+  }
 }
 
 export function killAllTunnelClients(clients: TunnelClient[]): number {
@@ -54,8 +102,44 @@ export function killAllTunnelClients(clients: TunnelClient[]): number {
   return killed;
 }
 
+type ApiTunnel = { id?: string; token?: string; connected?: boolean };
+
 type ApiRequest = (method: string, path: string, body?: unknown) => Promise<any>;
 
+export async function stopTunnelClients(
+  apiRequest: ApiRequest,
+  clients: TunnelClient[],
+  opts: { connectedGhosts?: boolean } = {}
+): Promise<{ killed: number; deleted: number }> {
+  const tokens = new Set(clients.map((c) => c.token));
+  let deleted = 0;
+
+  try {
+    const result = await apiRequest("GET", "/v1/tunnels");
+    const tunnels = (result.tunnels || []) as ApiTunnel[];
+    for (const tunnel of tunnels) {
+      if (!tunnel.id) continue;
+      const matched = Boolean(tunnel.token && tokens.has(tunnel.token));
+      const ghost = Boolean(opts.connectedGhosts && tunnel.connected);
+      if (!matched && !ghost) continue;
+      try {
+        await apiRequest("DELETE", `/v1/tunnels/${tunnel.id}`);
+        deleted++;
+      } catch {
+        /* keep stopping the rest */
+      }
+    }
+  } catch {
+    /* still kill local processes */
+  }
+
+  let killed = 0;
+  for (const c of clients) {
+    if (killTunnelClient(c.pid)) killed++;
+  }
+  return { killed, deleted };
+}
+
 /**
  * Create a tunnel via API and start the local client in background.
  * NOTE: Maintains existing behavior including the brief post-spawn delay.
@@ -79,19 +163,8 @@ export async function createAndStartTunnel(apiRequest: ApiRequest, port: number)
   const url = result.url || "(no url)";
   const token = result.token || "(no token)";
   const alias = result.alias || null;
-  const ctrl = process.env.TUNNEL_CTRL || "tunnel.uplink.spot:7071";
 
-  // Start tunnel client in background
-  // (CommonJS build: __dirname available)
-  const path = require("path");
-  const projectRoot = resolveProjectRoot(__dirname);
-  const clientPath = path.join(projectRoot, "scripts/tunnel/client-improved.js");
-  const clientProcess = spawn("node", [clientPath, "--token", token, "--port", String(port), "--ctrl", ctrl], {
-    stdio: "ignore",
-    detached: true,
-    cwd: projectRoot,
-  });
-  clientProcess.unref();
+  startTunnelClient({ token, port });
 
   // Wait a moment for client to connect
   await new Promise((resolve) => setTimeout(resolve, 2000));

package/cli/src/subcommands/menu/inline-tree-select.ts

@@ -1,4 +1,4 @@
-import { colorCyan, colorDim } from "./colors";
+import { colorBold, colorDim } from "./colors";
 
 // Inline arrow-key selector (returns selected option, or null for "Back")
 export type SelectOption = { label: string; value: string | number | null };
@@ -32,11 +32,11 @@ export async function inlineSelect(
         let branchColor: string;
 
         if (isSelected) {
-          branchColor = colorCyan(branch);
+          branchColor = colorBold(branch);
           if (opt.label === "Back") {
             label = colorDim(opt.label);
           } else {
-            label = colorCyan(opt.label);
+            label = colorBold(opt.label);
           }
         } else {
           branchColor = colorDim(branch);
@@ -58,13 +58,14 @@ export async function inlineSelect(
     allOptions.forEach((opt, idx) => {
       const isLast = idx === allOptions.length - 1;
       const branch = isLast ? "└─" : "├─";
-      const branchColor = idx === 0 ? colorCyan(branch) : colorDim(branch);
-      const label = idx === 0 ? colorCyan(opt.label) : opt.label === "Back" ? colorDim(opt.label) : opt.label;
+      const branchColor = idx === 0 ? colorBold(branch) : colorDim(branch);
+      const label = idx === 0 ? colorBold(opt.label) : opt.label === "Back" ? colorDim(opt.label) : opt.label;
       console.log(`${branchColor} ${label}`);
     });
 
     // Set up key handler
     try {
+      process.stdin.ref();
       process.stdin.setRawMode(true);
       process.stdin.resume();
     } catch {

package/cli/src/subcommands/menu/io.ts

@@ -10,13 +10,35 @@ function stylePrompt(question: string): string {
     .replace(backTokenRegex, (match) => colorBold(match));
 }
 
+export function prepareStdinForPrompt(): void {
+  try {
+    process.stdin.setRawMode(false);
+  } catch {
+    /* ignore */
+  }
+  process.stdin.ref();
+  process.stdin.resume();
+  process.stdin.setEncoding("utf8");
+  drainStdin();
+}
+
+/** Drop a leftover Enter from Ink so readline does not auto-answer the next prompt. */
+function drainStdin(): void {
+  const stdin = process.stdin as NodeJS.ReadStream & { read?: () => unknown };
+  if (typeof stdin.read !== "function") return;
+  try {
+    let chunk: unknown;
+    while ((chunk = stdin.read()) !== null) {
+      void chunk;
+    }
+  } catch {
+    /* ignore */
+  }
+}
+
 export function promptLine(question: string): Promise<string> {
   return new Promise((resolve) => {
-    try {
-      process.stdin.setRawMode(false);
-    } catch {
-      /* ignore */
-    }
+    prepareStdinForPrompt();
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     rl.question(stylePrompt(question), (answer) => {
       rl.close();

package/cli/src/subcommands/menu/menus/domains.ts

@@ -0,0 +1,199 @@
+import type { SelectOption } from "../inline-tree-select";
+import type { MenuChoice } from "../types";
+import { launchDomainking } from "../../../utils/launchDomainking";
+import { parseHostedApps, runCli, runCliCapture } from "./hosting";
+
+type Deps = {
+  promptLine: (question: string) => Promise<string>;
+  restoreRawMode: () => void;
+  inlineSelect: (
+    title: string,
+    options: SelectOption[],
+    includeBack?: boolean
+  ) => Promise<{ index: number; value: string | number | null } | null>;
+};
+
+const PROVIDER_OPTIONS: SelectOption[] = [
+  { label: "GoDaddy", value: "godaddy" },
+  { label: "Cloudflare", value: "cloudflare" },
+  { label: "Hostinger", value: "hostinger" },
+  { label: "Namecheap", value: "namecheap" },
+];
+
+async function pickHostedApp(
+  deps: Deps,
+  title: string
+): Promise<{ name: string; id: string; url?: string } | null> {
+  const output = runCliCapture(["host", "list"]);
+  if (!output || output.includes("No apps found")) {
+    deps.restoreRawMode();
+    return null;
+  }
+  const apps = parseHostedApps(output);
+  if (apps.length === 0) {
+    deps.restoreRawMode();
+    return null;
+  }
+  const options: SelectOption[] = apps.map((app) => ({
+    label: `${app.name}${app.url ? `  ${app.url}` : ""}`,
+    value: app.id,
+  }));
+  const choice = await deps.inlineSelect(title, options, true);
+  if (choice === null) {
+    deps.restoreRawMode();
+    return null;
+  }
+  return apps.find((app) => app.id === choice.value) ?? null;
+}
+
+export function buildDomainsMenu(deps: Deps): MenuChoice {
+  const { restoreRawMode, promptLine } = deps;
+
+  return {
+    label: "Domains",
+    subMenu: [
+      {
+        label: "My domains",
+        action: async () => {
+          try {
+            const output = runCliCapture(["domains", "list"]);
+            restoreRawMode();
+            return output || "No domains. Connect a registrar first.";
+          } catch (error) {
+            restoreRawMode();
+            return error instanceof Error ? error.message : String(error);
+          }
+        },
+      },
+      {
+        label: "Connect registrar",
+        action: async () => {
+          const choice = await deps.inlineSelect("Which registrar?", PROVIDER_OPTIONS, true);
+          if (choice === null || typeof choice.value !== "string") {
+            restoreRawMode();
+            return "";
+          }
+          const provider = choice.value;
+          const extraEnv: Record<string, string> = {};
+          const args = ["domains", "providers", "connect", provider, "--token-env", "UPLINK_CONNECT_TOKEN"];
+          if (provider === "namecheap") {
+            const user = (await promptLine("Namecheap API user (or back): ")).trim();
+            if (!user || user === "back") {
+              restoreRawMode();
+              return "";
+            }
+            const key = (await promptLine("Namecheap API key (or back): ")).trim();
+            if (!key || key === "back") {
+              restoreRawMode();
+              return "";
+            }
+            extraEnv.UPLINK_CONNECT_TOKEN = key;
+            extraEnv.UPLINK_CONNECT_USER = user;
+            args.push("--user-env", "UPLINK_CONNECT_USER");
+          } else {
+            const token = (
+              await promptLine(
+                `${PROVIDER_OPTIONS.find((option) => option.value === provider)?.label ?? provider} API token (or back): `
+              )
+            ).trim();
+            if (!token || token === "back") {
+              restoreRawMode();
+              return "";
+            }
+            extraEnv.UPLINK_CONNECT_TOKEN = token;
+          }
+          try {
+            runCli(args, extraEnv);
+            restoreRawMode();
+            return `Connected ${provider}.`;
+          } catch (error) {
+            restoreRawMode();
+            return error instanceof Error ? error.message : String(error);
+          }
+        },
+      },
+      {
+        label: "Find a domain",
+        action: async () => {
+          restoreRawMode();
+          return launchDomainking();
+        },
+      },
+      {
+        label: "Attach to app",
+        action: async () => {
+          const app = await pickHostedApp(deps, "Attach domain to which app?");
+          if (!app) return "No hosted apps. Deploy one under Host first.";
+          const hostname = (await promptLine("Hostname (e.g. example.com, or back): ")).trim().toLowerCase();
+          if (!hostname || hostname === "back") {
+            restoreRawMode();
+            return "";
+          }
+          runCli(["host", "domains", "add", "--id", app.id, "--hostname", hostname]);
+          restoreRawMode();
+          return `Attached ${hostname} to ${app.name}. Point DNS, then Verify.`;
+        },
+      },
+      {
+        label: "Verify DNS",
+        action: async () => {
+          const app = await pickHostedApp(deps, "Verify a domain on which app?");
+          if (!app) return "No hosted apps.";
+          const hostname = (await promptLine("Hostname to verify (or back): ")).trim().toLowerCase();
+          if (!hostname || hostname === "back") {
+            restoreRawMode();
+            return "";
+          }
+          runCli(["host", "domains", "verify", "--id", app.id, "--hostname", hostname]);
+          restoreRawMode();
+          return `Checked ${hostname} on ${app.name}.`;
+        },
+      },
+      {
+        label: "List on app",
+        action: async () => {
+          const app = await pickHostedApp(deps, "List domains for which app?");
+          if (!app) return "No hosted apps.";
+          const output = runCliCapture(["host", "domains", "list", "--id", app.id]);
+          restoreRawMode();
+          return `${app.name}\n${output || "No custom domains attached."}`;
+        },
+      },
+      {
+        label: "Detach from app",
+        action: async () => {
+          const app = await pickHostedApp(deps, "Detach a domain from which app?");
+          if (!app) return "No hosted apps.";
+          const hostname = (await promptLine("Hostname to detach (or back): ")).trim().toLowerCase();
+          if (!hostname || hostname === "back") {
+            restoreRawMode();
+            return "";
+          }
+          runCli(["host", "domains", "remove", "--id", app.id, "--hostname", hostname]);
+          restoreRawMode();
+          return `Detached ${hostname} from ${app.name}.`;
+        },
+      },
+      {
+        label: "Help",
+        action: async () => {
+          return [
+            "Uplink lists domains you already own at connected registrars, then attaches them to hosted apps.",
+            "",
+            "  My domains  — inventory from GoDaddy / Cloudflare / Hostinger / Namecheap",
+            "  Connect     — save a registrar token (same as the CLI)",
+            "  Find        — search names that are not yours yet",
+            "  Attach      — bind a hostname to a hosted app",
+            "  Verify      — check DNS points at the hosting edge, then TLS",
+            "",
+            "CLI (agents):",
+            "  uplink domains providers connect godaddy --token-env GODADDY_PAT --json",
+            "  uplink domains list --json",
+            "  uplink domains check example.com --json",
+            "  uplink host domains add --id <app> --hostname example.com --json",
+          ].join("\n");
+        },
+      },
+    ],
+  };
+}