uplink-cli 0.1.0-alpha.1

package/cli/src/subcommands/db.ts

@@ -0,0 +1,117 @@
+import { Command } from "commander";
+import { apiRequest } from "../http";
+
+export const dbCommand = new Command("db").description("Manage databases");
+
+dbCommand
+  .command("create")
+  .description("Create a new database")
+  .requiredOption("--name <name>", "Database name")
+  .requiredOption("--project <project>", "Project name")
+  .option("--provider <provider>", "Provider", "neon")
+  .option("--region <region>", "Region", "eu-central-1")
+  .option("--plan <plan>", "Plan", "dev")
+  .option("--json", "Output JSON", false)
+  .action(async (opts) => {
+    const body = {
+      name: opts.name,
+      project: opts.project,
+      provider: opts.provider,
+      region: opts.region,
+      plan: opts.plan,
+    };
+
+    const result = await apiRequest("POST", "/v1/dbs", body);
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`Created DB ${result.name} (${result.id}) in ${result.region}`);
+    }
+  });
+
+dbCommand
+  .command("list")
+  .description("List databases")
+  .option("--project <project>", "Project name")
+  .option("--json", "Output JSON", false)
+  .action(async (opts) => {
+    const query = opts.project ? `?project=${encodeURIComponent(opts.project)}` : "";
+    const result = await apiRequest("GET", `/v1/dbs${query}`);
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      for (const db of result.items) {
+        console.log(
+          `${db.id}  ${db.name}  ${db.region}  ${db.status}  ready=${db.ready}`
+        );
+      }
+    }
+  });
+
+dbCommand
+  .command("info")
+  .description("Get details for a database")
+  .requiredOption("--id <id>", "Database id")
+  .option("--json", "Output JSON", false)
+  .action(async (opts) => {
+    const result = await apiRequest("GET", `/v1/dbs/${opts.id}`);
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`DB ${result.name} (${result.id})`);
+      console.log(`  region: ${result.region}`);
+      console.log(`  status: ${result.status}`);
+      console.log(`  engine: ${result.engine} ${result.version}`);
+    }
+  });
+
+dbCommand
+  .command("delete")
+  .description("Delete a database")
+  .requiredOption("--id <id>", "Database id")
+  .option("--yes", "Confirm deletion", false)
+  .option("--json", "Output JSON", false)
+  .action(async (opts) => {
+    if (!opts.yes) {
+      throw new Error("Refusing to delete without --yes");
+    }
+    const result = await apiRequest("DELETE", `/v1/dbs/${opts.id}`);
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`Deleted DB ${result.id}`);
+    }
+  });
+
+dbCommand
+  .command("link")
+  .description("Link a DB to a service via env var")
+  .requiredOption("--db-id <id>", "Database id")
+  .requiredOption("--service <service>", "Service name")
+  .requiredOption("--env-var <envVar>", "Environment variable name")
+  .option("--json", "Output JSON", false)
+  .action(async (opts) => {
+    const body = {
+      service: opts.service,
+      envVar: opts["env-var"],
+    };
+
+    const result = await apiRequest(
+      "POST",
+      `/v1/dbs/${opts["db-id"]}/link-service`,
+      body
+    );
+
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(
+        `Linked DB ${result.dbId} to service ${result.service} as ${result.envVar}`
+      );
+    }
+  });
+
+
+
+
+

package/cli/src/subcommands/dev.ts

@@ -0,0 +1,86 @@
+import { Command } from "commander";
+import { spawn } from "child_process";
+import { apiRequest } from "../http";
+import path from "path";
+
+export const devCommand = new Command("dev")
+  .description("Run local dev with optional tunnel")
+  .option("--tunnel", "Enable tunnel")
+  .option("--port <port>", "Local port to expose", "3000")
+  .option("--json", "Output JSON", false)
+  .option("--improved", "Use improved client with auto-reconnect and better error handling", false)
+  .action(async (opts) => {
+    const port = Number(opts.port);
+    if (opts.tunnel) {
+      // Request tunnel from control plane
+      const result = await apiRequest("POST", "/v1/tunnels", { port });
+      if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(`Tunnel URL: ${result.url}`);
+        // If the control-plane returns an https URL for the dev.uplink.spot domain,
+        // it may not actually be reachable unless TLS is configured on the relay.
+        // Print an HTTP fallback to reduce confusion during development.
+        if (
+          typeof result.url === "string" &&
+          result.url.startsWith("https://") &&
+          result.url.includes(".dev.uplink.spot")
+        ) {
+          console.log(`HTTP URL (if HTTPS not enabled): ${result.url.replace(/^https:\/\//, "http://")}`);
+        }
+      }
+
+      // Spawn tunnel client (use improved version if requested)
+      const clientFile = opts.improved ? "client-improved.js" : "client.js";
+      const clientPath = path.join(
+        process.cwd(),
+        "scripts",
+        "tunnel",
+        clientFile
+      );
+      const ctrlHost = process.env.TUNNEL_CTRL ?? "127.0.0.1:7071";
+      const args = [
+        clientPath,
+        "--token",
+        result.token,
+        "--port",
+        String(port),
+        "--ctrl",
+        ctrlHost,
+      ];
+      console.log(`Starting tunnel client: node ${args.join(" ")}`);
+      const child = spawn("node", args, { stdio: "inherit" });
+
+      // Forward Ctrl+C / termination to the child so the tunnel shuts down cleanly.
+      const shutdown = () => {
+        try {
+          child.kill("SIGINT");
+        } catch {
+          /* ignore */
+        }
+      };
+      process.on("SIGINT", shutdown);
+      process.on("SIGTERM", shutdown);
+
+      // Keep the CLI process alive while the tunnel client is running.
+      await new Promise<void>((resolve) => {
+        child.on("exit", (code, signal) => {
+          process.off("SIGINT", shutdown);
+          process.off("SIGTERM", shutdown);
+
+          if (signal) {
+            console.error(`Tunnel client exited due to signal ${signal}`);
+            process.exitCode = 1;
+          } else if (code && code !== 0) {
+            console.error(`Tunnel client exited with code ${code}`);
+            process.exitCode = code;
+          }
+          resolve();
+        });
+      });
+    } else {
+      console.log("Tunnel not enabled. Provide --tunnel to expose localhost.");
+    }
+  });
+
+