uplink-cli 0.1.38 → 0.2.0

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/domain-check.ts

@@ -0,0 +1,34 @@
+import { launchDomainking, resolveDomainkingEntry } from "../../../utils/launchDomainking";
+import { runCliCapture } from "./hosting";
+
+type Deps = {
+  promptLine: (question: string) => Promise<string>;
+  restoreRawMode: () => void;
+};
+
+/**
+ * Shared "find a domain" action: the Domainking search TUI when it is
+ * available, otherwise an inline prompt against `uplink domains check`
+ * (which works without a registrar via public DNS/RDAP).
+ */
+export function buildFindDomainAction(deps: Deps): () => Promise<string> {
+  return async () => {
+    if (resolveDomainkingEntry()) {
+      deps.restoreRawMode();
+      return launchDomainking();
+    }
+
+    const domain = (await deps.promptLine("Domain to check (e.g. example.com, or back): "))
+      .trim()
+      .toLowerCase();
+    deps.restoreRawMode();
+    if (!domain || domain === "back") return "";
+    if (!domain.includes(".")) return "Pass a full domain like example.com";
+
+    try {
+      return runCliCapture(["domains", "check", domain]) || `${domain}: no result.`;
+    } catch (error) {
+      return error instanceof Error ? error.message : String(error);
+    }
+  };
+}

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

@@ -0,0 +1,197 @@
+import type { SelectOption } from "../inline-tree-select";
+import type { MenuChoice } from "../types";
+import { buildFindDomainAction } from "./domain-check";
+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" },
+  { label: "DreamHost", value: "dreamhost" },
+];
+
+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: buildFindDomainAction(deps),
+      },
+      {
+        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 / DreamHost",
+            "  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");
+        },
+      },
+    ],
+  };
+}

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

@@ -14,9 +14,13 @@ type Deps = {
   ) => Promise<{ index: number; value: string | number | null } | null>;
 };
 
-type HostedApp = { name: string; id: string; url?: string };
+export type HostedApp = { name: string; id: string; url?: string };
 
-function parseHostedApps(output: string): HostedApp[] {
+function appOptionLabel(app: HostedApp): string {
+  return app.url ? `${app.name}  ${app.url}` : app.name;
+}
+
+export function parseHostedApps(output: string): HostedApp[] {
   const lines = output.split("\n");
   const apps: HostedApp[] = [];
   for (let i = 0; i < lines.length; i += 1) {
@@ -47,7 +51,7 @@ async function resolvePath(promptLine: Deps["promptLine"]): Promise<string | nul
   }
 }
 
-function runCli(args: string[]): void {
+export function runCli(args: string[], extraEnv?: Record<string, string>): void {
   try {
     process.stdin.setRawMode(false);
   } catch {
@@ -57,6 +61,7 @@ function runCli(args: string[]): void {
   const cmd = cliBin ? [cliBin, ...args] : [process.argv[1], ...args];
   const result = spawnSync(process.execPath, cmd, {
     stdio: "inherit",
+    env: extraEnv ? { ...process.env, ...extraEnv } : process.env,
   });
   if (result.error) throw result.error;
   if (result.status && result.status !== 0) {
@@ -64,7 +69,7 @@ function runCli(args: string[]): void {
   }
 }
 
-function runCliCapture(args: string[]): string {
+export function runCliCapture(args: string[], extraEnv?: Record<string, string>): string {
   try {
     process.stdin.setRawMode(false);
   } catch {
@@ -75,6 +80,7 @@ function runCliCapture(args: string[]): string {
   const result = spawnSync(process.execPath, cmd, {
     stdio: ["ignore", "pipe", "pipe"],
     encoding: "utf8",
+    env: extraEnv ? { ...process.env, ...extraEnv } : process.env,
   });
   if (result.error) throw result.error;
   if (result.status && result.status !== 0) {
@@ -120,7 +126,7 @@ export function buildHostingMenu(deps: Deps): MenuChoice {
             return "No apps found. Use Setup Wizard to create one first.";
           }
           const options: SelectOption[] = apps.map((app) => ({
-            label: `${app.name} (${app.id})`,
+            label: appOptionLabel(app),
             value: app.id,
           }));
           const choice = await inlineSelect("Select app to deploy to", options, true);
@@ -160,45 +166,6 @@ export function buildHostingMenu(deps: Deps): MenuChoice {
           return "Analysis complete.";
         },
       },
-      {
-        label: "List Hosted Apps",
-        action: async () => {
-          const output = runCliCapture(["host", "list"]);
-          if (!output || output.includes("No apps found")) {
-            restoreRawMode();
-            return "No apps found.";
-          }
-          const apps = parseHostedApps(output);
-          if (apps.length === 0) {
-            restoreRawMode();
-            return "No apps found.";
-          }
-          const options: SelectOption[] = apps.map((app) => ({
-            label: `${app.name} (${app.id})${app.url ? ` ${app.url}` : ""}`,
-            value: app.id,
-          }));
-          const choice = await inlineSelect("Hosted apps", options, true);
-          if (choice === null) {
-            restoreRawMode();
-            return "";
-          }
-          const selected = apps.find((app) => app.id === choice.value);
-          if (!selected) {
-            restoreRawMode();
-            return "Invalid selection.";
-          }
-          restoreRawMode();
-          return [
-            `App: ${selected.name}`,
-            `ID:  ${selected.id}`,
-            selected.url ? `URL: ${selected.url}` : "",
-            "",
-            "Commands:",
-            `  uplink host status --id ${selected.id}`,
-            `  uplink host logs --id ${selected.id}`,
-          ].join("\n");
-        },
-      },
       {
         label: "Delete Hosted App",
         action: async () => {
@@ -213,7 +180,7 @@ export function buildHostingMenu(deps: Deps): MenuChoice {
             return "No apps found.";
           }
           const options: SelectOption[] = apps.map((app) => ({
-            label: `${app.name} (${app.id})`,
+            label: appOptionLabel(app),
             value: app.id,
           }));
           const choice = await inlineSelect("Select app to delete", options, true);
@@ -251,8 +218,9 @@ export function buildHostingMenu(deps: Deps): MenuChoice {
             "  Setup Wizard     - First-time setup: creates Dockerfile, config, app, and deploys",
             "  Deploy           - Redeploy to an existing app (faster, skips setup)",
             "  Analyze          - Check project for deployment readiness",
-            "  List Apps        - Show your deployed apps",
+            "  Apps              - Arrow through apps to inspect url, status, and size",
             "  Delete App       - Remove an app and optionally its data",
+            "  Custom domains   - also under the top-level Domains menu",
             "",
             "CLI commands:",
             "  uplink host setup --name <app> --path <path>   # Full setup + deploy",

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

@@ -4,4 +4,5 @@ export { buildManageTokensMenu } from "./tokens";
 export { buildManageTunnelsMenu } from "./tunnels";
 export { buildManageAliasesMenu } from "./aliases";
 export { buildHostingMenu } from "./hosting";
+export { buildDomainsMenu } from "./domains";
 

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

@@ -16,8 +16,10 @@ type Deps = {
   scanCommonPorts: () => Promise<number[]>;
   findTunnelClients: () => Array<{ pid: number; port: number; token: string }>;
   createAndStartTunnel: (port: number) => Promise<string>;
-  killTunnelClient: (pid: number) => boolean;
-  killAllTunnelClients: (clients: Array<{ pid: number; port: number; token: string }>) => number;
+  stopTunnelClients: (
+    clients: Array<{ pid: number; port: number; token: string }>,
+    opts?: { connectedGhosts?: boolean }
+  ) => Promise<{ killed: number; deleted: number }>;
   colorDim: (text: string) => string;
   colorRed: (text: string) => string;
 };
@@ -33,8 +35,7 @@ export function buildManageTunnelsMenu(deps: Deps): MenuChoice {
     scanCommonPorts,
     findTunnelClients,
     createAndStartTunnel,
-    killTunnelClient,
-    killAllTunnelClients,
+    stopTunnelClients,
     colorDim,
     colorRed,
   } = deps;
@@ -43,7 +44,7 @@ export function buildManageTunnelsMenu(deps: Deps): MenuChoice {
     label: "Share",
     subMenu: [
       {
-        label: "Start (Auto)",
+        label: "Start tunnel",
         action: async () => {
           try {
             // Scan for active ports
@@ -142,65 +143,25 @@ export function buildManageTunnelsMenu(deps: Deps): MenuChoice {
         },
       },
       {
-        label: "Start (Manual)",
+        label: "Stop tunnel",
         action: async () => {
-          const answer = await promptLine('Local port to expose (default 3000, or "back"): ');
-          if (isBackInput(answer)) {
-            restoreRawMode();
-            return "";
-          }
-          const port = Number(answer) || 3000;
           try {
-            const result = await apiRequest("POST", "/v1/tunnels", { port });
-            try {
-              process.stdin.setRawMode(true);
-              process.stdin.resume();
-            } catch {
-              /* ignore */
-            }
-            const url = result.url || "(no url)";
-            const token = result.token || "(no token)";
-            const httpFallback = typeof url === "string" && url.startsWith("https://") ? url.replace(/^https:\/\//, "http://") : "";
-            return [
-              `Created tunnel: ${url}`,
-              httpFallback && url !== httpFallback ? `HTTP fallback: ${httpFallback}` : "",
-              `Token: ${token}`,
-              "",
-              "To start the tunnel client, run:",
-              `  node scripts/tunnel/client-improved.js --token ${token} --port ${port} --ctrl ${process.env.TUNNEL_CTRL || "tunnel.uplink.spot:7071"}`,
-            ]
-              .filter(Boolean)
-              .join("\n");
-          } catch (err: any) {
-            try {
-              process.stdin.setRawMode(true);
-              process.stdin.resume();
-            } catch {
-              /* ignore */
-            }
-            throw err;
-          }
-        },
-      },
-      {
-        label: "Stop Tunnel",
-        action: async () => {
-          try {
-            // Find running tunnel client processes
             const processes = findTunnelClients();
 
             if (processes.length === 0) {
+              const ghost = await stopTunnelClients([], { connectedGhosts: true });
               restoreRawMode();
+              if (ghost.deleted > 0) {
+                return `✓ Removed ${ghost.deleted} relay-connected tunnel${ghost.deleted !== 1 ? "s" : ""} with no local client`;
+              }
               return "No running tunnel clients found.";
             }
 
-            // Build options from running tunnels
             const options: SelectOption[] = processes.map((p) => ({
               label: `Port ${p.port} ${colorDim(`(${truncate(p.token, 8)})`)}`,
               value: p.pid,
             }));
 
-            // Add "Stop all" option if more than one tunnel
             if (processes.length > 1) {
               options.push({ label: colorRed("Stop all tunnels"), value: "all" });
             }
@@ -208,28 +169,25 @@ export function buildManageTunnelsMenu(deps: Deps): MenuChoice {
             const result = await inlineSelect("Select tunnel to stop", options, true);
 
             if (result === null) {
-              // User selected Back
               restoreRawMode();
-              return ""; // Return empty to go back without message
+              return "";
             }
 
-            let killed = 0;
-            if (result.value === "all") {
-              // Kill all
-              killed = killAllTunnelClients(processes);
-            } else {
-              // Kill specific client
-              const pid = result.value as number;
-              const ok = killTunnelClient(pid);
-              if (!ok) {
-                restoreRawMode();
-                throw new Error(`Failed to kill process ${pid}`);
-              }
-              killed = 1;
-            }
+            const selected =
+              result.value === "all"
+                ? processes
+                : processes.filter((p) => {
+                    const pid = result.value as number;
+                    const chosen = processes.find((c) => c.pid === pid);
+                    return p.pid === pid || (chosen && p.token === chosen.token);
+                  });
 
+            const { killed, deleted } = await stopTunnelClients(selected);
             restoreRawMode();
-            return `✓ Stopped ${killed} tunnel client${killed !== 1 ? "s" : ""}`;
+            if (killed === 0 && deleted === 0) {
+              throw new Error("Failed to stop tunnel");
+            }
+            return `✓ Stopped ${killed} local client${killed !== 1 ? "s" : ""}, removed ${deleted} tunnel record${deleted !== 1 ? "s" : ""}`;
           } catch (err: any) {
             restoreRawMode();
             throw err;

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

@@ -1,5 +1,5 @@
 import { clearScreen } from "./io";
-import { colorBold, colorCyan, colorDim, colorGreen, colorRed } from "./colors";
+import { colorBold, colorDim, colorGreen, colorRed } from "./colors";
 import { DEFAULT_MENU_MESSAGE, type MenuChoice } from "./types";
 
 export type RenderArgs = {
@@ -107,7 +107,7 @@ export function renderMenu(args: RenderArgs) {
       const styledLine = line
         .replace(/^✓/, colorGreen("✓"))
         .replace(/^✗/, colorRed("✗"))
-        .replace(/^→/, colorCyan("→"));
+        .replace(/^→/, colorDim("→"));
       console.log(styledLine);
     });
   }

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

@@ -1,12 +1,19 @@
 import fetch from "node-fetch";
-import { getResolvedApiBase } from "../../utils/api-base";
+import { getResolvedApiBase, getResolvedApiToken } from "../../utils/api-base";
 
-export async function unauthenticatedRequest(method: string, path: string, body?: unknown): Promise<any> {
+export async function unauthenticatedRequest(
+  method: string,
+  path: string,
+  body?: unknown,
+  options: { includeCurrentToken?: boolean } = {}
+): Promise<any> {
   const apiBase = getResolvedApiBase();
+  const token = options.includeCurrentToken ? getResolvedApiToken(apiBase) : undefined;
   const response = await fetch(`${apiBase}${path}`, {
     method,
     headers: {
       "Content-Type": "application/json",
+      ...(token ? { Authorization: `Bearer ${token}` } : {}),
     },
     body: body ? JSON.stringify(body) : undefined,
   });

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

@@ -1,6 +1,6 @@
 import fetch from "node-fetch";
 import { spawn } from "child_process";
-import { resolveProjectRoot } from "../../../utils/project-root";
+import { resolveProjectRoot } from "../../utils/project-root";
 import { getResolvedApiBase, getResolvedApiToken } from "../../utils/api-base";
 
 export function runSmoke(script: "smoke:tunnel" | "smoke:db" | "smoke:all" | "test:comprehensive") {