uplink-cli 0.1.38 → 0.1.39

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");
+        },
+      },
+    ],
+  };
+}

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";