uplink-cli 0.1.4 → 0.1.7

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/dev.ts

@@ -38,7 +38,7 @@ export const devCommand = new Command("dev")
         "tunnel",
         clientFile
       );
-      const ctrlHost = process.env.TUNNEL_CTRL ?? "127.0.0.1:7071";
+      const ctrlHost = process.env.TUNNEL_CTRL ?? "tunnel.uplink.spot:7071";
       const args = [
         clientPath,
         "--token",

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.4",
+  "version": "0.1.7",
   "description": "Expose localhost to the internet in seconds. Interactive terminal UI, permanent custom domains, zero config. A modern ngrok alternative.",
   "keywords": [
     "tunnel",