uplink-cli 0.1.38 → 0.1.39

package/cli/src/tui/format.ts

@@ -0,0 +1,22 @@
+export function formatBytes(bytes: number): string {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.min(sizes.length - 1, Math.floor(Math.log(bytes) / Math.log(k)));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
+}
+
+export function formatDate(iso?: string): string {
+  if (!iso) return "—";
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) return "—";
+  return date.toISOString().slice(0, 10);
+}
+
+export function cleanLabel(label: string): string {
+  return label
+    .replace(/^🚀\s*/, "")
+    .replace(/^⚠️\s*/, "⚠ ")
+    .replace(/^✅\s*/, "")
+    .replace(/^❌\s*/, "");
+}

package/cli/src/tui/index.mts

@@ -0,0 +1,6 @@
+import { startMenuSession } from "./session.mts";
+
+startMenuSession().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});

package/cli/src/tui/liveTree.ts

@@ -0,0 +1,40 @@
+import type { MenuChoice } from "../subcommands/menu/types";
+import type { MenuStatus } from "./App";
+import { cleanLabel } from "./format";
+import { fetchAppLogs } from "./snapshot";
+
+export function withLiveApps(tree: MenuChoice[], status: MenuStatus): MenuChoice[] {
+  return tree.map((item) => {
+    if (!item.subMenu || cleanLabel(item.label) !== "Hosting") return item;
+    const rest = item.subMenu.filter((choice) => cleanLabel(choice.label) !== "Apps");
+    const appsMenu: MenuChoice = {
+      label: "Apps",
+      subMenu:
+        status.apps.length > 0
+          ? status.apps.map((app) => ({
+              label: app.name,
+              inspect: { kind: "app", id: app.id, url: app.url, createdAt: app.createdAt },
+              subMenu: [
+                {
+                  label: "Logs",
+                  action: () => fetchAppLogs(app.id),
+                },
+              ],
+            }))
+          : [{ label: "No apps yet", action: async () => "No hosted apps." }],
+    };
+    return { ...item, subMenu: [appsMenu, ...rest] };
+  });
+}
+
+export function resolveStack(tree: MenuChoice[], titles: string[]): MenuChoice[][] {
+  const stack: MenuChoice[][] = [tree];
+  let current = tree;
+  for (let i = 1; i < titles.length; i += 1) {
+    const found = current.find((choice) => cleanLabel(choice.label) === titles[i]);
+    if (!found?.subMenu) break;
+    stack.push(found.subMenu);
+    current = found.subMenu;
+  }
+  return stack;
+}

package/cli/src/tui/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/cli/src/tui/runMenu.tsx

@@ -0,0 +1,57 @@
+import { render } from "ink";
+import { MenuApp, type MenuOutcome, type MenuStatus } from "./App";
+import type { MenuChoice } from "../subcommands/menu/types";
+import { prepareStdinForPrompt } from "../subcommands/menu/io";
+import { resolveStack, withLiveApps } from "./liveTree";
+
+export async function runInkMenu(opts: {
+  tree: MenuChoice[];
+  getStatus: () => Promise<MenuStatus>;
+}): Promise<void> {
+  let message = "";
+  let titles = ["UPLINK"];
+  let selected = 0;
+
+  while (true) {
+    const status = await opts.getStatus();
+    const tree = withLiveApps(opts.tree, status);
+    const stack = resolveStack(tree, titles);
+    let outcome: MenuOutcome = { kind: "quit" };
+    const instance = render(
+      <MenuApp
+        tree={tree}
+        status={status}
+        message={message}
+        initialStack={stack}
+        initialTitles={titles}
+        initialSelected={Math.min(selected, (stack[stack.length - 1]?.length || 1) - 1)}
+        onOutcome={(next) => {
+          outcome = next;
+        }}
+      />
+    );
+    await instance.waitUntilExit();
+    instance.unmount();
+    prepareStdinForPrompt();
+
+    if (outcome.kind !== "action") return;
+
+    titles = outcome.titles;
+    selected = outcome.selected;
+
+    if (outcome.isExit) {
+      try {
+        await outcome.action();
+      } catch {
+        /* ignore */
+      }
+      return;
+    }
+
+    try {
+      message = (await outcome.action()) || "";
+    } catch (error) {
+      message = `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+}

package/cli/src/tui/session.mts

@@ -0,0 +1,382 @@
+import fetch from "node-fetch";
+import { apiRequest } from "../http";
+import { clearScreen, promptLine, restoreRawMode, truncate } from "../subcommands/menu/io";
+import { unauthenticatedRequest } from "../subcommands/menu/requests";
+import { inlineSelect } from "../subcommands/menu/inline-tree-select";
+import {
+  colorDim,
+  colorGreen,
+  colorRed,
+  colorWhite,
+} from "../subcommands/menu/colors";
+import { type MenuChoice } from "../subcommands/menu/types";
+import {
+  buildManageAliasesMenu,
+  buildManageTokensMenu,
+  buildManageTunnelsMenu,
+  buildHostingMenu,
+  buildDomainsMenu,
+  buildSystemStatusMenu,
+  buildUsageMenu,
+} from "../subcommands/menu/menus";
+import { ports, smoke, tokenConfig, tunnelClients } from "../subcommands/menu/effects";
+import { runInkMenu } from "./runMenu";
+import { launchDomainking } from "../utils/launchDomainking";
+import { fetchMenuSnapshot } from "./snapshot";
+
+function formatBytes(bytes: number): string {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
+}
+
+export async function startMenuSession(): Promise<void> {
+    const apiBase = process.env.AGENTCLOUD_API_BASE || "https://api.uplink.spot";
+    
+    // Determine role (admin or user) via /v1/me; check if auth failed
+    let isAdmin = false;
+    let authFailed = false;
+    const meStart = Date.now();
+    try {
+      const me = await apiRequest("GET", "/v1/me");
+      isAdmin = me?.role === "admin";
+    } catch (err: any) {
+      // Check if it's an authentication error
+      const errorMsg = err?.message || String(err);
+      authFailed =
+        errorMsg.includes("UNAUTHORIZED") ||
+        errorMsg.includes("401") ||
+        errorMsg.includes("Missing or invalid token") ||
+        errorMsg.includes("Missing AGENTCLOUD_TOKEN");
+      isAdmin = false;
+    }
+    const meDurationMs = Date.now() - meStart;
+
+    // Build menu structure dynamically by role and auth status
+    const mainMenu: MenuChoice[] = [];
+    
+    // If authentication failed, show ONLY "Get Started", "About", and "Exit"
+    if (authFailed) {
+      mainMenu.push({
+        label: "🚀 Get Started (Create Account)",
+        action: async () => {
+          restoreRawMode();
+          clearScreen();
+          try {
+            process.stdout.write("\n");
+            process.stdout.write(colorWhite("UPLINK") + colorDim("  Create Account\n"));
+            process.stdout.write("\n");
+
+            const label = (await promptLine("Label (optional): ")).trim();
+            const expiresInput = (await promptLine("Expires in days (optional): ")).trim();
+            const expiresDays = expiresInput ? Number(expiresInput) : undefined;
+
+            if (expiresDays && (isNaN(expiresDays) || expiresDays <= 0)) {
+              restoreRawMode();
+              return "Invalid expiration days. Please enter a positive number or leave empty.";
+            }
+
+            process.stdout.write("\nCreating your token...\n");
+            process.stdout.write("");
+            let result;
+            try {
+              result = await unauthenticatedRequest("POST", "/v1/signup", {
+                label: label || undefined,
+                expiresInDays: expiresDays || undefined,
+              });
+              if (!result) {
+                restoreRawMode();
+                return "❌ Error: No response from server.";
+              }
+            } catch (err: any) {
+              restoreRawMode();
+              const errorMsg = err?.message || String(err);
+              console.error("\n❌ Signup error:", errorMsg);
+              if (errorMsg.includes("429") || errorMsg.includes("RATE_LIMIT")) {
+                return "⚠️  Too many signup attempts. Please try again later.";
+              }
+              return `❌ Error creating account: ${errorMsg}`;
+            }
+
+            if (!result || !result.token) {
+              restoreRawMode();
+              return "❌ Error: Invalid response from server. Token not received.";
+            }
+
+            const token = result.token;
+            const tokenId = result.id;
+            const userId = result.userId;
+
+            process.stdout.write("\n");
+            process.stdout.write(colorGreen("✓") + " Account created\n");
+            process.stdout.write("\n");
+            process.stdout.write(colorDim("├─") + " Token     " + token + "\n");
+            process.stdout.write(colorDim("├─") + " ID        " + tokenId + "\n");
+            process.stdout.write(colorDim("├─") + " User      " + userId + "\n");
+            process.stdout.write(colorDim("├─") + " Role      " + result.role + "\n");
+            if (result.expiresAt) {
+              process.stdout.write(colorDim("└─") + " Expires   " + result.expiresAt + "\n");
+            } else {
+              process.stdout.write(colorDim("└─") + " Expires   " + colorDim("never") + "\n");
+            }
+            process.stdout.write("\n");
+            process.stdout.write(colorDim("!") + " Save this token securely — shown only once\n");
+
+            // Try to automatically add token to shell config
+            const detected = tokenConfig.detectShellConfigFile();
+            let configFile: string | null = detected.configFile;
+            let shellName = detected.shellName;
+
+            let tokenAdded = false;
+            const tokenExists = configFile ? tokenConfig.shellConfigHasToken(configFile) : false;
+
+            if (configFile) {
+              const promptText = tokenExists
+                ? `\n→ Update existing token in ~/.${shellName}rc? (Y/n): `
+                : `\n→ Add token to ~/.${shellName}rc? (Y/n): `;
+              
+              const addToken = (await promptLine(promptText)).trim().toLowerCase();
+              if (addToken !== "n" && addToken !== "no") {
+                try {
+                  const res = tokenConfig.upsertShellToken(configFile, token);
+                  tokenAdded = res.wrote;
+                  if (tokenExists) {
+                    console.log(colorGreen(`\n✓ Token updated in ~/.${shellName}rc`));
+                  } else {
+                    console.log(colorGreen(`\n✓ Token added to ~/.${shellName}rc`));
+                  }
+                  if (!res.verifyOk) {
+                    console.log(
+                      colorRed(`\n! Token may not have been written correctly. Check ~/.${shellName}rc`)
+                    );
+                  }
+                } catch (err: any) {
+                  if (err?.message?.includes("UNSAFE_SHELL_CONFIG_PERMISSIONS")) {
+                    console.log(
+                      colorRed(
+                        `\n! Could not write to ~/.${shellName}rc: file is group/world writable. Fix permissions first.`
+                      )
+                    );
+                    console.log(colorDim(`  chmod 600 ~/.${shellName}rc`));
+                  } else {
+                    console.log(colorRed(`\n! Could not write to ~/.${shellName}rc: ${err.message}`));
+                  }
+                  console.log(`\n  Please add manually:`);
+                  console.log(colorDim(`  echo 'export AGENTCLOUD_TOKEN=${token}' >> ~/.${shellName}rc`));
+                }
+              }
+            } else {
+              console.log(colorDim(`\n→ Could not detect your shell. Add the token manually:`));
+              console.log(colorDim(`  echo 'export AGENTCLOUD_TOKEN=${token}' >> ~/.zshrc  # for zsh`));
+              console.log(colorDim(`  echo 'export AGENTCLOUD_TOKEN=${token}' >> ~/.bashrc  # for bash`));
+            }
+
+            if (!tokenAdded) {
+            process.stdout.write("\n");
+            process.stdout.write(colorDim("!") + " Set this token as an environment variable:\n\n");
+            process.stdout.write(colorDim("  ") + "export AGENTCLOUD_TOKEN=" + token + "\n");
+            if (configFile) {
+              process.stdout.write(colorDim(`\n  Or add to ~/.${shellName}rc:\n`));
+              process.stdout.write(colorDim("  ") + `echo 'export AGENTCLOUD_TOKEN=${token}' >> ~/.${shellName}rc\n`);
+              process.stdout.write(colorDim("  ") + `source ~/.${shellName}rc\n`);
+            }
+            process.stdout.write(colorDim("\n  Then restart this menu.\n\n"));
+            }
+
+            restoreRawMode();
+
+            if (tokenAdded) {
+              process.env.AGENTCLOUD_TOKEN = token;
+              // Use stdout writes to avoid buffering/race with process.exit()
+              process.stdout.write(`\n${colorGreen("✓")} Token saved to ~/.${shellName}rc\n`);
+              process.stdout.write(`\n${colorDim("→")} Next: run in your terminal:\n`);
+              process.stdout.write(colorDim(`   source ~/.${shellName}rc && uplink\n\n`));
+              
+              setTimeout(() => {
+                process.exit(0);
+              }, 3000);
+              
+              return undefined as any;
+            }
+
+            console.log("\nPress Enter to continue...");
+            await promptLine("");
+            restoreRawMode();
+            return "Token created! Please set AGENTCLOUD_TOKEN environment variable and restart the menu.";
+          } catch (err: any) {
+            restoreRawMode();
+            const errorMsg = err?.message || String(err);
+            if (errorMsg.includes("429") || errorMsg.includes("RATE_LIMIT")) {
+              return "⚠️  Too many signup attempts. Please try again later.";
+            }
+            return `❌ Error creating account: ${errorMsg}`;
+          }
+        },
+      });
+      
+      mainMenu.push({
+        label: "Find a domain",
+        action: async () => {
+          restoreRawMode();
+          return launchDomainking();
+        },
+      });
+
+      mainMenu.push({
+        label: "About",
+        action: async () => {
+          return [
+            "Uplink CLI",
+            "Open source CLI for sharing localhost and hosting apps.",
+            "Interactive menu + agent-friendly commands for automation.",
+            "",
+            "Website: https://uplink.spot",
+            "GitHub: https://github.com/firstprinciplecode/uplink",
+            "Issues: https://github.com/firstprinciplecode/uplink/issues",
+          ].join("\n");
+        },
+      });
+
+      mainMenu.push({
+        label: "Exit",
+        action: async () => {
+          return "Goodbye!";
+        },
+      });
+    } else {
+      // Only show other menu items if authentication succeeded
+
+    const shareMenu = buildManageTunnelsMenu({
+      apiRequest,
+      promptLine,
+      restoreRawMode,
+      truncate,
+      formatBytes,
+      inlineSelect,
+      scanCommonPorts: ports.scanCommonPorts,
+      findTunnelClients: tunnelClients.findTunnelClients,
+      createAndStartTunnel: (port: number) => tunnelClients.createAndStartTunnel(apiRequest, port),
+      stopTunnelClients: (clients, opts) => tunnelClients.stopTunnelClients(apiRequest, clients, opts),
+      colorDim,
+      colorRed,
+    });
+
+    const aliasesMenu = buildManageAliasesMenu({
+      apiRequest,
+      promptLine,
+      restoreRawMode,
+      inlineSelect,
+      findTunnelClients: tunnelClients.findTunnelClients,
+      truncate,
+    });
+
+    shareMenu.subMenu = shareMenu.subMenu || [];
+    if (aliasesMenu.subMenu) {
+      shareMenu.subMenu.push({
+        label: "Aliases",
+        subMenu: aliasesMenu.subMenu,
+      });
+    }
+    if (isAdmin) {
+      shareMenu.subMenu.push({
+        label: "⚠️  Stop ALL Tunnel Clients (kill switch)",
+        action: async () => {
+          const clients = tunnelClients.findTunnelClients();
+          if (clients.length === 0) {
+            const ghost = await tunnelClients.stopTunnelClients(apiRequest, [], {
+              connectedGhosts: true,
+            });
+            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.";
+          }
+          const { killed, deleted } = await tunnelClients.stopTunnelClients(apiRequest, clients);
+          return `✓ Stopped ${killed} local client${killed !== 1 ? "s" : ""}, removed ${deleted} tunnel record${deleted !== 1 ? "s" : ""}`;
+        },
+      });
+    }
+
+    mainMenu.push(shareMenu);
+
+    mainMenu.push(
+      buildHostingMenu({
+        promptLine,
+        restoreRawMode,
+        inlineSelect,
+      })
+    );
+
+    mainMenu.push(
+      buildDomainsMenu({
+        promptLine,
+        restoreRawMode,
+        inlineSelect,
+      })
+    );
+
+    // Admin-only: Usage section
+    if (isAdmin) {
+      mainMenu.push(
+        buildUsageMenu({
+          apiRequest,
+          truncate,
+        })
+      );
+    }
+
+    if (isAdmin) {
+      mainMenu.push(
+        buildSystemStatusMenu({
+          apiBase,
+          apiRequest,
+          fetch: (url: string) => fetch(url) as any,
+          truncate,
+          formatBytes,
+          runSmoke: smoke.runSmoke,
+        })
+      );
+    }
+
+    // Admin-only: Manage Tokens
+    if (isAdmin) {
+      mainMenu.push(
+        buildManageTokensMenu({
+          apiRequest,
+          promptLine,
+          restoreRawMode,
+          truncate,
+        })
+      );
+    }
+
+    mainMenu.push({
+      label: "About",
+      action: async () => {
+        return [
+          "Uplink CLI",
+          "Open source CLI for sharing localhost and hosting apps.",
+          "Interactive menu + agent-friendly commands for automation.",
+          "",
+          "Website: https://uplink.spot",
+          "GitHub: https://github.com/firstprinciplecode/uplink",
+          "Issues: https://github.com/firstprinciplecode/uplink/issues",
+        ].join("\n");
+      },
+    });
+
+    mainMenu.push({
+      label: "Exit",
+      action: async () => "Goodbye!",
+    });
+    }
+
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+      console.error("Uplink menu needs an interactive terminal. Use `uplink --help` for commands.");
+      process.exit(1);
+    }
+
+    await runInkMenu({ tree: mainMenu, getStatus: fetchMenuSnapshot });
+}

package/cli/src/tui/snapshot.ts

@@ -0,0 +1,146 @@
+import fetch from "node-fetch";
+import { connectedProviders } from "../registrars";
+import { health, tunnelClients } from "../subcommands/menu/effects";
+import { getResolvedApiBase, getResolvedApiToken } from "../utils/api-base";
+import type { MenuStatus } from "./App";
+
+const SNAPSHOT_TIMEOUT_MS = 2000;
+const ARTIFACT_CAP_BYTES = 500_000_000;
+
+export { ARTIFACT_CAP_BYTES };
+
+type JsonObject = Record<string, unknown>;
+
+function localTunnels(): MenuStatus["tunnels"] {
+  const domain = process.env.TUNNEL_DOMAIN || "x.uplink.spot";
+  const scheme = (process.env.TUNNEL_URL_SCHEME || "https").toLowerCase();
+  return tunnelClients.findTunnelClients().map((client) => ({
+    url: `${scheme}://${client.token}.${domain}`,
+    port: client.port,
+  }));
+}
+
+async function apiGet(path: string, timeoutMs = SNAPSHOT_TIMEOUT_MS): Promise<unknown | null> {
+  const apiBase = getResolvedApiBase();
+  const token = getResolvedApiToken(apiBase);
+  if (!token) return null;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(`${apiBase}${path}`, {
+      signal: controller.signal,
+      headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function asObject(value: unknown): JsonObject | null {
+  return value && typeof value === "object" && !Array.isArray(value) ? (value as JsonObject) : null;
+}
+
+function asString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+async function fetchApps(): Promise<MenuStatus["apps"]> {
+  const body = asObject(await apiGet("/v1/apps"));
+  const apps = body?.apps;
+  if (!Array.isArray(apps)) return [];
+  const parsed: MenuStatus["apps"] = [];
+  for (const item of apps) {
+    const rec = asObject(item);
+    if (!rec) continue;
+    const name = asString(rec.name);
+    const id = asString(rec.id);
+    if (!name || !id) continue;
+    parsed.push({
+      name,
+      id,
+      url: asString(rec.url),
+      createdAt: asString(rec.createdAt),
+    });
+  }
+  return parsed;
+}
+
+async function fetchHealth(): Promise<{ connected: boolean; latencyMs: number | null }> {
+  const started = Date.now();
+  const healthRes = await health.checkApiHealth({});
+  if (!healthRes.ok) return { connected: false, latencyMs: null };
+  return { connected: true, latencyMs: Date.now() - started };
+}
+
+export async function fetchMenuSnapshot(): Promise<MenuStatus> {
+  const tunnels = localTunnels();
+  const [healthStatus, apps, providers] = await Promise.all([
+    fetchHealth(),
+    fetchApps(),
+    Promise.resolve(connectedProviders()),
+  ]);
+  return {
+    connected: healthStatus.connected,
+    latencyMs: healthStatus.latencyMs,
+    tunnels,
+    apps,
+    providers,
+  };
+}
+
+export type AppInspect = {
+  name: string;
+  url: string;
+  createdAt?: string;
+  deploy?: string;
+  build?: string;
+  sizeBytes?: number;
+  domains: { hostname: string; verified: boolean }[];
+};
+
+export async function fetchAppInspect(id: string): Promise<AppInspect | null> {
+  const [statusBody, domainsBody] = await Promise.all([
+    apiGet(`/v1/apps/${id}/status`),
+    apiGet(`/v1/apps/${id}/domains`),
+  ]);
+  const status = asObject(statusBody);
+  if (!status) return null;
+  const app = asObject(status.app);
+  const release = asObject(status.activeRelease);
+  const deployment = asObject(status.activeDeployment);
+  const domainList = asObject(domainsBody)?.domains;
+  const domains: AppInspect["domains"] = [];
+  if (Array.isArray(domainList)) {
+    for (const item of domainList) {
+      const rec = asObject(item);
+      const hostname = rec ? asString(rec.hostname) : undefined;
+      if (!hostname) continue;
+      domains.push({ hostname, verified: rec?.verified === true });
+    }
+  }
+  const size = release?.sizeBytes;
+  return {
+    name: asString(app?.name) || id,
+    url: asString(app?.url) || "",
+    createdAt: asString(app?.createdAt),
+    deploy: asString(deployment?.status),
+    build: asString(release?.buildStatus),
+    sizeBytes: typeof size === "number" && Number.isFinite(size) ? size : undefined,
+    domains,
+  };
+}
+
+export async function fetchAppLogs(id: string): Promise<string> {
+  const body = asObject(await apiGet(`/v1/apps/${id}/logs`, 4000));
+  if (!body) return "No logs available.";
+  const lines = body.lines;
+  if (!Array.isArray(lines) || lines.length === 0) return "No log lines.";
+  return lines
+    .filter((line): line is string => typeof line === "string")
+    .slice(-40)
+    .join("\n");
+}