relight-cli 0.1.0 → 0.3.0

package/src/commands/logs.js

@@ -0,0 +1,111 @@
+import { fatal, fmt } from "../lib/output.js";
+import { resolveAppName } from "../lib/link.js";
+import { resolveTarget } from "../lib/providers/resolve.js";
+import kleur from "kleur";
+
+export async function logs(name, options) {
+  name = resolveAppName(name);
+  var target = await resolveTarget(options);
+  var cfg = target.cfg;
+  var appProvider = await target.provider("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 { resolveTarget } from "../lib/providers/resolve.js";
+
+export async function open(name, options) {
+  name = resolveAppName(name);
+  var target = await resolveTarget(options);
+  var cfg = target.cfg;
+  var appProvider = await target.provider("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 { resolveTarget } from "../lib/providers/resolve.js";
+import kleur from "kleur";
+
+export async function ps(name, options) {
+  name = resolveAppName(name);
+  var target = await resolveTarget(options);
+  var cfg = target.cfg;
+  var appProvider = await target.provider("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 { resolveTarget } from "../lib/providers/resolve.js";
+
+export async function scale(name, options) {
+  name = resolveAppName(name);
+  var target = await resolveTarget(options);
+  var cfg = target.cfg;
+  var appProvider = await target.provider("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`);
+  }
+}

package/src/commands/service.js

@@ -0,0 +1,227 @@
+import { createInterface } from "readline";
+import { success, fatal, fmt, table } from "../lib/output.js";
+import {
+  SERVICE_TYPES,
+  getRegisteredServices,
+  saveServiceConfig,
+  removeServiceConfig,
+  normalizeServiceConfig,
+  tryGetServiceConfig,
+} from "../lib/config.js";
+import { verifyConnection } from "../lib/clouds/slicervm.js";
+import { verifyApiKey } from "../lib/clouds/neon.js";
+import kleur from "kleur";
+
+function prompt(rl, question) {
+  return new Promise((resolve) => rl.question(question, resolve));
+}
+
+export async function serviceList() {
+  var services = getRegisteredServices();
+
+  if (services.length === 0) {
+    process.stderr.write("No services registered.\n");
+    process.stderr.write(
+      `\n${fmt.dim("Hint:")} ${fmt.cmd("relight service add")} to register one.\n`
+    );
+    return;
+  }
+
+  var headers = ["NAME", "LAYER", "TYPE", "ENDPOINT"];
+  var rows = services.map((a) => [
+    fmt.bold(a.name),
+    a.layer,
+    SERVICE_TYPES[a.type]?.name || a.type,
+    a.socketPath || a.apiUrl || (a.type === "neon" ? "console.neon.tech" : "-"),
+  ]);
+
+  console.log(table(headers, rows));
+}
+
+export async function serviceAdd(name) {
+  var rl = createInterface({ input: process.stdin, output: process.stderr });
+
+  // 1. Pick layer
+  var layers = ["compute", "db"];
+  process.stderr.write(`\n${kleur.bold("Register a service")}\n\n`);
+  process.stderr.write(`  ${kleur.bold("Layer:")}\n\n`);
+  for (var i = 0; i < layers.length; i++) {
+    process.stderr.write(`  ${kleur.bold(`[${i + 1}]`)} ${layers[i]}\n`);
+  }
+  process.stderr.write("\n");
+
+  var layerChoice = await prompt(rl, `Select layer [1-${layers.length}]: `);
+  var layerIdx = parseInt(layerChoice, 10) - 1;
+  if (isNaN(layerIdx) || layerIdx < 0 || layerIdx >= layers.length) {
+    rl.close();
+    fatal("Invalid selection.");
+  }
+  var layer = layers[layerIdx];
+
+  // 2. Pick type (contextual to layer)
+  var types = Object.entries(SERVICE_TYPES)
+    .filter(([, v]) => v.layer === layer)
+    .map(([id, v]) => ({ id, name: v.name }));
+
+  process.stderr.write(`\n  ${kleur.bold("Type:")}\n\n`);
+  for (var i = 0; i < types.length; i++) {
+    process.stderr.write(
+      `  ${kleur.bold(`[${i + 1}]`)} ${types[i].name}\n`
+    );
+  }
+  process.stderr.write("\n");
+
+  var typeChoice = await prompt(rl, `Select type [1-${types.length}]: `);
+  var typeIdx = parseInt(typeChoice, 10) - 1;
+  if (isNaN(typeIdx) || typeIdx < 0 || typeIdx >= types.length) {
+    rl.close();
+    fatal("Invalid selection.");
+  }
+  var serviceType = types[typeIdx].id;
+
+  // 3. Connection details (SlicerVM-specific)
+  var config = { layer, type: serviceType };
+
+  if (serviceType === "slicervm") {
+    process.stderr.write(`\n  ${kleur.bold("Connection mode")}\n\n`);
+    process.stderr.write(`  ${kleur.bold("[1]")} Unix socket (local dev)\n`);
+    process.stderr.write(`  ${kleur.bold("[2]")} HTTP API (remote)\n\n`);
+
+    var modeChoice = await prompt(rl, "Select [1-2]: ");
+    var useSocket = modeChoice.trim() === "1";
+
+    if (useSocket) {
+      var defaultSocket = "/var/run/slicer/slicer.sock";
+      var socketPath = await prompt(rl, `Socket path [${defaultSocket}]: `);
+      socketPath = (socketPath || "").trim() || defaultSocket;
+      config.socketPath = socketPath;
+    } else {
+      var apiUrl = await prompt(
+        rl,
+        "Slicer API URL (e.g. https://slicer.example.com:8080): "
+      );
+      apiUrl = (apiUrl || "").trim().replace(/\/+$/, "");
+      if (!apiUrl) {
+        rl.close();
+        fatal("No API URL provided.");
+      }
+      config.apiUrl = apiUrl;
+
+      var token = await prompt(rl, "API token: ");
+      token = (token || "").trim();
+      if (!token) {
+        rl.close();
+        fatal("No token provided.");
+      }
+      config.token = token;
+    }
+
+    var hostGroup = await prompt(rl, "Host group [apps]: ");
+    config.hostGroup = (hostGroup || "").trim() || "apps";
+
+    var baseDomain = await prompt(
+      rl,
+      "Base domain (e.g. apps.example.com) [localhost]: "
+    );
+    config.baseDomain = (baseDomain || "").trim() || "localhost";
+
+    // 4. Verify connection
+    process.stderr.write("\nVerifying...\n");
+    var verifyCfg = normalizeServiceConfig(config);
+    try {
+      await verifyConnection(verifyCfg);
+    } catch (e) {
+      rl.close();
+      fatal("Connection failed.", e.message);
+    }
+
+    if (useSocket) {
+      process.stderr.write(`  Socket: ${fmt.bold(config.socketPath)}\n`);
+    } else {
+      process.stderr.write(`  API: ${fmt.bold(config.apiUrl)}\n`);
+    }
+    process.stderr.write(`  Host group: ${fmt.dim(config.hostGroup)}\n`);
+    process.stderr.write(`  Base domain: ${fmt.dim(config.baseDomain)}\n`);
+  } else if (serviceType === "neon") {
+    process.stderr.write(`\n  ${kleur.bold("Neon API key")}\n\n`);
+    process.stderr.write(
+      `  ${fmt.dim("Get your API key at https://console.neon.tech/app/settings/api-keys")}\n\n`
+    );
+
+    var apiKey = await prompt(rl, "API key: ");
+    apiKey = (apiKey || "").trim();
+    if (!apiKey) {
+      rl.close();
+      fatal("No API key provided.");
+    }
+    config.apiKey = apiKey;
+
+    // Verify connection
+    process.stderr.write("\nVerifying...\n");
+    try {
+      var projects = await verifyApiKey(apiKey);
+      process.stderr.write(
+        `  Authenticated. ${projects.length} existing project${projects.length === 1 ? "" : "s"}.\n`
+      );
+    } catch (e) {
+      rl.close();
+      fatal("Authentication failed.", e.message);
+    }
+  }
+
+  // 5. Auto-name if not provided
+  if (!name) {
+    var existing = getRegisteredServices().filter((a) => a.type === serviceType);
+    if (existing.length === 0) {
+      name = serviceType;
+    } else {
+      name = `${serviceType}-${existing.length + 1}`;
+    }
+    var inputName = await prompt(rl, `Service name [${name}]: `);
+    name = (inputName || "").trim() || name;
+  }
+
+  // Check for existing
+  if (tryGetServiceConfig(name)) {
+    var overwrite = await prompt(
+      rl,
+      `Service '${name}' already exists. Overwrite? [y/N] `
+    );
+    if (!overwrite.match(/^y(es)?$/i)) {
+      rl.close();
+      process.stderr.write("Cancelled.\n");
+      process.exit(0);
+    }
+  }
+
+  rl.close();
+
+  // 6. Save
+  saveServiceConfig(name, config);
+
+  success(`Service ${fmt.bold(name)} registered!`);
+}
+
+export async function serviceRemove(name) {
+  if (!name) {
+    fatal("Usage: relight service remove <name>");
+  }
+
+  if (!tryGetServiceConfig(name)) {
+    fatal(`Service '${name}' not found.`);
+  }
+
+  var rl = createInterface({ input: process.stdin, output: process.stderr });
+  var answer = await new Promise((resolve) =>
+    rl.question(`Remove service '${name}'? [y/N] `, resolve)
+  );
+  rl.close();
+
+  if (!answer.match(/^y(es)?$/i)) {
+    process.stderr.write("Cancelled.\n");
+    return;
+  }
+
+  removeServiceConfig(name);
+  success(`Service ${fmt.bold(name)} removed.`);
+}