uplink-cli 0.1.26 → 0.1.28

package/cli/src/index.ts

@@ -7,11 +7,9 @@ import { menuCommand } from "./subcommands/menu";
 import { tunnelCommand } from "./subcommands/tunnel";
 import { signupCommand } from "./subcommands/signup";
 import { readFileSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
+import { join } from "path";
 
-// Get version from package.json
-const __dirname = dirname(fileURLToPath(import.meta.url));
+// Get version from package.json (CommonJS build: __dirname available)
 const pkgPath = join(__dirname, "../../package.json");
 const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
 

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

@@ -19,6 +19,7 @@ export async function createAndStartTunnel(port: number): Promise<string> {
   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");
@@ -40,16 +41,28 @@ export async function createAndStartTunnel(port: number): Promise<string> {
     /* ignore */
   }
 
-  return [
+  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.`,
-  ].join("\n");
+  );
+  
+  return lines.join("\n");
 }
 
 export function findTunnelClients(): Array<{ pid: number; port: number; token: string }> {

package/cli/src/subcommands/menu.ts

@@ -785,19 +785,31 @@ export const menuCommand = new Command("menu")
             label: "View Tunnel Stats",
             action: async () => {
               try {
-                const result = await apiRequest("GET", "/v1/tunnels");
-                const tunnels = result.tunnels || result?.items || [];
-                if (!tunnels || tunnels.length === 0) {
+                // Show stats for running tunnels only
+                const runningClients = findTunnelClients();
+                if (runningClients.length === 0) {
                   restoreRawMode();
-                  return "No tunnels found.";
+                  return "No active tunnels. Start a tunnel first.";
+                }
+
+                // Get alias info
+                let aliasMap: Record<number, string> = {};
+                try {
+                  const aliasResult = await apiRequest("GET", "/v1/tunnels/aliases");
+                  const aliases = aliasResult.aliases || [];
+                  for (const a of aliases) {
+                    aliasMap[a.targetPort || a.target_port] = a.alias;
+                  }
+                } catch {
+                  // Continue without alias info
                 }
 
-                const options: SelectOption[] = tunnels.map((t: any) => {
-                  const token = truncate(t.token || t.id, 12);
-                  const alias = t.alias ? `${t.alias}.x.uplink.spot` : "(no permanent URL)";
+                const options: SelectOption[] = runningClients.map((c) => {
+                  const token = truncate(c.token, 12);
+                  const alias = aliasMap[c.port] ? `${aliasMap[c.port]}.uplink.spot` : `port ${c.port}`;
                   return {
                     label: `${token}    ${alias}`,
-                    value: t.id,
+                    value: c.token,
                   };
                 });
 
@@ -807,7 +819,16 @@ export const menuCommand = new Command("menu")
                   return "";
                 }
 
-                const stats = await apiRequest("GET", `/v1/tunnels/${choice.value}/stats`) as any;
+                // Find the tunnel by token to get its ID
+                const result = await apiRequest("GET", "/v1/tunnels");
+                const tunnels = result.tunnels || [];
+                const tunnel = tunnels.find((t: any) => t.token === choice.value);
+                
+                if (!tunnel) {
+                  return "Tunnel not found in backend. It may have been cleaned up.";
+                }
+
+                const stats = await apiRequest("GET", `/v1/tunnels/${tunnel.id}/stats`) as any;
                 const connected = stats.connected ? "yes" : "no";
                 const alias = stats.alias || null;
 
@@ -823,7 +844,7 @@ export const menuCommand = new Command("menu")
 
                 const totals = stats.totals || {};
                 const current = stats.currentRun || {};
-                const permanentUrl = `https://${alias}.x.uplink.spot`;
+                const permanentUrl = `https://${alias}.uplink.spot`;
                 return [
                   `Permanent URL: ${permanentUrl}`,
                   `Connected:     ${connected}`,
@@ -845,96 +866,50 @@ export const menuCommand = new Command("menu")
             },
           },
           {
-            label: "Create Permanent URL",
+            label: "Active Tunnels",
             action: async () => {
+              // Get tunnels from API with connection status
+              let connectedTunnels: Array<{ token: string; targetPort: number; url: string; alias?: string; aliasUrl?: string }> = [];
               try {
-                const result = await apiRequest("GET", "/v1/tunnels");
-                const tunnels = result.tunnels || result?.items || [];
-                if (!tunnels || tunnels.length === 0) {
-                  restoreRawMode();
-                  return "No tunnels found. Create a tunnel first.";
+                const tunnelsResult = await apiRequest("GET", "/v1/tunnels");
+                const tunnels = tunnelsResult.tunnels || [];
+                // Only show tunnels that are actually connected to the relay
+                connectedTunnels = tunnels.filter((t: any) => t.connected === true);
+              } catch (err: any) {
+                // If API fails, fall back to local process check
+                const runningClients = findTunnelClients();
+                if (runningClients.length === 0) {
+                  return "No active tunnels. Use 'Start' to create one.";
                 }
-
-                const options: SelectOption[] = tunnels.map((t: any) => {
-                  const token = truncate(t.token || t.id, 12);
-                  const alias = t.alias ? `${t.alias}.x.uplink.spot` : "(no permanent URL)";
-                  return {
-                    label: `${token}    ${alias}`,
-                    value: t.id,
-                  };
+                // Show warning that we can't verify connection status
+                const lines = runningClients.map((c) => {
+                  const token = truncate(c.token, 12);
+                  const port = String(c.port).padEnd(5);
+                  return `${token.padEnd(14)}  ${port}  (status unknown)`;
                 });
-
-                const choice = await inlineSelect("Select tunnel to set permanent URL", options, true);
-                if (choice === null) {
-                  restoreRawMode();
-                  return "";
-                }
-
-                try { process.stdin.setRawMode(false); } catch { /* ignore */ }
-                const aliasName = await promptLine("Enter alias name (e.g. my-app): ");
-                restoreRawMode();
-
-                if (!aliasName.trim()) {
-                  return "No alias provided.";
-                }
-
-                try {
-                  const aliasResult = await apiRequest("POST", `/v1/tunnels/${choice.value}/alias`, {
-                    alias: aliasName.trim(),
-                  });
-                  const permanentUrl = `https://${aliasResult.alias}.x.uplink.spot`;
-                  return [
-                    "✓ Permanent URL created",
-                    "",
-                    `→ Alias     ${aliasResult.alias}`,
-                    `→ URL       ${permanentUrl}`,
-                    "",
-                    "Your tunnel will now be accessible at this permanent URL.",
-                  ].join("\n");
-                } catch (err: any) {
-                  const msg = err?.message || String(err);
-                  if (msg.includes("ALIAS_NOT_ENABLED")) {
-                    return [
-                      "❌ Permanent URLs are a premium feature",
-                      "",
-                      "Contact us on Discord at uplink.spot to upgrade your account.",
-                    ].join("\n");
-                  }
-                  if (msg.includes("ALIAS_LIMIT_REACHED")) {
-                    return [
-                      "❌ URL limit reached",
-                      "",
-                      "You've reached your URL limit. Contact us to increase it.",
-                    ].join("\n");
-                  }
-                  if (msg.includes("ALIAS_TAKEN") || msg.includes("already in use")) {
-                    return `❌ Alias "${aliasName.trim()}" is already in use. Try a different name.`;
-                  }
-                  throw err;
-                }
-              } catch (err: any) {
-                restoreRawMode();
-                throw err;
+                return [
+                  "⚠ Could not verify connection status from relay",
+                  "",
+                  "Token          Port   Status",
+                  "-".repeat(40),
+                  ...lines,
+                ].join("\n");
               }
-            },
-          },
-          {
-            label: "My Tunnels",
-            action: async () => {
-              const runningClients = findTunnelClients();
-              const result = await apiRequest("GET", "/v1/tunnels");
-              const tunnels = result.tunnels || result?.items || [];
-              if (!tunnels || tunnels.length === 0) {
-                return "No tunnels found.";
+              
+              if (connectedTunnels.length === 0) {
+                return "No active tunnels connected to relay. Use 'Start' to create one.";
               }
               
-              const lines = tunnels.map((t: any) => {
-                const token = truncate(t.token || "", 12);
-                const port = String(t.target_port ?? t.targetPort ?? "-").padEnd(5);
-                const connectedLocal = runningClients.some((c) => c.token === (t.token || ""));
-                const status = connectedLocal ? "connected" : "unknown";
-                const alias = t.alias ? `${t.alias}.x.uplink.spot` : "-";
-                return `${token.padEnd(14)}  ${port}  ${status.padEnd(11)}  ${alias}`;
+              // Match with local processes to get port info
+              const runningClients = findTunnelClients();
+              const tokenToClient = new Map(runningClients.map(c => [c.token, c]));
+              
+              const lines = connectedTunnels.map((tunnel) => {
+                const token = truncate(tunnel.token, 12);
+                const client = tokenToClient.get(tunnel.token);
+                const port = client ? String(client.port).padEnd(5) : String(tunnel.targetPort).padEnd(5);
+                const alias = tunnel.aliasUrl || (tunnel.alias ? `https://${tunnel.alias}.uplink.spot` : "-");
+                return `${token.padEnd(14)}  ${port}  connected    ${alias}`;
               });
               
               return [
@@ -947,6 +922,280 @@ export const menuCommand = new Command("menu")
         ],
       });
 
+    // Manage Aliases (Premium feature)
+    mainMenu.push({
+      label: "Manage Aliases",
+      subMenu: [
+        {
+          label: "My Aliases",
+          action: async () => {
+            try {
+              const result = await apiRequest("GET", "/v1/tunnels/aliases");
+              const aliases = result.aliases || [];
+              
+              if (aliases.length === 0) {
+                return [
+                  "No aliases configured.",
+                  "",
+                  "Use 'Create Alias' to set up a permanent URL for a port.",
+                ].join("\n");
+              }
+              
+              const runningClients = findTunnelClients();
+              const runningPorts = new Set(runningClients.map(c => c.port));
+              
+              const lines = aliases.map((a: any) => {
+                const alias = a.alias.padEnd(15);
+                const port = String(a.targetPort || a.target_port).padEnd(6);
+                const status = runningPorts.has(a.targetPort || a.target_port) ? "active" : "inactive";
+                return `${alias}  ${port}  ${status}`;
+              });
+              
+              return [
+                "Alias            Port    Status",
+                "-".repeat(40),
+                ...lines,
+                "",
+                "Active = tunnel running on that port",
+              ].join("\n");
+            } catch (err: any) {
+              const msg = err?.message || String(err);
+              if (msg.includes("ALIAS_NOT_ENABLED") || msg.includes("403")) {
+                return [
+                  "❌ Aliases are a premium feature",
+                  "",
+                  "Contact us on Discord at uplink.spot to upgrade.",
+                ].join("\n");
+              }
+              throw err;
+            }
+          },
+        },
+        {
+          label: "Create Alias",
+          action: async () => {
+            let aliasName = "";
+            let port = 0;
+            try {
+              // Step 1: Select port - show running tunnels + custom option
+              const runningClients = findTunnelClients();
+              const portOptions: SelectOption[] = [];
+              
+              // Add running tunnel ports
+              for (const client of runningClients) {
+                portOptions.push({
+                  label: `Port ${client.port} (tunnel running)`,
+                  value: client.port,
+                });
+              }
+              
+              // Add custom option
+              portOptions.push({ label: "Enter custom port", value: "custom" });
+              
+              const portChoice = await inlineSelect("Select port to create alias for", portOptions, true);
+              if (portChoice === null) {
+                restoreRawMode();
+                return "";
+              }
+              
+              if (portChoice.value === "custom") {
+                try { process.stdin.setRawMode(false); } catch { /* ignore */ }
+                const portStr = await promptLine("Enter port number (e.g. 3000): ");
+                port = Number(portStr);
+                if (!port || port < 1 || port > 65535) {
+                  restoreRawMode();
+                  return "Invalid port number.";
+                }
+              } else {
+                port = portChoice.value as number;
+              }
+              
+              // Step 2: Enter alias name
+              try { process.stdin.setRawMode(false); } catch { /* ignore */ }
+              aliasName = await promptLine("Enter alias name (e.g. my-app): ");
+              restoreRawMode();
+              
+              if (!aliasName.trim()) {
+                return "No alias provided.";
+              }
+              
+              const result = await apiRequest("POST", "/v1/tunnels/aliases", {
+                alias: aliasName.trim(),
+                port,
+              });
+              
+              const tunnelRunning = runningClients.some(c => c.port === port);
+              const statusMsg = tunnelRunning 
+                ? "Alias is now active!"
+                : "Start a tunnel on this port to make it accessible.";
+              
+              return [
+                "✓ Alias created",
+                "",
+                `→ Alias     ${result.alias}`,
+                `→ Port      ${result.targetPort}`,
+                `→ URL       ${result.url}`,
+                "",
+                statusMsg,
+              ].join("\n");
+            } catch (err: any) {
+              restoreRawMode();
+              const msg = err?.message || String(err);
+              if (msg.includes("ALIAS_NOT_ENABLED")) {
+                return [
+                  "❌ Aliases are a premium feature",
+                  "",
+                  "Contact us on Discord at uplink.spot to upgrade.",
+                ].join("\n");
+              }
+              if (msg.includes("ALIAS_LIMIT_REACHED")) {
+                return [
+                  "❌ Alias limit reached",
+                  "",
+                  "You've reached your alias limit. Contact us to increase it.",
+                ].join("\n");
+              }
+              if (msg.includes("ALIAS_TAKEN")) {
+                return `❌ Alias "${aliasName.trim()}" is already taken. Try a different name.`;
+              }
+              if (msg.includes("PORT_HAS_ALIAS")) {
+                return `❌ Port ${port} already has an alias. Use 'Reassign Alias' to change it.`;
+              }
+              throw err;
+            }
+          },
+        },
+        {
+          label: "Reassign Alias",
+          action: async () => {
+            try {
+              const result = await apiRequest("GET", "/v1/tunnels/aliases");
+              const aliases = result.aliases || [];
+              
+              if (aliases.length === 0) {
+                restoreRawMode();
+                return "No aliases to reassign. Create one first.";
+              }
+              
+              // Step 1: Select which alias to reassign
+              const aliasOptions: SelectOption[] = aliases.map((a: any) => ({
+                label: `${a.alias} → port ${a.targetPort || a.target_port}`,
+                value: a.alias,
+              }));
+              
+              const aliasChoice = await inlineSelect("Select alias to reassign", aliasOptions, true);
+              if (aliasChoice === null) {
+                restoreRawMode();
+                return "";
+              }
+              
+              const selectedAlias = aliases.find((a: any) => a.alias === aliasChoice.value);
+              const currentPort = selectedAlias?.targetPort || selectedAlias?.target_port;
+              
+              // Step 2: Show available ports (running tunnels + custom option)
+              const runningClients = findTunnelClients();
+              const portOptions: SelectOption[] = [];
+              
+              // Add running tunnel ports (excluding current port)
+              for (const client of runningClients) {
+                if (client.port !== currentPort) {
+                  portOptions.push({
+                    label: `Port ${client.port} (tunnel running)`,
+                    value: client.port,
+                  });
+                }
+              }
+              
+              // Add current port indicator if tunnel is running
+              const currentRunning = runningClients.find(c => c.port === currentPort);
+              if (currentRunning) {
+                portOptions.unshift({
+                  label: `Port ${currentPort} (current, tunnel running)`,
+                  value: `current-${currentPort}`,
+                });
+              }
+              
+              // Add custom option
+              portOptions.push({ label: "Enter custom port", value: "custom" });
+              
+              const portChoice = await inlineSelect("Select new port for alias", portOptions, true);
+              if (portChoice === null) {
+                restoreRawMode();
+                return "";
+              }
+              
+              let port: number;
+              if (portChoice.value === "custom") {
+                try { process.stdin.setRawMode(false); } catch { /* ignore */ }
+                const portStr = await promptLine("Enter new port number: ");
+                restoreRawMode();
+                port = Number(portStr);
+                if (!port || port < 1 || port > 65535) {
+                  return "Invalid port number.";
+                }
+              } else if (typeof portChoice.value === "string" && portChoice.value.startsWith("current-")) {
+                restoreRawMode();
+                return "Alias is already assigned to this port.";
+              } else {
+                port = portChoice.value as number;
+              }
+              
+              restoreRawMode();
+              
+              const updateResult = await apiRequest("PUT", `/v1/tunnels/aliases/${aliasChoice.value}`, { port });
+              
+              return [
+                "✓ Alias reassigned",
+                "",
+                `→ Alias     ${updateResult.alias}`,
+                `→ Port      ${updateResult.targetPort}`,
+                `→ URL       ${updateResult.url}`,
+              ].join("\n");
+            } catch (err: any) {
+              restoreRawMode();
+              const msg = err?.message || String(err);
+              if (msg.includes("PORT_HAS_ALIAS")) {
+                return "❌ That port already has an alias assigned.";
+              }
+              throw err;
+            }
+          },
+        },
+        {
+          label: "Delete Alias",
+          action: async () => {
+            try {
+              const result = await apiRequest("GET", "/v1/tunnels/aliases");
+              const aliases = result.aliases || [];
+              
+              if (aliases.length === 0) {
+                restoreRawMode();
+                return "No aliases to delete.";
+              }
+              
+              const options: SelectOption[] = aliases.map((a: any) => ({
+                label: `${a.alias} → port ${a.targetPort || a.target_port}`,
+                value: a.alias,
+              }));
+              
+              const choice = await inlineSelect("Select alias to delete", options, true);
+              if (choice === null) {
+                restoreRawMode();
+                return "";
+              }
+              
+              await apiRequest("DELETE", `/v1/tunnels/aliases/${choice.value}`);
+              
+              return `✓ Alias "${choice.value}" deleted.`;
+            } catch (err: any) {
+              restoreRawMode();
+              throw err;
+            }
+          },
+        },
+      ],
+    });
+
     // Admin-only: Usage section
     if (isAdmin) {
       mainMenu.push({
@@ -1128,7 +1377,8 @@ export const menuCommand = new Command("menu")
       if (clients.length === 0) {
         cachedActiveTunnels = "";
       } else {
-        const domain = process.env.TUNNEL_DOMAIN || "t.uplink.spot";
+        // Default domain should be the current production domain; allow override via env.
+        const domain = process.env.TUNNEL_DOMAIN || "x.uplink.spot";
         const scheme = (process.env.TUNNEL_URL_SCHEME || "https").toLowerCase();
         
         const tunnelLines = clients.map((client, idx) => {
@@ -1374,6 +1624,7 @@ async function createAndStartTunnel(port: number): Promise<string> {
   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";
   
   // Start tunnel client in background
@@ -1397,16 +1648,28 @@ async function createAndStartTunnel(port: number): Promise<string> {
     /* ignore */
   }
   
-  return [
+  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.`,
-  ].join("\n");
+  );
+  
+  return lines.join("\n");
 }
 
 function findTunnelClients(): Array<{ pid: number; port: number; token: string }> {