uplink-cli 0.1.38 → 0.2.0

package/cli/src/tui/snapshot.ts

@@ -0,0 +1,175 @@
+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;
+/** Hard max for a single upload (paid). Free accounts are tighter via /v1/me. */
+const ARTIFACT_CAP_BYTES = 500_000_000;
+
+export { ARTIFACT_CAP_BYTES };
+
+const FREE_STORAGE = 100_000_000;
+const FREE_APP_LIMIT = 1;
+
+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 };
+}
+
+function parseHosting(me: JsonObject | null): {
+  storageUsedBytes: number;
+  storageLimitBytes: number;
+  appLimit: number;
+  alwaysOn: boolean;
+  idleMinutes: number | null;
+} {
+  const hosting = asObject(me?.hosting);
+  const storage = asObject(hosting?.storageBytes);
+  const apps = asObject(hosting?.apps);
+  const used = Number(storage?.used);
+  const limit = Number(storage?.limit);
+  const appLimit = Number(apps?.limit);
+  return {
+    storageUsedBytes: Number.isFinite(used) ? used : 0,
+    storageLimitBytes: Number.isFinite(limit) ? limit : FREE_STORAGE,
+    appLimit: Number.isFinite(appLimit) ? appLimit : FREE_APP_LIMIT,
+    alwaysOn: hosting?.alwaysOn === true,
+    idleMinutes: typeof hosting?.idleMinutes === "number" ? hosting.idleMinutes : 30,
+  };
+}
+
+export async function fetchMenuSnapshot(): Promise<MenuStatus> {
+  const tunnels = localTunnels();
+  const [healthStatus, apps, providers, meBody] = await Promise.all([
+    fetchHealth(),
+    fetchApps(),
+    Promise.resolve(connectedProviders()),
+    apiGet("/v1/me"),
+  ]);
+  const hosting = parseHosting(asObject(meBody));
+  return {
+    connected: healthStatus.connected,
+    latencyMs: healthStatus.latencyMs,
+    tunnels,
+    apps,
+    providers,
+    ...hosting,
+  };
+}
+
+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");
+}

package/cli/src/utils/api-base.ts

@@ -2,6 +2,7 @@ import { homedir } from "os";
 import { join } from "path";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { createInterface } from "readline";
+import { readStoredCredentials } from "./credentials";
 
 export const DEFAULT_API_BASE = "https://api.uplink.spot";
 
@@ -75,6 +76,8 @@ export function getResolvedApiBase(): string {
   if (envBase) return envBase;
   const parsedToken = parseTokenEnv(process.env.AGENTCLOUD_TOKEN);
   if (parsedToken.apiBase) return parsedToken.apiBase;
+  const storedBase = normalizeApiBase(readStoredCredentials()?.apiBase);
+  if (storedBase) return storedBase;
   const configBase = readApiBaseConfig();
   if (configBase) return configBase;
   return DEFAULT_API_BASE;
@@ -83,6 +86,8 @@ export function getResolvedApiBase(): string {
 export function getResolvedApiToken(apiBase: string): string | undefined {
   const parsedToken = parseTokenEnv(process.env.AGENTCLOUD_TOKEN);
   if (parsedToken.token) return parsedToken.token;
+  const stored = readStoredCredentials();
+  if (stored?.token) return stored.token;
   if (isLocalApiBase(apiBase)) {
     return process.env.AGENTCLOUD_TOKEN_DEV || undefined;
   }
@@ -128,6 +133,12 @@ export async function ensureApiBase(options: { interactive: boolean }): Promise<
     return parsedToken.apiBase;
   }
 
+  const storedBase = normalizeApiBase(readStoredCredentials()?.apiBase);
+  if (storedBase) {
+    process.env.AGENTCLOUD_API_BASE = storedBase;
+    return storedBase;
+  }
+
   const configBase = readApiBaseConfig();
   if (configBase) {
     process.env.AGENTCLOUD_API_BASE = configBase;

package/cli/src/utils/credentials.ts

@@ -0,0 +1,58 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+export type StoredCredentials = {
+  token: string;
+  userId?: string;
+  email?: string;
+  accountType?: "guest" | "verified";
+  apiBase?: string;
+  updatedAt?: string;
+};
+
+function credentialsDir(): string {
+  return join(homedir(), ".uplink");
+}
+
+export function credentialsPath(): string {
+  return join(credentialsDir(), "credentials");
+}
+
+export function readStoredCredentials(): StoredCredentials | null {
+  try {
+    const path = credentialsPath();
+    if (!existsSync(path)) return null;
+    const parsed = JSON.parse(readFileSync(path, "utf-8")) as StoredCredentials;
+    if (!parsed?.token || typeof parsed.token !== "string") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+export function writeStoredCredentials(creds: StoredCredentials): string {
+  const dir = credentialsDir();
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  try {
+    chmodSync(dir, 0o700);
+  } catch {
+    /* best effort */
+  }
+  const path = credentialsPath();
+  const body: StoredCredentials = {
+    token: creds.token,
+    userId: creds.userId,
+    email: creds.email,
+    accountType: creds.accountType,
+    apiBase: creds.apiBase,
+    updatedAt: new Date().toISOString(),
+  };
+  writeFileSync(path, JSON.stringify(body, null, 2) + "\n", { mode: 0o600 });
+  try {
+    chmodSync(path, 0o600);
+  } catch {
+    /* best effort */
+  }
+  return path;
+}

package/cli/src/utils/domain-availability.ts

@@ -0,0 +1,56 @@
+import { promises as dns } from "dns";
+import fetch from "node-fetch";
+
+export type PublicAvailability = {
+  domain: string;
+  status: "available" | "taken" | "unknown";
+  source: "dns" | "rdap";
+  detail: string;
+};
+
+const RDAP_TIMEOUT_MS = 8000;
+
+/**
+ * Registrar-free availability check: DNS nameservers first (fast, definitive
+ * for registered domains), then RDAP for the authoritative registration record.
+ * Price and purchase still require a connected registrar.
+ */
+export async function checkDomainAvailability(domain: string): Promise<PublicAvailability> {
+  try {
+    const nameservers = await dns.resolveNs(domain);
+    if (nameservers.length > 0) {
+      return { domain, status: "taken", source: "dns", detail: "domain has nameservers" };
+    }
+  } catch {
+    // NXDOMAIN or no NS records — RDAP decides.
+  }
+
+  let lastFailure = "RDAP unreachable";
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const response = await fetch(`https://rdap.org/domain/${encodeURIComponent(domain)}`, {
+        headers: { accept: "application/rdap+json" },
+        timeout: RDAP_TIMEOUT_MS,
+      });
+      if (response.status === 404) {
+        return { domain, status: "available", source: "rdap", detail: "no registration record" };
+      }
+      if (response.ok) {
+        return { domain, status: "taken", source: "rdap", detail: "registration record exists" };
+      }
+      lastFailure = `RDAP returned ${response.status}`;
+    } catch (error) {
+      lastFailure = error instanceof Error ? error.message : String(error);
+    }
+  }
+  return { domain, status: "unknown", source: "rdap", detail: lastFailure };
+}
+
+export function formatPublicAvailability(result: PublicAvailability): string {
+  const lines = [`${result.domain}  ${result.status}  (${result.detail})`];
+  if (result.status === "available") {
+    lines.push("  Availability is from public DNS/RDAP. For price and purchase, connect a registrar:");
+    lines.push("  uplink domains providers connect godaddy --token-env GODADDY_PAT");
+  }
+  return lines.join("\n");
+}

package/cli/src/utils/guest-access.ts

@@ -0,0 +1,38 @@
+import fetch from "node-fetch";
+import { getResolvedApiBase, getResolvedApiToken } from "./api-base";
+import { readStoredCredentials, writeStoredCredentials } from "./credentials";
+
+type GuestSignup = {
+  token: string;
+  userId: string;
+  accountType?: "guest";
+};
+
+export async function ensureGuestAccess(options: { force?: boolean } = {}): Promise<void> {
+  const apiBase = getResolvedApiBase();
+  // force: mint a fresh guest token even when one resolves (e.g. it was rejected by the API).
+  if (!options.force && getResolvedApiToken(apiBase)) return;
+
+  const response = await fetch(`${apiBase}/v1/signup`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ label: "Automatic guest access" }),
+  });
+  const json = (await response.json().catch(() => ({}))) as GuestSignup & {
+    error?: { code?: string; message?: string };
+  };
+  if (!response.ok || !json.token) {
+    const code = json.error?.code || "GUEST_ACCESS_FAILED";
+    const message = json.error?.message || response.statusText;
+    throw new Error(`${code}: ${message}`);
+  }
+
+  writeStoredCredentials({
+    ...(readStoredCredentials() ?? {}),
+    token: json.token,
+    userId: json.userId,
+    accountType: "guest",
+    apiBase,
+  });
+  process.env.AGENTCLOUD_TOKEN = json.token;
+}

package/cli/src/utils/launchDomainking.ts

@@ -0,0 +1,64 @@
+import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+function projectRoot(): string {
+  return join(__dirname, "../..");
+}
+
+function resolveTsx(): string {
+  const root = projectRoot();
+  try {
+    return require.resolve("tsx/dist/cli.cjs", { paths: [root] });
+  } catch {
+    try {
+      return require.resolve("tsx/cli", { paths: [root] });
+    } catch {
+      return "tsx";
+    }
+  }
+}
+
+/** Domainking stays its own package; we spawn it, we do not import it. */
+export function resolveDomainkingEntry(): string | null {
+  if (process.env.DOMAINKING_ENTRY && existsSync(process.env.DOMAINKING_ENTRY)) {
+    return process.env.DOMAINKING_ENTRY;
+  }
+  const candidates = [
+    join(homedir(), "domainking", "src", "index.tsx"),
+    join(projectRoot(), "..", "domainking", "src", "index.tsx"),
+    join(projectRoot(), "..", "..", "domainking", "src", "index.tsx"),
+  ];
+  return candidates.find((path) => existsSync(path)) ?? null;
+}
+
+export function launchDomainking(): string {
+  const entry = resolveDomainkingEntry();
+  if (!entry) {
+    return [
+      "Domain search TUI is not bundled with uplink-cli.",
+      "",
+      "Agent-friendly commands (no TUI needed):",
+      "  uplink domains list --json",
+      "  uplink domains check example.com --json",
+      "  uplink host domains add --id app_xxx --hostname example.com --json",
+      "  uplink host domains verify --id app_xxx --hostname example.com --json",
+      "",
+      "Optional: set DOMAINKING_ENTRY to a Domainking src/index.tsx for the search UI.",
+    ].join("\n");
+  }
+
+  const result = spawnSync(resolveTsx(), [entry], {
+    stdio: "inherit",
+    cwd: join(entry, "..", ".."),
+    env: process.env,
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status && result.status !== 0) {
+    return "Domain search exited.";
+  }
+  return "Back from domain search. Attach a hostname with Domains › Attach to app.";
+}

package/cli/src/utils/login-flow.ts

@@ -0,0 +1,57 @@
+import { unauthenticatedRequest } from "../subcommands/menu/requests";
+import { getResolvedApiBase } from "./api-base";
+import { writeStoredCredentials } from "./credentials";
+
+export type LoginToken = {
+  id: string;
+  token: string;
+  tokenPrefix: string;
+  role: string;
+  userId: string;
+  label: string;
+  createdAt: string;
+  expiresAt: string | null;
+  message?: string;
+};
+
+export function normalizeEmail(raw: string): string {
+  return raw.trim().toLowerCase();
+}
+
+export function isEmail(raw: string): boolean {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(normalizeEmail(raw));
+}
+
+export async function requestLoginCode(email: string): Promise<{ ok: boolean; message?: string }> {
+  return unauthenticatedRequest(
+    "POST",
+    "/v1/auth/otp/request",
+    { email: normalizeEmail(email) },
+    { includeCurrentToken: true }
+  );
+}
+
+export async function verifyLoginCode(email: string, code: string): Promise<LoginToken> {
+  return unauthenticatedRequest(
+    "POST",
+    "/v1/auth/otp/verify",
+    {
+      email: normalizeEmail(email),
+      code: code.trim(),
+    },
+    { includeCurrentToken: true }
+  );
+}
+
+export function persistLogin(result: { token: string; userId: string }, email?: string): string {
+  const apiBase = getResolvedApiBase();
+  const path = writeStoredCredentials({
+    token: result.token,
+    userId: result.userId,
+    email,
+    accountType: email ? "verified" : "guest",
+    apiBase,
+  });
+  process.env.AGENTCLOUD_TOKEN = result.token;
+  return path;
+}