uplink-cli 0.1.3 → 0.1.6

package/cli/src/agents/tunnels-client.ts

@@ -0,0 +1,55 @@
+import { apiRequest } from "../http";
+
+export type Tunnel = {
+  id: string;
+  url?: string;
+  ingressHttpUrl?: string;
+  token?: string;
+  alias?: string | null;
+  status?: string;
+  createdAt?: string;
+  updatedAt?: string;
+};
+
+export class TunnelsClient {
+  async create(port: number, opts?: { project?: string; alias?: string }) {
+    const tunnel = await apiRequest("POST", "/v1/tunnels", {
+      port,
+      project: opts?.project,
+    }) as Tunnel;
+
+    let aliasError: string | null = null;
+    if (opts?.alias) {
+      try {
+        const aliasResult = await apiRequest("POST", `/v1/tunnels/${tunnel.id}/alias`, {
+          alias: opts.alias,
+        }) as Tunnel;
+        tunnel.alias = aliasResult.alias ?? tunnel.alias;
+      } catch (err: any) {
+        aliasError = err?.message || String(err);
+      }
+    }
+
+    return { tunnel, aliasError };
+  }
+
+  async list() {
+    return apiRequest("GET", "/v1/tunnels") as Promise<{ tunnels: Tunnel[]; count: number }>;
+  }
+
+  async setAlias(id: string, alias: string) {
+    return apiRequest("POST", `/v1/tunnels/${id}/alias`, { alias }) as Promise<Tunnel>;
+  }
+
+  async deleteAlias(id: string) {
+    return apiRequest("DELETE", `/v1/tunnels/${id}/alias`) as Promise<Tunnel>;
+  }
+
+  async stats(id: string) {
+    return apiRequest("GET", `/v1/tunnels/${id}/stats`);
+  }
+
+  async stop(id: string) {
+    return apiRequest("DELETE", `/v1/tunnels/${id}`) as Promise<{ id: string; status: string }>;
+  }
+}

package/cli/src/index.ts

@@ -4,19 +4,54 @@ import { dbCommand } from "./subcommands/db";
 import { devCommand } from "./subcommands/dev";
 import { adminCommand } from "./subcommands/admin";
 import { menuCommand } from "./subcommands/menu";
+import { tunnelCommand } from "./subcommands/tunnel";
+import { signupCommand } from "./subcommands/signup";
 
 const program = new Command();
 
 program
   .name("uplink")
   .description("Agent-friendly cloud CLI")
-  .version("0.1.0");
+  .version("0.1.0")
+  .option("--api-base <url>", "Override API base URL (default env AGENTCLOUD_API_BASE)")
+  .option("--token-stdin", "Read AGENTCLOUD_TOKEN from stdin once");
 
 program.addCommand(dbCommand);
 program.addCommand(devCommand);
 program.addCommand(adminCommand);
+program.addCommand(tunnelCommand);
+program.addCommand(signupCommand);
 program.addCommand(menuCommand);
 
+// Global pre-action hook to apply shared options
+let cachedTokenStdin: string | null = null;
+program.hook("preAction", async (thisCommand) => {
+  // Collect global options
+  const opts =
+    typeof thisCommand.optsWithGlobals === "function"
+      ? thisCommand.optsWithGlobals()
+      : thisCommand.opts();
+
+  if (opts.apiBase) {
+    process.env.AGENTCLOUD_API_BASE = String(opts.apiBase);
+  }
+
+  if (opts.tokenStdin) {
+    if (!cachedTokenStdin) {
+      cachedTokenStdin = await new Promise<string>((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => (data += chunk));
+        process.stdin.on("end", () => resolve(data.trim()));
+        process.stdin.on("error", (err) => reject(err));
+      });
+    }
+    if (cachedTokenStdin) {
+      process.env.AGENTCLOUD_TOKEN = cachedTokenStdin;
+    }
+  }
+});
+
 // If no command provided and not a flag, default to menu
 if (process.argv.length === 2) {
   process.argv.push("menu");

package/cli/src/subcommands/menu.ts

@@ -8,6 +8,11 @@ import { homedir } from "os";
 import { join } from "path";
 import { existsSync, readFileSync, writeFileSync } from "fs";
 
+// Check if running from project directory (smoke tests require local scripts)
+function isInProjectDir(): boolean {
+  return existsSync("scripts/test-comprehensive.sh") && existsSync("package.json");
+}
+
 type MenuChoice = {
   label: string;
   action?: () => Promise<string>;
@@ -471,33 +476,36 @@ export const menuCommand = new Command("menu")
       // Only show other menu items if authentication succeeded
 
     if (isAdmin) {
-      mainMenu.push({
-        label: "System Status",
-        subMenu: [
-          {
-            label: "View Status",
-            action: async () => {
-              let health = "unknown";
-              try {
-                const res = await fetch(`${apiBase}/health`);
-                const json = await res.json().catch(() => ({}));
-                health = json.status || res.statusText || "unknown";
-              } catch {
-                health = "unreachable";
-              }
+      const systemStatusItems: MenuChoice[] = [
+        {
+          label: "View Status",
+          action: async () => {
+            let health = "unknown";
+            try {
+              const res = await fetch(`${apiBase}/health`);
+              const json = await res.json().catch(() => ({}));
+              health = json.status || res.statusText || "unknown";
+            } catch {
+              health = "unreachable";
+            }
 
-              const stats = await apiRequest("GET", "/v1/admin/stats");
-              return [
-                `API health: ${health}`,
-                "Tunnels:",
-                `  Active ${stats.tunnels.active} | Inactive ${stats.tunnels.inactive} | Deleted ${stats.tunnels.deleted} | Total ${stats.tunnels.total}`,
-                `  Created last 24h: ${stats.tunnels.createdLast24h}`,
-                "Databases:",
-                `  Ready ${stats.databases.ready} | Provisioning ${stats.databases.provisioning} | Failed ${stats.databases.failed} | Deleted ${stats.databases.deleted} | Total ${stats.databases.total}`,
-                `  Created last 24h: ${stats.databases.createdLast24h}`,
-              ].join("\n");
-            },
+            const stats = await apiRequest("GET", "/v1/admin/stats");
+            return [
+              `API health: ${health}`,
+              "Tunnels:",
+              `  Active ${stats.tunnels.active} | Inactive ${stats.tunnels.inactive} | Deleted ${stats.tunnels.deleted} | Total ${stats.tunnels.total}`,
+              `  Created last 24h: ${stats.tunnels.createdLast24h}`,
+              "Databases:",
+              `  Ready ${stats.databases.ready} | Provisioning ${stats.databases.provisioning} | Failed ${stats.databases.failed} | Deleted ${stats.databases.deleted} | Total ${stats.databases.total}`,
+              `  Created last 24h: ${stats.databases.createdLast24h}`,
+            ].join("\n");
           },
+        },
+      ];
+
+      // Smoke tests only available when running from project directory
+      if (isInProjectDir()) {
+        systemStatusItems.push(
           {
             label: "Test: Tunnel",
             action: async () => {
@@ -525,72 +533,80 @@ export const menuCommand = new Command("menu")
               await runSmoke("test:comprehensive");
               return "test:comprehensive completed";
             },
-          },
-          {
-            label: "View Connected Tunnels",
-            action: async () => {
-              try {
-                const data = await apiRequest("GET", "/v1/admin/relay-status") as {
-                  connectedTunnels?: number;
-                  tunnels?: Array<{ token: string; clientIp: string; targetPort: number; connectedAt: string; connectedFor: string }>;
-                  timestamp?: string;
-                  error?: string;
-                  message?: string;
-                };
-
-                if (data.error) {
-                  return `Error: ${data.error}${data.message ? ` - ${data.message}` : ""}`;
-                }
-                if (!data.tunnels || data.tunnels.length === 0) {
-                  return "No tunnels currently connected to the relay.";
-                }
-
-                const lines = data.tunnels.map((t) =>
-                  `${truncate(t.token, 12).padEnd(14)} ${t.clientIp.padEnd(16)} ${String(t.targetPort).padEnd(6)} ${t.connectedFor.padEnd(10)} ${truncate(t.connectedAt, 19)}`
-                );
+          }
+        );
+      }
 
-                return [
-                  `Connected Tunnels: ${data.connectedTunnels}`,
-                  "",
-                  "Token          Client IP        Port   Uptime     Connected At",
-                  "-".repeat(75),
-                  ...lines,
-                ].join("\n");
-              } catch (err: any) {
-                return `Error: Failed to get relay status - ${err.message}`;
-              }
-            },
-          },
-          {
-            label: "View Traffic Stats",
-            action: async () => {
-              const data = await apiRequest("GET", "/v1/admin/traffic-stats?sync=true") as {
-                count?: number;
-                aliases?: Array<{ alias: string; requests: number; bytesIn: number; bytesOut: number; lastSeenAt: string | null; lastStatus: number | null }>;
+      systemStatusItems.push(
+        {
+          label: "View Connected Tunnels",
+          action: async () => {
+            try {
+              const data = await apiRequest("GET", "/v1/admin/relay-status") as {
+                connectedTunnels?: number;
+                tunnels?: Array<{ token: string; clientIp: string; targetPort: number; connectedAt: string; connectedFor: string }>;
+                timestamp?: string;
+                error?: string;
+                message?: string;
               };
 
-              const aliases = data.aliases || [];
-              if (aliases.length === 0) return "No persisted alias stats yet.";
+              if (data.error) {
+                return `Error: ${data.error}${data.message ? ` - ${data.message}` : ""}`;
+              }
+              if (!data.tunnels || data.tunnels.length === 0) {
+                return "No tunnels currently connected to the relay.";
+              }
 
-              const top = aliases.slice(0, 25);
-              const lines = top.map((a) => {
-                const last = a.lastSeenAt ? truncate(a.lastSeenAt, 19) : "-";
-                return `${truncate(a.alias, 22).padEnd(24)} ${String(a.requests || 0).padStart(8)}  ${formatBytes(a.bytesIn || 0).padStart(9)}  ${formatBytes(a.bytesOut || 0).padStart(9)}  ${String(a.lastStatus ?? "-").padStart(3)}  ${last}`;
-              });
+              const lines = data.tunnels.map((t) =>
+                `${truncate(t.token, 12).padEnd(14)} ${t.clientIp.padEnd(16)} ${String(t.targetPort).padEnd(6)} ${t.connectedFor.padEnd(10)} ${truncate(t.connectedAt, 19)}`
+              );
 
               return [
-                `Aliases tracked: ${aliases.length}`,
+                `Connected Tunnels: ${data.connectedTunnels}`,
                 "",
-                "Alias                    Requests   In         Out        Sts  Last Seen",
+                "Token          Client IP        Port   Uptime     Connected At",
                 "-".repeat(75),
                 ...lines,
-                aliases.length > top.length ? `\nShowing top ${top.length} by requests.` : "",
-              ]
-                .filter(Boolean)
-                .join("\n");
-            },
+              ].join("\n");
+            } catch (err: any) {
+              return `Error: Failed to get relay status - ${err.message}`;
+            }
           },
-        ],
+        },
+        {
+          label: "View Traffic Stats",
+          action: async () => {
+            const data = await apiRequest("GET", "/v1/admin/traffic-stats?sync=true") as {
+              count?: number;
+              aliases?: Array<{ alias: string; requests: number; bytesIn: number; bytesOut: number; lastSeenAt: string | null; lastStatus: number | null }>;
+            };
+
+            const aliases = data.aliases || [];
+            if (aliases.length === 0) return "No persisted alias stats yet.";
+
+            const top = aliases.slice(0, 25);
+            const lines = top.map((a) => {
+              const last = a.lastSeenAt ? truncate(a.lastSeenAt, 19) : "-";
+              return `${truncate(a.alias, 22).padEnd(24)} ${String(a.requests || 0).padStart(8)}  ${formatBytes(a.bytesIn || 0).padStart(9)}  ${formatBytes(a.bytesOut || 0).padStart(9)}  ${String(a.lastStatus ?? "-").padStart(3)}  ${last}`;
+            });
+
+            return [
+              `Aliases tracked: ${aliases.length}`,
+              "",
+              "Alias                    Requests   In         Out        Sts  Last Seen",
+              "-".repeat(75),
+              ...lines,
+              aliases.length > top.length ? `\nShowing top ${top.length} by requests.` : "",
+            ]
+              .filter(Boolean)
+              .join("\n");
+          },
+        }
+      );
+
+      mainMenu.push({
+        label: "System Status",
+        subMenu: systemStatusItems,
       });
     }
 

package/cli/src/subcommands/signup.ts

@@ -0,0 +1,79 @@
+import { Command } from "commander";
+import { printJson, handleError } from "../utils/machine";
+
+type SignupResponse = {
+  id: string;
+  token: string;
+  tokenPrefix: string;
+  role: string;
+  userId: string;
+  label: string;
+  createdAt: string;
+  expiresAt: string | null;
+  message: string;
+};
+
+/**
+ * Unauthenticated request for signup (no token required)
+ */
+async function signupRequest(body: Record<string, unknown>): Promise<SignupResponse> {
+  const apiBase = process.env.AGENTCLOUD_API_BASE || "https://api.uplink.spot";
+  const url = `${apiBase}/v1/signup`;
+
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+
+  const json = await res.json();
+
+  if (!res.ok) {
+    const code = json?.error?.code || "SIGNUP_ERROR";
+    const msg = json?.error?.message || json?.message || res.statusText;
+    throw new Error(`${code}: ${msg}`);
+  }
+
+  return json as SignupResponse;
+}
+
+export const signupCommand = new Command("signup")
+  .description("Create a new user account and token (no auth required)")
+  .option("--label <label>", "Optional label for the token")
+  .option("--expires-days <days>", "Token expiration in days (optional)")
+  .option("--json", "Output JSON", false)
+  .action(async (opts) => {
+    try {
+      const body: Record<string, unknown> = {};
+      if (opts.label) body.label = opts.label;
+      if (opts.expiresDays) {
+        const days = Number(opts.expiresDays);
+        if (!Number.isFinite(days) || days <= 0) {
+          console.error("Invalid --expires-days. Provide a positive number.");
+          process.exit(2);
+        }
+        body.expiresInDays = days;
+      }
+
+      const result = await signupRequest(body);
+
+      if (opts.json) {
+        printJson(result);
+      } else {
+        console.log("Account created successfully!");
+        console.log("");
+        console.log(`  Token:    ${result.token}`);
+        console.log(`  User ID:  ${result.userId}`);
+        console.log(`  Role:     ${result.role}`);
+        console.log(`  Label:    ${result.label}`);
+        console.log(`  Expires:  ${result.expiresAt ?? "never"}`);
+        console.log("");
+        console.log("Save this token securely - it will not be shown again.");
+        console.log("");
+        console.log("To use this token, set the environment variable:");
+        console.log(`  export AGENTCLOUD_TOKEN="${result.token}"`);
+      }
+    } catch (error) {
+      handleError(error, { json: opts.json });
+    }
+  });

package/cli/src/subcommands/tunnel.ts

@@ -0,0 +1,192 @@
+import { Command } from "commander";
+import { apiRequest } from "../http";
+import { handleError, printJson } from "../utils/machine";
+
+type TunnelResponse = {
+  id: string;
+  url?: string;
+  host?: string;
+  port?: number;
+  token?: string;
+  alias?: string | null;
+  status?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  ingressHttpUrl?: string;
+};
+
+type TunnelListResponse = {
+  tunnels: TunnelResponse[];
+  count: number;
+};
+
+type TunnelStatsResponse = any;
+
+export const tunnelCommand = new Command("tunnel")
+  .description("Manage tunnels non-interactively (agent-friendly)");
+
+// Create tunnel
+tunnelCommand
+  .command("create")
+  .description("Create a tunnel")
+  .requiredOption("--port <port>", "Local port to expose")
+  .option("--alias <alias>", "Optional permanent alias (if enabled on account)")
+  .option("--project <project>", "Optional project id")
+  .option("--json", "Output JSON", false)
+  .action(async (opts) => {
+    const port = Number(opts.port);
+    if (!Number.isFinite(port) || port <= 0) {
+      console.error("Invalid port. Provide a positive integer.");
+      process.exit(2);
+    }
+
+    try {
+      const body: Record<string, unknown> = { port };
+      if (opts.project) body.project = opts.project;
+
+      const tunnel = await apiRequest("POST", "/v1/tunnels", body) as TunnelResponse;
+      let aliasResult: TunnelResponse | null = null;
+      let aliasError: string | null = null;
+
+      if (opts.alias) {
+        try {
+          aliasResult = await apiRequest("POST", `/v1/tunnels/${tunnel.id}/alias`, {
+            alias: opts.alias,
+          }) as TunnelResponse;
+        } catch (err: any) {
+          aliasError = err?.message || String(err);
+        }
+      }
+
+      if (opts.json) {
+        printJson({
+          tunnel,
+          alias: aliasResult?.alias ?? null,
+          aliasError,
+        });
+      } else {
+        console.log(`Created tunnel ${tunnel.id}`);
+        console.log(`  url:   ${tunnel.url ?? tunnel.ingressHttpUrl ?? "-"}`);
+        console.log(`  token: ${tunnel.token ?? "-"}`);
+        if (opts.alias) {
+          if (aliasResult?.alias) {
+            console.log(`  alias: ${aliasResult.alias}`);
+          } else if (aliasError) {
+            console.log(`  alias: failed - ${aliasError}`);
+          }
+        } else if (tunnel.alias) {
+          console.log(`  alias: ${tunnel.alias}`);
+        }
+      }
+    } catch (error) {
+      handleError(error, { json: opts.json });
+    }
+  });
+
+// List tunnels
+tunnelCommand
+  .command("list")
+  .description("List your tunnels")
+  .option("--json", "Output JSON", false)
+  .action(async (opts) => {
+    try {
+      const result = await apiRequest("GET", "/v1/tunnels") as TunnelListResponse;
+      if (opts.json) {
+        printJson(result);
+      } else {
+        if (!result.tunnels || result.tunnels.length === 0) {
+          console.log("No tunnels found.");
+          return;
+        }
+        console.log(`Tunnels (${result.count}):`);
+        for (const t of result.tunnels) {
+          console.log(
+            `${t.id}  ${t.url ?? t.ingressHttpUrl ?? "-"}  token=${t.token ?? "-"}  alias=${t.alias ?? "-"}  status=${t.status ?? "-"}`
+          );
+        }
+      }
+    } catch (error) {
+      handleError(error, { json: opts.json });
+    }
+  });
+
+// Set alias
+tunnelCommand
+  .command("alias-set")
+  .description("Set or update an alias for a tunnel")
+  .requiredOption("--id <id>", "Tunnel id")
+  .requiredOption("--alias <alias>", "Alias to set")
+  .option("--json", "Output JSON", false)
+  .action(async (opts) => {
+    try {
+      const result = await apiRequest("POST", `/v1/tunnels/${opts.id}/alias`, {
+        alias: opts.alias,
+      }) as TunnelResponse;
+      if (opts.json) {
+        printJson(result);
+      } else {
+        console.log(`Alias set: ${result.alias ?? opts.alias} -> ${result.url ?? "-"}`);
+      }
+    } catch (error) {
+      handleError(error, { json: opts.json });
+    }
+  });
+
+// Delete alias
+tunnelCommand
+  .command("alias-delete")
+  .description("Remove alias from a tunnel")
+  .requiredOption("--id <id>", "Tunnel id")
+  .option("--json", "Output JSON", false)
+  .action(async (opts) => {
+    try {
+      const result = await apiRequest("DELETE", `/v1/tunnels/${opts.id}/alias`) as TunnelResponse;
+      if (opts.json) {
+        printJson(result);
+      } else {
+        console.log(`Alias removed for tunnel ${result.id}`);
+      }
+    } catch (error) {
+      handleError(error, { json: opts.json });
+    }
+  });
+
+// Stats
+tunnelCommand
+  .command("stats")
+  .description("Get tunnel stats (in-memory or alias totals)")
+  .requiredOption("--id <id>", "Tunnel id")
+  .option("--json", "Output JSON", false)
+  .action(async (opts) => {
+    try {
+      const result = await apiRequest("GET", `/v1/tunnels/${opts.id}/stats`) as TunnelStatsResponse;
+      if (opts.json) {
+        printJson(result);
+      } else {
+        console.log(`Stats for tunnel ${opts.id}`);
+        console.log(JSON.stringify(result, null, 2));
+      }
+    } catch (error) {
+      handleError(error, { json: opts.json });
+    }
+  });
+
+// Stop (delete) tunnel
+tunnelCommand
+  .command("stop")
+  .description("Stop (delete) a tunnel")
+  .requiredOption("--id <id>", "Tunnel id")
+  .option("--json", "Output JSON", false)
+  .action(async (opts) => {
+    try {
+      const result = await apiRequest("DELETE", `/v1/tunnels/${opts.id}`) as { id: string; status: string };
+      if (opts.json) {
+        printJson(result);
+      } else {
+        console.log(`Stopped tunnel ${result.id} (status=${result.status})`);
+      }
+    } catch (error: any) {
+      console.error(error?.message || String(error));
+      process.exit(30);
+    }
+  });

package/cli/src/utils/machine.ts

@@ -0,0 +1,45 @@
+/**
+ * Machine-mode helpers for CLI commands.
+ * Ensures JSON-only stdout in --json mode and consistent exit codes.
+ */
+
+export type MachineOptions = { json?: boolean };
+
+export function printJson(data: unknown) {
+  process.stdout.write(JSON.stringify(data, null, 2));
+  process.stdout.write("\n");
+}
+
+export function selectExitCode(message: string): number {
+  const msg = message.toLowerCase();
+  if (
+    msg.includes("missing agentcloud_token") ||
+    msg.includes("unauthorized") ||
+    msg.includes("forbidden") ||
+    msg.includes("401") ||
+    msg.includes("403")
+  ) {
+    return 10; // auth missing/invalid
+  }
+  if (
+    msg.includes("econnrefused") ||
+    msg.includes("enotfound") ||
+    msg.includes("etimedout") ||
+    msg.includes("econnreset") ||
+    msg.includes("socket hang up") ||
+    msg.includes("network")
+  ) {
+    return 20; // network
+  }
+  return 30; // server/unknown
+}
+
+export function handleError(error: unknown, opts: MachineOptions = {}) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (opts.json) {
+    printJson({ error: message });
+  } else {
+    console.error(message);
+  }
+  process.exit(selectExitCode(message));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uplink-cli",
-  "version": "0.1.3",
+  "version": "0.1.6",
   "description": "Expose localhost to the internet in seconds. Interactive terminal UI, permanent custom domains, zero config. A modern ngrok alternative.",
   "keywords": [
     "tunnel",