svamp-cli 0.1.48 → 0.1.49

package/dist/commands-DlPBC5p0.mjs

@@ -0,0 +1,514 @@
+function getSandboxEnv() {
+  return {
+    apiUrl: process.env.SANDBOX_API_URL || "",
+    apiKey: process.env.SANDBOX_API_KEY || "",
+    namespace: process.env.SANDBOX_NAMESPACE || "",
+    sandboxId: process.env.SANDBOX_ID || ""
+  };
+}
+function requireSandboxEnv() {
+  const env = getSandboxEnv();
+  if (!env.apiUrl) {
+    throw new Error(
+      "SANDBOX_API_URL is not set. Service commands require a sandbox environment.\nThis is normally set by the Svamp provisioner when running in a cloud machine."
+    );
+  }
+  if (!env.apiKey) {
+    throw new Error("SANDBOX_API_KEY is not set.");
+  }
+  if (!env.namespace) {
+    throw new Error("SANDBOX_NAMESPACE is not set.");
+  }
+  return env;
+}
+function requireSandboxApiEnv() {
+  const env = getSandboxEnv();
+  if (!env.apiUrl) {
+    throw new Error(
+      "SANDBOX_API_URL is not set. Set it via environment variable or `svamp service config`."
+    );
+  }
+  if (!env.apiKey) {
+    throw new Error("SANDBOX_API_KEY is not set.");
+  }
+  return env;
+}
+async function sandboxFetch(env, path, init) {
+  const url = `${env.apiUrl.replace(/\/+$/, "")}${path}`;
+  const headers = {
+    "Authorization": `Bearer ${env.apiKey}`,
+    "Content-Type": "application/json",
+    ...init?.headers || {}
+  };
+  const res = await fetch(url, { ...init, headers });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    let detail = body;
+    try {
+      detail = JSON.parse(body).detail || body;
+    } catch {
+    }
+    throw new Error(`${res.status} ${res.statusText}: ${detail}`);
+  }
+  return res;
+}
+async function createServiceGroup(name, ports, options) {
+  const env = requireSandboxEnv();
+  const body = {};
+  if (ports.length === 1 && options?.subdomain) {
+    body.port = ports[0];
+    body.subdomain = options.subdomain;
+  } else {
+    body.ports = ports.map((p) => ({ port: p }));
+  }
+  if (options?.healthPath) {
+    body.health_path = options.healthPath;
+    if (options.healthInterval) {
+      body.health_interval = options.healthInterval;
+    }
+  }
+  const res = await sandboxFetch(env, `/services/${env.namespace}/${name}`, {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+  return res.json();
+}
+async function listServiceGroups() {
+  const env = requireSandboxEnv();
+  const res = await sandboxFetch(env, `/services/${env.namespace}`);
+  return res.json();
+}
+async function getServiceGroup(name) {
+  const env = requireSandboxEnv();
+  const res = await sandboxFetch(env, `/services/${env.namespace}/${name}`);
+  return res.json();
+}
+async function deleteServiceGroup(name) {
+  const env = requireSandboxEnv();
+  const res = await sandboxFetch(env, `/services/${env.namespace}/${name}`, {
+    method: "DELETE"
+  });
+  return res.json();
+}
+async function addPort(name, port, subdomain) {
+  const env = requireSandboxEnv();
+  const res = await sandboxFetch(env, `/services/${env.namespace}/${name}/ports`, {
+    method: "POST",
+    body: JSON.stringify({ port, subdomain })
+  });
+  return res.json();
+}
+async function removePort(name, port) {
+  const env = requireSandboxEnv();
+  const res = await sandboxFetch(env, `/services/${env.namespace}/${name}/ports/${port}`, {
+    method: "DELETE"
+  });
+  return res.json();
+}
+async function addBackend(name, sandboxId) {
+  const env = requireSandboxEnv();
+  const sid = sandboxId || env.sandboxId;
+  if (!sid) {
+    throw new Error(
+      "No sandbox ID provided and SANDBOX_ID is not set.\nUse --sandbox-id <id> to specify which sandbox to add."
+    );
+  }
+  const res = await sandboxFetch(env, `/services/${env.namespace}/${name}/backends`, {
+    method: "POST",
+    body: JSON.stringify({ sandbox_id: sid })
+  });
+  return res.json();
+}
+async function removeBackend(name, sandboxId) {
+  const env = requireSandboxEnv();
+  const sid = sandboxId || env.sandboxId;
+  if (!sid) {
+    throw new Error(
+      "No sandbox ID provided and SANDBOX_ID is not set.\nUse --sandbox-id <id> to specify which sandbox to remove."
+    );
+  }
+  const res = await sandboxFetch(env, `/services/${env.namespace}/${name}/backends/${sid}`, {
+    method: "DELETE"
+  });
+  return res.json();
+}
+
+function getFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : void 0;
+}
+function getAllFlags(args, flag) {
+  const values = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === flag && i + 1 < args.length) {
+      values.push(args[i + 1]);
+      i++;
+    }
+  }
+  return values;
+}
+function hasFlag(args, ...flags) {
+  return flags.some((f) => args.includes(f));
+}
+function positionalArgs(args) {
+  const result = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith("--")) {
+      if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+        i++;
+      }
+      continue;
+    }
+    result.push(args[i]);
+  }
+  return result;
+}
+function parsePorts(args) {
+  const portStrs = getAllFlags(args, "--port");
+  if (portStrs.length === 0) return [];
+  const ports = [];
+  for (const s of portStrs) {
+    const p = parseInt(s, 10);
+    if (isNaN(p) || p < 1 || p > 65535) {
+      console.error(`Error: invalid port '${s}' \u2014 must be 1-65535`);
+      process.exit(1);
+    }
+    ports.push(p);
+  }
+  return ports;
+}
+function printServiceGroupInfo(info) {
+  console.log(`Service group: ${info.name}`);
+  console.log(`  Namespace: ${info.namespace}`);
+  console.log(`  K8s svc:   ${info.k8s_service}`);
+  console.log(`  Created:   ${info.created_at}`);
+  if (info.health_path) {
+    console.log(`  Health:    ${info.health_path} (every ${info.health_interval}s)`);
+  }
+  console.log(`  Ports (${info.ports.length}):`);
+  for (const p of info.ports) {
+    console.log(`    ${p.port} \u2192 ${p.url}`);
+  }
+  console.log(`  Backends (${info.backends.length}):`);
+  for (const b of info.backends) {
+    const healthTag = b.healthy === false ? " [unhealthy]" : b.healthy === true ? "" : "";
+    const failInfo = b.consecutive_failures ? ` (${b.consecutive_failures} failures)` : "";
+    console.log(`    - ${b.sandbox_id} (${b.pod_ip})${healthTag}${failInfo}`);
+  }
+}
+function printServiceGroupListItem(g) {
+  console.log(`  ${g.name}`);
+  if (g.ports.length > 1) {
+    for (const p of g.ports) {
+      console.log(`    ${p.port} \u2192 ${p.url}`);
+    }
+  } else {
+    console.log(`    URL:  ${g.url}`);
+    console.log(`    Port: ${g.port}`);
+  }
+  console.log(`    Backends: ${g.backend_count}`);
+}
+async function serviceCreate(args) {
+  const positional = positionalArgs(args);
+  const name = positional[0];
+  const ports = parsePorts(args);
+  const subdomain = getFlag(args, "--subdomain");
+  const healthPath = getFlag(args, "--health-path");
+  const healthIntervalStr = getFlag(args, "--health-interval");
+  if (!name || ports.length === 0) {
+    console.error("Usage: svamp service create <name> --port <port> [--port <port2>] [--health-path <path>]");
+    process.exit(1);
+  }
+  const healthInterval = healthIntervalStr ? parseInt(healthIntervalStr, 10) : void 0;
+  try {
+    const result = await createServiceGroup(name, ports, {
+      subdomain,
+      healthPath,
+      healthInterval
+    });
+    console.log(`Service group created: ${result.name}`);
+    for (const p of result.ports) {
+      console.log(`  ${p.port} \u2192 ${p.url}`);
+    }
+    console.log(`  K8s svc:  ${result.k8s_service}`);
+    console.log(`  Backends: ${result.backends.length}`);
+  } catch (err) {
+    console.error(`Error creating service group: ${err.message}`);
+    process.exit(1);
+  }
+}
+async function serviceList(args) {
+  const jsonOutput = hasFlag(args, "--json");
+  try {
+    const groups = await listServiceGroups();
+    if (jsonOutput) {
+      console.log(JSON.stringify(groups, null, 2));
+      return;
+    }
+    if (groups.length === 0) {
+      console.log("No service groups found.");
+      return;
+    }
+    console.log(`Service groups (${groups.length}):
+`);
+    for (const g of groups) {
+      printServiceGroupListItem(g);
+      console.log();
+    }
+  } catch (err) {
+    console.error(`Error listing service groups: ${err.message}`);
+    process.exit(1);
+  }
+}
+async function serviceInfo(args) {
+  const positional = positionalArgs(args);
+  const name = positional[0];
+  const jsonOutput = hasFlag(args, "--json");
+  if (!name) {
+    console.error("Usage: svamp service info <name> [--json]");
+    process.exit(1);
+  }
+  try {
+    const info = await getServiceGroup(name);
+    if (jsonOutput) {
+      console.log(JSON.stringify(info, null, 2));
+      return;
+    }
+    printServiceGroupInfo(info);
+  } catch (err) {
+    console.error(`Error getting service group: ${err.message}`);
+    process.exit(1);
+  }
+}
+async function serviceDelete(args) {
+  const positional = positionalArgs(args);
+  const name = positional[0];
+  if (!name) {
+    console.error("Usage: svamp service delete <name>");
+    process.exit(1);
+  }
+  try {
+    await deleteServiceGroup(name);
+    console.log(`Service group '${name}' deleted.`);
+  } catch (err) {
+    console.error(`Error deleting service group: ${err.message}`);
+    process.exit(1);
+  }
+}
+async function serviceAddBackend(args) {
+  const positional = positionalArgs(args);
+  const name = positional[0];
+  const sandboxId = getFlag(args, "--sandbox-id");
+  if (!name) {
+    console.error("Usage: svamp service add-backend <name> [--sandbox-id <id>]");
+    process.exit(1);
+  }
+  try {
+    const result = await addBackend(name, sandboxId);
+    console.log(`Backend added to '${name}': ${result.sandbox_id} (${result.pod_ip})`);
+    console.log(`  Total backends: ${result.backend_count}`);
+  } catch (err) {
+    console.error(`Error adding backend: ${err.message}`);
+    process.exit(1);
+  }
+}
+async function serviceRemoveBackend(args) {
+  const positional = positionalArgs(args);
+  const name = positional[0];
+  const sandboxId = getFlag(args, "--sandbox-id");
+  if (!name) {
+    console.error("Usage: svamp service remove-backend <name> [--sandbox-id <id>]");
+    process.exit(1);
+  }
+  try {
+    const result = await removeBackend(name, sandboxId);
+    console.log(`Backend removed from '${name}': ${result.sandbox_id}`);
+    console.log(`  Remaining backends: ${result.backend_count}`);
+  } catch (err) {
+    console.error(`Error removing backend: ${err.message}`);
+    process.exit(1);
+  }
+}
+async function serviceAddPort(args) {
+  const positional = positionalArgs(args);
+  const name = positional[0];
+  const ports = parsePorts(args);
+  const subdomain = getFlag(args, "--subdomain");
+  if (!name || ports.length !== 1) {
+    console.error("Usage: svamp service add-port <name> --port <port> [--subdomain <sub>]");
+    process.exit(1);
+  }
+  try {
+    const result = await addPort(name, ports[0], subdomain);
+    console.log(`Port added to '${name}': ${result.port} \u2192 ${result.url}`);
+    console.log(`  Total ports: ${result.total_ports}`);
+  } catch (err) {
+    console.error(`Error adding port: ${err.message}`);
+    process.exit(1);
+  }
+}
+async function serviceRemovePort(args) {
+  const positional = positionalArgs(args);
+  const name = positional[0];
+  const ports = parsePorts(args);
+  if (!name || ports.length !== 1) {
+    console.error("Usage: svamp service remove-port <name> --port <port>");
+    process.exit(1);
+  }
+  try {
+    const result = await removePort(name, ports[0]);
+    console.log(`Port removed from '${name}': ${result.port}`);
+    console.log(`  Remaining ports: ${result.total_ports}`);
+  } catch (err) {
+    console.error(`Error removing port: ${err.message}`);
+    process.exit(1);
+  }
+}
+async function serviceExpose(args) {
+  const positional = positionalArgs(args);
+  const name = positional[0];
+  const ports = parsePorts(args);
+  const subdomain = getFlag(args, "--subdomain");
+  const healthPath = getFlag(args, "--health-path");
+  const healthIntervalStr = getFlag(args, "--health-interval");
+  if (!name || ports.length === 0) {
+    console.error("Usage: svamp service expose <name> --port <port> [--port <port2>] [--health-path <path>]");
+    process.exit(1);
+  }
+  const healthInterval = healthIntervalStr ? parseInt(healthIntervalStr, 10) : void 0;
+  const env = getSandboxEnv();
+  try {
+    const group = await createServiceGroup(name, ports, {
+      subdomain,
+      healthPath,
+      healthInterval
+    });
+    if (env.sandboxId) {
+      const result = await addBackend(name);
+      console.log(`Backend added: ${result.sandbox_id} (${result.pod_ip})`);
+      console.log(`
+Service is live:`);
+      for (const p of group.ports) {
+        console.log(`  ${p.port} \u2192 ${p.url}`);
+      }
+    } else {
+      console.log(`No SANDBOX_ID detected \u2014 starting reverse tunnel.`);
+      const { runTunnel } = await import('./tunnel-BXEroHJF.mjs');
+      await runTunnel(name, ports);
+    }
+  } catch (err) {
+    console.error(`Error exposing service: ${err.message}`);
+    process.exit(1);
+  }
+}
+async function serviceTunnel(args) {
+  const positional = positionalArgs(args);
+  const name = positional[0];
+  const ports = parsePorts(args);
+  if (!name || ports.length === 0) {
+    console.error("Usage: svamp service tunnel <name> --port <port> [--port <port2>]");
+    process.exit(1);
+  }
+  const { runTunnel } = await import('./tunnel-BXEroHJF.mjs');
+  await runTunnel(name, ports);
+}
+async function handleServiceCommand() {
+  const args = process.argv.slice(2);
+  const serviceArgs = args.slice(1);
+  const sub = serviceArgs[0];
+  if (!sub || sub === "--help" || sub === "-h") {
+    printServiceHelp();
+    return;
+  }
+  const commandArgs = serviceArgs.slice(1);
+  if (sub === "create") {
+    await serviceCreate(commandArgs);
+  } else if (sub === "list" || sub === "ls") {
+    await serviceList(commandArgs);
+  } else if (sub === "info" || sub === "show") {
+    await serviceInfo(commandArgs);
+  } else if (sub === "delete" || sub === "rm") {
+    await serviceDelete(commandArgs);
+  } else if (sub === "add-backend" || sub === "add") {
+    await serviceAddBackend(commandArgs);
+  } else if (sub === "remove-backend" || sub === "remove") {
+    await serviceRemoveBackend(commandArgs);
+  } else if (sub === "add-port") {
+    await serviceAddPort(commandArgs);
+  } else if (sub === "remove-port") {
+    await serviceRemovePort(commandArgs);
+  } else if (sub === "expose") {
+    await serviceExpose(commandArgs);
+  } else if (sub === "tunnel") {
+    await serviceTunnel(commandArgs);
+  } else {
+    console.error(`Unknown service command: ${sub}`);
+    printServiceHelp();
+    process.exit(1);
+  }
+}
+function printServiceHelp() {
+  console.log(`
+svamp service \u2014 Manage load-balanced service groups
+
+Usage:
+  svamp service create <name> --port <port> [--port <port2>] [options]   Create a service group
+  svamp service list [--json]                                             List service groups
+  svamp service info <name> [--json]                                      Show service group details
+  svamp service delete <name>                                             Delete a service group
+  svamp service add-backend <name> [--sandbox-id <id>]                    Add a pod as backend
+  svamp service remove-backend <name> [--sandbox-id <id>]                 Remove a backend
+  svamp service add-port <name> --port <port> [--subdomain <sub>]         Add port to existing group
+  svamp service remove-port <name> --port <port>                          Remove port from group
+  svamp service expose <name> --port <port> [--port <port2>] [options]    Create + join (auto-detects tunnel)
+  svamp service tunnel <name> --port <port> [--port <port2>]              Tunnel local ports to service group
+
+Create/Expose options:
+  --health-path <path>       Health check endpoint (e.g., /health)
+  --health-interval <sec>    Health check interval in seconds (default: 30)
+  --subdomain <sub>          Custom subdomain (single-port only)
+
+Service groups expose HTTP services via stable URLs with K8s-native load
+balancing. Multiple pods can serve the same service \u2014 K8s handles traffic
+distribution automatically.
+
+Multi-port: Use --port multiple times to expose several ports under one
+service group. Each port gets its own unique subdomain and URL.
+
+Auto-detect: 'expose' automatically detects the environment:
+  - Cloud sandbox (SANDBOX_ID set): adds pod as K8s backend
+  - Local machine (no SANDBOX_ID): starts reverse tunnel
+
+Environment variables (set by provisioner):
+  SANDBOX_API_URL     Agent-sandbox API base URL
+  SANDBOX_API_KEY     API authentication token
+  SANDBOX_NAMESPACE   User's sandbox namespace
+  SANDBOX_ID          This pod's sandbox ID
+
+Examples:
+  svamp service expose my-api --port 8000
+  svamp service expose my-api --port 8000 --port 3000 --health-path /health
+  svamp service add-port my-api --port 5000
+  svamp service remove-port my-api --port 5000
+  svamp service list
+  svamp service info my-api
+  svamp service delete my-api
+`.trim());
+}
+
+var commands = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    handleServiceCommand: handleServiceCommand,
+    serviceAddBackend: serviceAddBackend,
+    serviceAddPort: serviceAddPort,
+    serviceCreate: serviceCreate,
+    serviceDelete: serviceDelete,
+    serviceExpose: serviceExpose,
+    serviceInfo: serviceInfo,
+    serviceList: serviceList,
+    serviceRemoveBackend: serviceRemoveBackend,
+    serviceRemovePort: serviceRemovePort,
+    serviceTunnel: serviceTunnel
+});
+
+export { commands as c, requireSandboxApiEnv as r };