uplink-cli 0.1.38 → 0.2.0

package/cli/src/tui/AppInspector.tsx

@@ -0,0 +1,114 @@
+import { Box, Text } from "ink";
+import { useEffect, useState } from "react";
+import type { MenuInspect } from "../subcommands/menu/types";
+import { ARTIFACT_CAP_BYTES, fetchAppInspect, type AppInspect } from "./snapshot";
+import { formatBytes, formatDate } from "./format";
+
+const LABEL_WIDTH = 10;
+const GAUGE_WIDTH = 16;
+
+function Row({
+  label,
+  value,
+  color,
+  dim,
+}: {
+  label: string;
+  value: string;
+  color?: "green" | "red";
+  dim?: boolean;
+}) {
+  return (
+    <Box>
+      <Box width={LABEL_WIDTH}>
+        <Text dimColor>{label}</Text>
+      </Box>
+      <Text color={color} dimColor={dim}>
+        {value}
+      </Text>
+    </Box>
+  );
+}
+
+function SizeGauge({ bytes }: { bytes: number }) {
+  const ratio = Math.min(1, bytes / ARTIFACT_CAP_BYTES);
+  const filled = Math.round(ratio * GAUGE_WIDTH);
+  return (
+    <Box>
+      <Box width={LABEL_WIDTH}>
+        <Text dimColor>size</Text>
+      </Box>
+      <Text>
+        <Text color="green">{"█".repeat(filled)}</Text>
+        <Text dimColor>{"░".repeat(GAUGE_WIDTH - filled)}</Text>
+        <Text dimColor>
+          {"  "}
+          {formatBytes(bytes)} / {formatBytes(ARTIFACT_CAP_BYTES)}
+        </Text>
+      </Text>
+    </Box>
+  );
+}
+
+function statusColor(value?: string): "green" | "red" | undefined {
+  if (!value) return undefined;
+  if (value === "running" || value === "ready") return "green";
+  if (value === "failed") return "red";
+  return undefined;
+}
+
+export function AppInspector({ inspect }: { inspect?: MenuInspect }) {
+  const [detail, setDetail] = useState<AppInspect | null>(null);
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    if (!inspect || inspect.kind !== "app") {
+      setDetail(null);
+      return;
+    }
+    let cancelled = false;
+    const timer = setTimeout(() => {
+      setLoading(true);
+      fetchAppInspect(inspect.id).then((next) => {
+        if (cancelled) return;
+        setDetail(next);
+        setLoading(false);
+      });
+    }, 120);
+    return () => {
+      cancelled = true;
+      clearTimeout(timer);
+    };
+  }, [inspect?.id, inspect?.kind]);
+
+  if (!inspect) return null;
+
+  const url = detail?.url || inspect.url || "—";
+  const deploy = detail?.deploy || (loading ? "…" : "—");
+  const build = detail?.build || (loading ? "…" : "—");
+  const domainText =
+    detail && detail.domains.length > 0
+      ? detail.domains
+          .slice(0, 2)
+          .map((domain) => `${domain.hostname}${domain.verified ? "" : " (pending)"}`)
+          .join(", ") + (detail.domains.length > 2 ? ` +${detail.domains.length - 2}` : "")
+      : loading && !detail
+        ? "…"
+        : "none";
+
+  return (
+    <Box flexDirection="column" marginTop={1}>
+      <Text dimColor>── inspect ──</Text>
+      <Row label="url" value={url} />
+      <Row label="status" value={deploy} color={statusColor(detail?.deploy)} dim={!detail?.deploy} />
+      <Row label="build" value={build} color={statusColor(detail?.build)} dim={!detail?.build} />
+      {detail?.sizeBytes != null ? (
+        <SizeGauge bytes={detail.sizeBytes} />
+      ) : (
+        <Row label="size" value={loading ? "…" : "none"} dim />
+      )}
+      <Row label="created" value={formatDate(detail?.createdAt || inspect.createdAt)} dim={!detail?.createdAt && !inspect.createdAt} />
+      <Row label="domains" value={domainText} dim={domainText === "none"} />
+    </Box>
+  );
+}

package/cli/src/tui/HomeStatus.tsx

@@ -0,0 +1,92 @@
+import { Box, Text } from "ink";
+import type { MenuStatus } from "./App";
+import { Wordmark } from "./brand";
+import { formatBytes } from "./format";
+
+const LABEL_WIDTH = 12;
+const SPACE_GAUGE = 16;
+
+function formatLimit(n: number): string {
+  return n < 0 ? "∞" : String(n);
+}
+
+function Metric({ label, value }: { label: string; value: string }) {
+  return (
+    <Box>
+      <Box width={LABEL_WIDTH}>
+        <Text dimColor>{label}</Text>
+      </Box>
+      <Text>{value}</Text>
+    </Box>
+  );
+}
+
+function SpaceMetric({ usedBytes, limitBytes }: { usedBytes: number; limitBytes: number }) {
+  const used = Math.max(0, usedBytes);
+  const unlimited = limitBytes < 0;
+  const cap = unlimited ? Math.max(used, 1) : Math.max(limitBytes, 1);
+  const left = unlimited ? used : Math.max(0, limitBytes - used);
+  const ratio = unlimited ? 0 : Math.min(1, used / cap);
+  const filled = Math.round(ratio * SPACE_GAUGE);
+  const nearlyFull = !unlimited && ratio >= 0.85;
+
+  return (
+    <Box flexDirection="column">
+      <Box>
+        <Box width={LABEL_WIDTH}>
+          <Text dimColor>space</Text>
+        </Box>
+        <Text>
+          <Text color={nearlyFull ? "red" : "green"}>{"█".repeat(filled)}</Text>
+          <Text dimColor>{"░".repeat(SPACE_GAUGE - filled)}</Text>
+          <Text dimColor>
+            {"  "}
+            {unlimited ? `${formatBytes(used)} used` : `${formatBytes(left)} left`}
+          </Text>
+        </Text>
+      </Box>
+      <Box>
+        <Box width={LABEL_WIDTH}>
+          <Text> </Text>
+        </Box>
+        <Text dimColor>
+          {unlimited ? "unlimited" : `of ${formatBytes(limitBytes)} hosting budget`}
+        </Text>
+      </Box>
+    </Box>
+  );
+}
+
+export function HomeStatus({ status }: { status: MenuStatus }) {
+  const latency =
+    status.connected && status.latencyMs != null ? `${status.latencyMs}ms` : "0ms";
+  const plan = status.alwaysOn ? "always-on" : `sleep after ${status.idleMinutes ?? 30}m idle`;
+
+  return (
+    <Box flexDirection="column">
+      <Wordmark />
+      <Box marginTop={1}>
+        <Text color={status.connected ? "green" : "yellow"}>
+          ● {status.connected ? "connected" : "offline"}
+        </Text>
+        <Text dimColor> · {latency}</Text>
+      </Box>
+      <Box marginTop={1} marginBottom={1}>
+        <Text dimColor>{"─".repeat(36)}</Text>
+      </Box>
+      <Box flexDirection="column">
+        <Metric
+          label="apps"
+          value={`${status.apps.length} / ${formatLimit(status.appLimit)}`}
+        />
+        <Metric label="tunnels" value={String(status.tunnels.length)} />
+        <Metric label="registrars" value={String(status.providers.length)} />
+        <SpaceMetric usedBytes={status.storageUsedBytes} limitBytes={status.storageLimitBytes} />
+        <Metric label="plan" value={plan} />
+      </Box>
+      <Box marginTop={1}>
+        <Text dimColor>{"─".repeat(36)}</Text>
+      </Box>
+    </Box>
+  );
+}

package/cli/src/tui/brand.tsx

@@ -0,0 +1,20 @@
+import { Box, Text } from "ink";
+
+const WORDMARK = [
+  " _   _ ___ _    ___ _  _ _  __",
+  "| | | | _ \\ |  |_ _| \\| | |/ /",
+  "| |_| |  _/ |__ | || .` | ' < ",
+  " \\___/|_| |____|___|_|\\_|_|\\_\\",
+];
+
+export function Wordmark() {
+  return (
+    <Box flexDirection="column">
+      {WORDMARK.map((line) => (
+        <Text key={line} bold>
+          {line}
+        </Text>
+      ))}
+    </Box>
+  );
+}

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,267 @@
+import fetch from "node-fetch";
+import { apiRequest } from "../http";
+import { clearScreen, promptLine, restoreRawMode, truncate } from "../subcommands/menu/io";
+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 { buildFindDomainAction } from "../subcommands/menu/menus/domain-check";
+import { ports, smoke, tunnelClients } from "../subcommands/menu/effects";
+import { runInkMenu } from "./runMenu";
+import { fetchMenuSnapshot } from "./snapshot";
+import { isEmail, normalizeEmail, persistLogin, requestLoginCode, verifyLoginCode } from "../utils/login-flow";
+import { ensureGuestAccess } from "../utils/guest-access";
+
+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];
+}
+
+async function continueWithEmail(): Promise<string | undefined> {
+  restoreRawMode();
+  clearScreen();
+  try {
+    process.stdout.write("\n");
+    process.stdout.write(colorWhite("UPLINK") + colorDim("  Continue with email\n\n"));
+    const email = normalizeEmail(await promptLine("Email: "));
+    if (!isEmail(email)) return "Invalid email.";
+
+    await requestLoginCode(email);
+    process.stdout.write(`\nCode sent to ${email}.\n`);
+    const code = (await promptLine("Code: ")).trim();
+    if (!/^\d{6}$/.test(code)) return "Code must be 6 digits.";
+
+    const result = await verifyLoginCode(email, code);
+    if (!result?.token) return "Invalid response from server. Token not received.";
+    const savedTo = persistLogin(result, email);
+    process.stdout.write(`\n${colorGreen("✓")} Account verified\n`);
+    process.stdout.write(colorDim(`  ${savedTo}\n\n`));
+    return "Email verified. Run uplink again to see Hosting and Domains.";
+  } catch (err: any) {
+    const errorMsg = err?.message || String(err);
+    if (errorMsg.includes("429") || errorMsg.includes("RATE_LIMIT")) {
+      return "Too many attempts. Please try again later.";
+    }
+    return `Email verification failed: ${errorMsg}`;
+  } finally {
+    restoreRawMode();
+  }
+}
+
+const aboutItem: MenuChoice = {
+  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");
+  },
+};
+
+const exitItem: MenuChoice = {
+  label: "Exit",
+  action: async () => "Goodbye!",
+};
+
+export async function startMenuSession(): Promise<void> {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+      console.error("Uplink menu needs an interactive terminal. Use `uplink --help` for commands.");
+      process.exit(1);
+    }
+
+    const apiBase = process.env.AGENTCLOUD_API_BASE || "https://api.uplink.spot";
+
+    let isAdmin = false;
+    let accountType: "guest" | "verified" | "admin" | null = null;
+    let connectionError: string | null = null;
+
+    const resolveAccount = async (): Promise<void> => {
+      const me = await apiRequest("GET", "/v1/me");
+      isAdmin = me?.role === "admin";
+      accountType = isAdmin ? "admin" : me?.accountType === "verified" ? "verified" : "guest";
+    };
+
+    try {
+      await resolveAccount();
+    } catch (err: any) {
+      const errorMsg = err?.message || String(err);
+      const authFailed =
+        errorMsg.includes("UNAUTHORIZED") ||
+        errorMsg.includes("401") ||
+        errorMsg.includes("Missing or invalid token") ||
+        errorMsg.includes("Missing AGENTCLOUD_TOKEN");
+      if (authFailed) {
+        // No usable token: quietly create guest access so everyone gets the same menu.
+        try {
+          await ensureGuestAccess({ force: true });
+          await resolveAccount();
+        } catch (guestErr: any) {
+          connectionError = guestErr?.message || String(guestErr);
+        }
+      } else {
+        connectionError = errorMsg;
+      }
+    }
+
+    const mainMenu: MenuChoice[] = [];
+
+    if (!accountType) {
+      // API unreachable (or guest provisioning failed): minimal offline menu.
+      mainMenu.push({
+        label: "Connection details",
+        action: async () => {
+          return [
+            `Could not reach ${apiBase}.`,
+            "",
+            connectionError ?? "Unknown error.",
+            "",
+            "Check your network, then run uplink again.",
+          ].join("\n");
+        },
+      });
+      mainMenu.push(aboutItem);
+      mainMenu.push(exitItem);
+    } else {
+
+    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,
+    });
+
+    shareMenu.subMenu = shareMenu.subMenu || [];
+    if (accountType !== "guest") {
+      const aliasesMenu = buildManageAliasesMenu({
+        apiRequest,
+        promptLine,
+        restoreRawMode,
+        inlineSelect,
+        findTunnelClients: tunnelClients.findTunnelClients,
+        truncate,
+      });
+      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);
+
+    if (accountType === "guest") {
+      mainMenu.push({
+        label: "Check domain availability",
+        action: buildFindDomainAction({ promptLine, restoreRawMode }),
+      });
+      mainMenu.push({
+        label: "Continue with email  (unlock hosting + domains)",
+        action: continueWithEmail,
+      });
+    } else {
+      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(aboutItem);
+    mainMenu.push(exitItem);
+    }
+
+    await runInkMenu({ tree: mainMenu, getStatus: fetchMenuSnapshot });
+}