relight-cli 0.1.0 → 0.2.0

package/src/commands/logs.js

@@ -0,0 +1,111 @@
+import { fatal, fmt } from "../lib/output.js";
+import { resolveAppName } from "../lib/link.js";
+import { resolveCloudId, getCloudCfg, getProvider } from "../lib/providers/resolve.js";
+import kleur from "kleur";
+
+export async function logs(name, options) {
+  name = resolveAppName(name);
+  var cloud = resolveCloudId(options.cloud);
+  var cfg = getCloudCfg(cloud);
+  var appProvider = await getProvider(cloud, "app");
+
+  process.stderr.write(
+    `Tailing logs for ${fmt.app(name)}... ${fmt.dim("(ctrl+c to stop)")}\n\n`
+  );
+
+  var tail;
+  try {
+    tail = await appProvider.streamLogs(cfg, name);
+  } catch (e) {
+    fatal(
+      `Could not start log tail for ${fmt.app(name)}.`,
+      e.message
+    );
+  }
+
+  // Non-WebSocket path (GCP polling)
+  if (!tail.url) {
+    process.on("SIGINT", async function () {
+      process.stderr.write(`\n${fmt.dim("Stopping tail...")}\n`);
+      await tail.cleanup();
+      process.exit(0);
+    });
+    // Keep process alive while polling happens in the background
+    await new Promise(() => {});
+    return;
+  }
+
+  // WebSocket path (Cloudflare)
+  var ws = new WebSocket(tail.url, "trace-v1");
+
+  ws.addEventListener("open", function () {
+    ws.send(JSON.stringify({}));
+  });
+
+  ws.addEventListener("message", async function (event) {
+    var raw = typeof event.data === "string" ? event.data : await event.data.text();
+    var data = JSON.parse(raw);
+
+    for (var evt of Array.isArray(data) ? data : [data]) {
+      var ts = evt.eventTimestamp
+        ? new Date(evt.eventTimestamp).toISOString()
+        : new Date().toISOString();
+      var method = evt.event?.request?.method || "";
+      var url = evt.event?.request?.url || "";
+      var statusCode = evt.event?.response?.status || "";
+      var outcome = evt.outcome || "";
+
+      if (method) {
+        var statusColor =
+          statusCode >= 500
+            ? kleur.red(statusCode)
+            : statusCode >= 400
+              ? kleur.yellow(statusCode)
+              : kleur.green(statusCode);
+        console.log(
+          `${kleur.dim(ts)}  ${kleur.bold(method)} ${url} ${statusColor} ${kleur.dim(`[${outcome}]`)}`
+        );
+      }
+
+      if (evt.logs) {
+        for (var log of evt.logs) {
+          var level = log.level || "log";
+          var msg = (log.message || []).join(" ");
+          var levelColor =
+            level === "error"
+              ? kleur.red(`[${level}]`)
+              : level === "warn"
+                ? kleur.yellow(`[${level}]`)
+                : kleur.dim(`[${level}]`);
+          console.log(`${kleur.dim(ts)}  ${levelColor} ${msg}`);
+        }
+      }
+
+      if (evt.exceptions) {
+        for (var ex of evt.exceptions) {
+          console.error(
+            `${kleur.dim(ts)}  ${kleur.red("[exception]")} ${ex.name}: ${ex.message}`
+          );
+        }
+      }
+    }
+  });
+
+  ws.addEventListener("error", function (event) {
+    process.stderr.write(
+      `${kleur.red("WebSocket error:")} ${event.message || "connection failed"}\n`
+    );
+  });
+
+  ws.addEventListener("close", function () {
+    process.stderr.write(`\n${fmt.dim("Tail disconnected.")}\n`);
+    process.exit(0);
+  });
+
+  process.on("SIGINT", async function () {
+    process.stderr.write(`\n${fmt.dim("Stopping tail...")}\n`);
+    ws.close();
+    await tail.cleanup();
+    process.exit(0);
+  });
+}

package/src/commands/open.js

@@ -0,0 +1,42 @@
+import { execSync } from "child_process";
+import { platform } from "os";
+import { fatal, fmt } from "../lib/output.js";
+import { resolveAppName } from "../lib/link.js";
+import { resolveCloudId, getCloudCfg, getProvider } from "../lib/providers/resolve.js";
+
+export async function open(name, options) {
+  name = resolveAppName(name);
+  var cloud = resolveCloudId(options.cloud);
+  var cfg = getCloudCfg(cloud);
+  var appProvider = await getProvider(cloud, "app");
+
+  var url = await appProvider.getAppUrl(cfg, name);
+
+  if (!url) {
+    fatal(
+      "Could not resolve app URL.",
+      "Ensure your app is deployed and has a URL configured."
+    );
+  }
+
+  process.stderr.write(`Opening ${fmt.url(url)}...\n`);
+
+  var cmd;
+  switch (platform()) {
+    case "darwin":
+      cmd = "open";
+      break;
+    case "win32":
+      cmd = "start";
+      break;
+    default:
+      cmd = "xdg-open";
+      break;
+  }
+
+  try {
+    execSync(`${cmd} "${url}"`, { stdio: "ignore" });
+  } catch {
+    console.log(url);
+  }
+}

package/src/commands/ps.js

@@ -0,0 +1,121 @@
+import { fatal, fmt, table } from "../lib/output.js";
+import { resolveAppName } from "../lib/link.js";
+import { resolveCloudId, getCloudCfg, getProvider } from "../lib/providers/resolve.js";
+import kleur from "kleur";
+
+export async function ps(name, options) {
+  name = resolveAppName(name);
+  var cloud = resolveCloudId(options.cloud);
+  var cfg = getCloudCfg(cloud);
+  var appProvider = await getProvider(cloud, "app");
+
+  var appConfig = await appProvider.getAppConfig(cfg, name);
+
+  if (!appConfig) {
+    fatal(
+      `App ${fmt.app(name)} not found.`,
+      `Run ${fmt.cmd(`relight deploy ${name} .`)} first.`
+    );
+  }
+
+  var instances = appConfig.instances || 2;
+
+  // Fetch live metrics
+  var metrics = await appProvider.getContainerStatus(cfg, name);
+
+  // Aggregate: group by region + durableObjectId, keep only active instances
+  var containers = [];
+  for (var row of metrics) {
+    var dim = row.dimensions;
+    if (!dim.active) continue;
+    var existing = containers.find(
+      (c) => c.region === dim.region && c.doId === dim.durableObjectId
+    );
+    if (existing) {
+      existing.cpuSamples++;
+      existing.cpuLoad += row.avg?.cpuLoad || 0;
+      existing.memory += row.avg?.memory || 0;
+    } else {
+      containers.push({
+        region: dim.region,
+        doId: dim.durableObjectId,
+        cpuLoad: row.avg?.cpuLoad || 0,
+        memory: row.avg?.memory || 0,
+        cpuSamples: 1,
+      });
+    }
+  }
+  for (var c of containers) {
+    c.cpuLoad = c.cpuLoad / c.cpuSamples;
+    c.memory = c.memory / c.cpuSamples;
+  }
+  containers.sort((a, b) => a.region.localeCompare(b.region) || a.doId.localeCompare(b.doId));
+
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          name,
+          image: appConfig.image,
+          regions: appConfig.regions,
+          instances,
+          containers: containers.map((c) => ({
+            region: c.region,
+            id: c.doId,
+            cpu: +(c.cpuLoad * 100).toFixed(1),
+            memoryMiB: +(c.memory / 1024 / 1024).toFixed(0),
+          })),
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+
+  var url = await appProvider.getAppUrl(cfg, name);
+  var customDomains = appConfig.domains || [];
+
+  console.log("");
+  console.log(`${fmt.bold("App:")}        ${fmt.app(name)}`);
+  if (customDomains.length > 0) {
+    console.log(`${fmt.bold("URL:")}        ${fmt.url(`https://${customDomains[0]}`)}`);
+    for (var d of customDomains.slice(1)) {
+      console.log(`             ${fmt.url(`https://${d}`)}`);
+    }
+    if (url) {
+      console.log(`             ${fmt.dim(url)}`);
+    }
+  } else if (url) {
+    console.log(`${fmt.bold("URL:")}        ${fmt.url(url)}`);
+  }
+  console.log(
+    `${fmt.bold("Image:")}      ${appConfig.image || fmt.dim("(not deployed)")}`
+  );
+  console.log(`${fmt.bold("Regions:")}    ${appConfig.regions.join(", ")}`);
+  console.log(`${fmt.bold("Instances:")}  ${instances} per region`);
+
+  if (appConfig.deployedAt) {
+    console.log(`${fmt.bold("Deployed:")}   ${appConfig.deployedAt}`);
+  }
+
+  console.log(`\n${fmt.bold("Containers:")}`);
+
+  if (containers.length > 0) {
+    var headers = ["", "REGION", "ID", "CPU", "MEMORY"];
+    var rows = containers.map((c) => [
+      kleur.green("*"),
+      c.region,
+      c.doId.slice(0, 8),
+      (c.cpuLoad * 100).toFixed(1) + "%",
+      (c.memory / 1024 / 1024).toFixed(0) + " MiB",
+    ]);
+    console.log(table(headers, rows));
+  } else {
+    console.log(fmt.dim("  No active containers (app may be sleeping)"));
+  }
+
+  console.log(
+    `\n${fmt.dim("Metrics from the last 15 minutes. Expect some delay in reporting.")}`
+  );
+}

package/src/commands/scale.js

@@ -0,0 +1,132 @@
+import { success, fatal, fmt } from "../lib/output.js";
+import { resolveAppName } from "../lib/link.js";
+import { resolveCloudId, getCloudCfg, getProvider } from "../lib/providers/resolve.js";
+
+export async function scale(name, options) {
+  name = resolveAppName(name);
+  var cloud = resolveCloudId(options.cloud);
+  var cfg = getCloudCfg(cloud);
+  var appProvider = await getProvider(cloud, "app");
+
+  var appConfig = await appProvider.getAppConfig(cfg, name);
+
+  if (!appConfig) {
+    fatal(
+      `App ${fmt.app(name)} not found.`,
+      `Run ${fmt.cmd(`relight deploy ${name} .`)} first.`
+    );
+  }
+
+  var changed = false;
+
+  if (options.regions) {
+    var validRegions = appProvider.getRegions();
+    var validCodes = validRegions.map((r) => r.code);
+    var regions = options.regions.split(",").map((r) => r.trim().toLowerCase());
+    for (var r of regions) {
+      if (!validCodes.includes(r)) {
+        fatal(
+          `Invalid location hint '${r}'.`,
+          `Valid hints: ${validCodes.join(", ")}`
+        );
+      }
+    }
+    appConfig.regions = regions;
+    changed = true;
+  }
+
+  if (options.instances) {
+    appConfig.instances = options.instances;
+    changed = true;
+  }
+
+  if (options.instanceType) {
+    appConfig.instanceType = options.instanceType;
+    delete appConfig.vcpu;
+    delete appConfig.memory;
+    delete appConfig.disk;
+    changed = true;
+  }
+  if (options.vcpu) {
+    appConfig.vcpu = options.vcpu;
+    delete appConfig.instanceType;
+    changed = true;
+  }
+  if (options.memory) {
+    appConfig.memory = options.memory;
+    delete appConfig.instanceType;
+    changed = true;
+  }
+  if (options.disk) {
+    appConfig.disk = options.disk;
+    delete appConfig.instanceType;
+    changed = true;
+  }
+
+  if (!changed) {
+    // Show current scale
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            regions: appConfig.regions,
+            instances: appConfig.instances,
+            instanceType: appConfig.instanceType,
+            vcpu: appConfig.vcpu,
+            memory: appConfig.memory,
+            disk: appConfig.disk,
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+
+    console.log(`\n${fmt.bold("App:")}        ${fmt.app(name)}`);
+    console.log(`${fmt.bold("Regions:")}    ${appConfig.regions.join(", ")}`);
+    console.log(`${fmt.bold("Instances:")}  ${appConfig.instances} per region`);
+    if (appConfig.vcpu || appConfig.memory || appConfig.disk) {
+      if (appConfig.vcpu) console.log(`${fmt.bold("vCPU:")}       ${appConfig.vcpu}`);
+      if (appConfig.memory) console.log(`${fmt.bold("Memory:")}     ${appConfig.memory} MiB`);
+      if (appConfig.disk) console.log(`${fmt.bold("Disk:")}       ${appConfig.disk} MB`);
+    } else {
+      console.log(`${fmt.bold("Type:")}       ${appConfig.instanceType || "lite"}`);
+    }
+    console.log(
+      `\n${fmt.dim("Geo-routing is automatic - requests route to the closest deployed region.")}`
+    );
+    return;
+  }
+
+  await appProvider.scale(cfg, name, { appConfig });
+
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          regions: appConfig.regions,
+          instances: appConfig.instances,
+          instanceType: appConfig.instanceType,
+          vcpu: appConfig.vcpu,
+          memory: appConfig.memory,
+          disk: appConfig.disk,
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+
+  success(`Scaled ${fmt.app(name)} (live).`);
+  process.stderr.write(`  Regions:    ${appConfig.regions.join(", ")}\n`);
+  process.stderr.write(`  Instances:  ${appConfig.instances}\n`);
+  if (appConfig.vcpu || appConfig.memory || appConfig.disk) {
+    if (appConfig.vcpu) process.stderr.write(`  vCPU:       ${appConfig.vcpu}\n`);
+    if (appConfig.memory) process.stderr.write(`  Memory:     ${appConfig.memory} MiB\n`);
+    if (appConfig.disk) process.stderr.write(`  Disk:       ${appConfig.disk} MB\n`);
+  } else {
+    process.stderr.write(`  Type:       ${appConfig.instanceType || "lite"}\n`);
+  }
+}