relight-cli 0.1.0 → 0.2.0

package/src/lib/clouds/slicervm.js

@@ -0,0 +1,139 @@
+// SlicerVM API client
+// Supports two connection modes:
+// - Unix socket: cfg.socketPath (local dev, no auth)
+// - HTTP: cfg.apiUrl + cfg.apiToken (remote, bearer token auth)
+
+import http from "node:http";
+
+function socketRequest(socketPath, method, path, body, headers) {
+  return new Promise((resolve, reject) => {
+    var opts = { socketPath, method, path, headers: headers || {} };
+    var req = http.request(opts, (res) => {
+      var chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => {
+        resolve({
+          ok: res.statusCode >= 200 && res.statusCode < 300,
+          status: res.statusCode,
+          headers: res.headers,
+          text: () => Promise.resolve(Buffer.concat(chunks).toString()),
+          json: () => Promise.resolve(JSON.parse(Buffer.concat(chunks).toString())),
+          body: null,
+        });
+      });
+    });
+    req.on("error", reject);
+    if (body) req.write(body);
+    req.end();
+  });
+}
+
+export async function slicerFetch(cfg, method, path, body, opts = {}) {
+  var headers = {};
+
+  if (cfg.apiToken) {
+    headers.Authorization = `Bearer ${cfg.apiToken}`;
+  }
+
+  var rawBody = body;
+  if (opts.contentType) {
+    headers["Content-Type"] = opts.contentType;
+  } else if (body && typeof body === "object" && !Buffer.isBuffer(body)) {
+    headers["Content-Type"] = "application/json";
+    rawBody = JSON.stringify(body);
+  }
+
+  var res;
+  if (cfg.socketPath) {
+    res = await socketRequest(cfg.socketPath, method, path, method === "GET" ? undefined : rawBody, headers);
+  } else {
+    res = await fetch(`${cfg.apiUrl}${path}`, {
+      method,
+      headers,
+      body: method === "GET" ? undefined : rawBody,
+    });
+  }
+
+  if (!res.ok) {
+    var text = await res.text();
+    throw new Error(`Slicer API ${method} ${path}: ${res.status} ${text}`);
+  }
+
+  var ct = (res.headers instanceof Headers)
+    ? res.headers.get("content-type") || ""
+    : res.headers["content-type"] || "";
+
+  if (ct.includes("application/json")) {
+    return res.json();
+  }
+  if (opts.stream) {
+    return res;
+  }
+  return res.text();
+}
+
+// --- Nodes ---
+
+export async function listNodes(cfg) {
+  return slicerFetch(cfg, "GET", "/nodes");
+}
+
+export async function createNode(cfg, hostGroup, opts = {}) {
+  return slicerFetch(cfg, "POST", `/hostgroup/${hostGroup}/nodes`, {
+    tags: opts.tags || [],
+    vcpu: opts.vcpu,
+    memory: opts.memory,
+  });
+}
+
+export async function deleteNode(cfg, hostGroup, hostname) {
+  return slicerFetch(cfg, "DELETE", `/hostgroup/${hostGroup}/nodes/${hostname}`);
+}
+
+// --- VM lifecycle ---
+
+export async function resumeVM(cfg, hostname) {
+  return slicerFetch(cfg, "POST", `/vm/${hostname}/resume`);
+}
+
+export async function pauseVM(cfg, hostname) {
+  return slicerFetch(cfg, "POST", `/vm/${hostname}/pause`);
+}
+
+export async function healthCheck(cfg, hostname) {
+  return slicerFetch(cfg, "GET", `/vm/${hostname}/health`);
+}
+
+// --- Exec ---
+
+export async function execInVM(cfg, hostname, cmd, args, opts = {}) {
+  var qs = new URLSearchParams();
+  qs.set("cmd", cmd);
+  for (var arg of (args || [])) {
+    qs.append("args", arg);
+  }
+  if (opts.uid !== undefined) qs.set("uid", String(opts.uid));
+  if (opts.gid !== undefined) qs.set("gid", String(opts.gid));
+  if (opts.workdir) qs.set("cwd", opts.workdir);
+  return slicerFetch(cfg, "POST", `/vm/${hostname}/exec?${qs}`, null, {
+    stream: opts.stream,
+  });
+}
+
+// --- File upload ---
+
+export async function uploadToVM(cfg, hostname, path, tarBuffer, opts = {}) {
+  var qs = new URLSearchParams({ path });
+  if (opts.uid !== undefined) qs.set("uid", String(opts.uid));
+  if (opts.gid !== undefined) qs.set("gid", String(opts.gid));
+  if (opts.mode) qs.set("mode", opts.mode);
+  return slicerFetch(cfg, "POST", `/vm/${hostname}/cp?${qs}`, tarBuffer, {
+    contentType: "application/x-tar",
+  });
+}
+
+// --- Auth verification ---
+
+export async function verifyConnection(cfg) {
+  return listNodes(cfg);
+}

package/src/lib/config.js

@@ -11,6 +11,7 @@ export var CLOUD_NAMES = {
   cf: "Cloudflare",
   gcp: "GCP",
   aws: "AWS",
+  slicervm: "SlicerVM",
 };
 
 export var CLOUD_IDS = Object.keys(CLOUD_NAMES);
@@ -56,3 +57,42 @@ export function getAuthenticatedClouds() {
     (id) => config.clouds[id] && Object.keys(config.clouds[id]).length > 0
   );
 }
+
+export function getDefaultCloud() {
+  var config = tryGetConfig();
+  if (!config) return null;
+  return config.default_cloud || null;
+}
+
+export function resolveCloudConfig(cloudId) {
+  var config = getConfig();
+  var cloud = config.clouds && config.clouds[cloudId];
+  if (!cloud) {
+    console.error(
+      `Not authenticated with ${CLOUD_NAMES[cloudId] || cloudId}. Run \`relight auth --cloud ${cloudId}\` first.`
+    );
+    process.exit(1);
+  }
+
+  // Return a normalized config object that providers can use
+  if (cloudId === "cf") {
+    return { accountId: cloud.accountId, apiToken: cloud.token };
+  }
+  if (cloudId === "gcp") {
+    return { clientEmail: cloud.clientEmail, privateKey: cloud.privateKey, project: cloud.project };
+  }
+  if (cloudId === "aws") {
+    return { accessKeyId: cloud.accessKeyId, secretAccessKey: cloud.secretAccessKey, region: cloud.region };
+  }
+  if (cloudId === "slicervm") {
+    var slicerCfg = { hostGroup: cloud.hostGroup, baseDomain: cloud.baseDomain };
+    if (cloud.socketPath) {
+      slicerCfg.socketPath = cloud.socketPath;
+    } else {
+      slicerCfg.apiUrl = cloud.apiUrl;
+      slicerCfg.apiToken = cloud.token;
+    }
+    return slicerCfg;
+  }
+  return cloud;
+}

package/src/lib/docker.js

@@ -0,0 +1,34 @@
+import { execSync } from "child_process";
+
+function ensureDocker() {
+  try {
+    execSync("docker version", { stdio: "pipe" });
+  } catch {
+    console.error("Docker is not running. Install and start Docker first.");
+    process.exit(1);
+  }
+}
+
+export function dockerBuild(contextPath, tag, opts = {}) {
+  ensureDocker();
+  var platform = opts.platform || "linux/amd64";
+  execSync(
+    `docker build --platform ${platform} --provenance=false -t ${tag} ${contextPath}`,
+    { stdio: "pipe" }
+  );
+}
+
+export function dockerTag(source, target) {
+  execSync(`docker tag ${source} ${target}`, { stdio: "pipe" });
+}
+
+export function dockerPush(tag) {
+  execSync(`docker push ${tag}`, { stdio: "pipe" });
+}
+
+export function dockerLogin(registry, username, password) {
+  execSync(
+    `docker login --password-stdin --username ${username} ${registry}`,
+    { input: password, stdio: "pipe" }
+  );
+}

package/src/lib/link.js

@@ -1,19 +1,24 @@
 import { readFileSync, writeFileSync, unlinkSync } from "fs";
+import YAML from "yaml";
 import { fatal, fmt } from "./output.js";
 
-var LINK_FILE = ".relight";
+var LINK_FILE = ".relight.yaml";
 
 export function readLink() {
   try {
-    var data = JSON.parse(readFileSync(LINK_FILE, "utf-8"));
-    return data;
+    var raw = readFileSync(LINK_FILE, "utf-8");
+    // Support both YAML and legacy JSON
+    return YAML.parse(raw);
   } catch {
     return null;
   }
 }
 
-export function linkApp(name, cloud) {
-  writeFileSync(LINK_FILE, JSON.stringify({ app: name, cloud }) + "\n");
+export function linkApp(name, cloud, dns, db) {
+  var data = { app: name, cloud };
+  if (dns && dns !== cloud) data.dns = dns;
+  if (db && db !== cloud) data.db = db;
+  writeFileSync(LINK_FILE, YAML.stringify(data));
 }
 
 export function unlinkApp() {
@@ -38,3 +43,13 @@ export function resolveCloud(cloud) {
   if (linked && linked.cloud) return linked.cloud;
   return null;
 }
+
+export function resolveDns() {
+  var linked = readLink();
+  return linked?.dns || null;
+}
+
+export function resolveDb() {
+  var linked = readLink();
+  return linked?.db || null;
+}