uplink-cli 0.1.38 → 0.1.39

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/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") {

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

@@ -1,99 +1,10 @@
-import { spawn, execSync } from "child_process";
-import { join } from "path";
-import { apiRequest } from "../../http";
-import { resolveProjectRoot } from "../../../utils/project-root";
-
-export async function createAndStartTunnel(port: number): Promise<string> {
-  // Check if tunnel already running on this port
-  const existing = findTunnelClients().filter(c => c.port === port);
-  if (existing.length > 0) {
-    return [
-      `⚠ Tunnel already running on port ${port}`,
-      ``,
-      `→ PID: ${existing[0].pid}`,
-      `→ Token: ${existing[0].token.substring(0, 8)}...`,
-      ``,
-      `Use "Stop Tunnel" first to disconnect the existing tunnel.`,
-    ].join("\n");
-  }
-
-  const result = await apiRequest("POST", "/v1/tunnels", { port });
-  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";
-
-  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();
-
-  await new Promise((resolve) => setTimeout(resolve, 2000));
-
-  try {
-    process.stdin.setRawMode(true);
-    process.stdin.resume();
-  } catch {
-    /* ignore */
-  }
-
-  const lines = [
-    `✓ Tunnel created and client started`,
-    ``,
-    `→ Public URL    ${url}`,
-  ];
-  
-  if (alias) {
-    // Use aliasUrl from backend if available, otherwise construct it
-    const aliasUrl = result.aliasUrl || `https://${alias}.uplink.spot`;
-    lines.push(`→ Alias         ${alias}`);
-    lines.push(`→ Alias URL     ${aliasUrl}`);
-  }
-  
-  lines.push(
-    `→ Token         ${token}`,
-    `→ Local port    ${port}`,
-    ``,
-    `Tunnel client running in background.`,
-    `Use "Stop Tunnel" to disconnect.`,
-  );
-  
-  return lines.join("\n");
-}
-
-export function findTunnelClients(): Array<{ pid: number; port: number; token: string }> {
-  try {
-    const user = process.env.USER || "";
-    const psCmd = user ? `ps -u ${user} -o pid=,command=` : "ps -eo pid=,command=";
-    const output = execSync(psCmd, { encoding: "utf-8" });
-    const lines = output
-      .trim()
-      .split("\n")
-      .filter((line) => line.includes("scripts/tunnel/client-improved.js"));
-
-    const clients: Array<{ pid: number; port: number; token: string }> = [];
-
-    for (const line of lines) {
-      const pidMatch = line.match(/^\s*(\d+)/);
-      const tokenMatch = line.match(/--token\s+(\S+)/);
-      const portMatch = line.match(/--port\s+(\d+)/);
-
-      if (pidMatch && tokenMatch && portMatch) {
-        clients.push({
-          pid: parseInt(pidMatch[1], 10),
-          port: parseInt(portMatch[1], 10),
-          token: tokenMatch[1],
-        });
-      }
-    }
-
-    return clients;
-  } catch {
-    return [];
-  }
-}
+/** @deprecated Prefer `./effects/tunnel-clients` — kept as a thin re-export. */
+export {
+  createAndStartTunnel,
+  findTunnelClients,
+  killAllTunnelClients,
+  killTunnelClient,
+  startTunnelClient,
+  stopTunnelClients,
+  resolveTunnelClientPath,
+} from "./effects/tunnel-clients";

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

@@ -1,7 +1,15 @@
+export type MenuInspect = {
+  kind: "app";
+  id: string;
+  url?: string;
+  createdAt?: string;
+};
+
 export type MenuChoice = {
   label: string;
   action?: () => Promise<string>;
   subMenu?: MenuChoice[];
+  inspect?: MenuInspect;
 };
 
 export const DEFAULT_MENU_MESSAGE = "Use ↑/↓ and Enter. ← to go back. Ctrl+C to quit.";