svamp-cli 0.1.86 → 0.1.87

package/dist/commands-BrEXFF2q.mjs

@@ -1,593 +0,0 @@
-import { writeFileSync, readFileSync } from 'fs';
-import { resolve } from 'path';
-import { connectAndGetMachine } from './commands-Dsoathf7.mjs';
-import 'node:fs';
-import 'node:child_process';
-import 'node:path';
-import 'node:os';
-import './run-D7JVP8QU.mjs';
-import 'os';
-import 'fs/promises';
-import 'url';
-import 'child_process';
-import 'crypto';
-import 'node:crypto';
-import '@agentclientprotocol/sdk';
-import '@modelcontextprotocol/sdk/client/index.js';
-import '@modelcontextprotocol/sdk/client/stdio.js';
-import '@modelcontextprotocol/sdk/types.js';
-import 'zod';
-import 'node:fs/promises';
-import 'node:util';
-
-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 splitOnDoubleDash(args) {
-  const sep = args.indexOf("--");
-  if (sep === -1) return { flagArgs: args, cmdArgs: [] };
-  return { flagArgs: args.slice(0, sep), cmdArgs: args.slice(sep + 1) };
-}
-function parseIntFlag(args, flag, defaultVal) {
-  const raw = getFlag(args, flag);
-  if (raw === void 0) return defaultVal;
-  const n = parseInt(raw, 10);
-  if (isNaN(n) || n < 0) {
-    console.error(`Error: ${flag} must be a non-negative integer`);
-    process.exit(1);
-  }
-  return n;
-}
-function parseIntFlagOpt(args, flag) {
-  const raw = getFlag(args, flag);
-  if (raw === void 0) return void 0;
-  const n = parseInt(raw, 10);
-  if (isNaN(n) || n < 0) {
-    console.error(`Error: ${flag} must be a non-negative integer`);
-    process.exit(1);
-  }
-  return n;
-}
-async function loadYaml() {
-  try {
-    return await import('yaml');
-  } catch {
-    console.error("Error: YAML support requires the `yaml` package. Run: yarn workspace svamp-cli add yaml");
-    process.exit(1);
-  }
-}
-async function readSpecFile(filePath) {
-  const absPath = resolve(filePath);
-  let raw;
-  try {
-    raw = readFileSync(absPath, "utf-8");
-  } catch (err) {
-    console.error(`Error reading spec file '${filePath}': ${err.message}`);
-    process.exit(1);
-  }
-  let parsed;
-  if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
-    const yaml = await loadYaml();
-    try {
-      parsed = yaml.parse(raw);
-    } catch (err) {
-      console.error(`Error parsing YAML: ${err.message}`);
-      process.exit(1);
-    }
-  } else {
-    try {
-      parsed = JSON.parse(raw);
-    } catch (err) {
-      console.error(`Error parsing JSON: ${err.message}`);
-      process.exit(1);
-    }
-  }
-  return normalizeSpec(parsed);
-}
-async function writeSpecFile(filePath, spec) {
-  const isYaml = filePath.endsWith(".yaml") || filePath.endsWith(".yml");
-  const yaml = await loadYaml();
-  const exportSpec = {
-    name: spec.name,
-    command: spec.command,
-    args: spec.args,
-    workdir: spec.workdir,
-    keepAlive: spec.keepAlive,
-    maxRestarts: spec.maxRestarts,
-    restartDelay: spec.restartDelay,
-    ...spec.env && Object.keys(spec.env).length > 0 ? { env: spec.env } : {},
-    ...spec.probe ? { probe: spec.probe } : {},
-    ...spec.ttl !== void 0 ? { ttl: spec.ttl } : {},
-    ...spec.serviceGroup ? { serviceGroup: spec.serviceGroup } : {},
-    ...spec.ports ? { ports: spec.ports } : {}
-  };
-  const content = isYaml ? `# svamp process spec \u2014 apply with: svamp process apply ${filePath}
-${yaml.stringify(exportSpec)}` : JSON.stringify(exportSpec, null, 2);
-  writeFileSync(filePath, content, "utf-8");
-}
-function specToYaml(spec, yaml) {
-  const exportSpec = {
-    name: spec.name,
-    command: spec.command,
-    args: spec.args,
-    workdir: spec.workdir,
-    keepAlive: spec.keepAlive
-  };
-  if (spec.maxRestarts) exportSpec.maxRestarts = spec.maxRestarts;
-  if (spec.restartDelay !== 2) exportSpec.restartDelay = spec.restartDelay;
-  if (spec.env && Object.keys(spec.env).length > 0) exportSpec.env = spec.env;
-  if (spec.probe) exportSpec.probe = spec.probe;
-  if (spec.ttl !== void 0) exportSpec.ttl = spec.ttl;
-  if (spec.serviceGroup) exportSpec.serviceGroup = spec.serviceGroup;
-  if (spec.ports) exportSpec.ports = spec.ports;
-  return yaml.stringify(exportSpec);
-}
-function normalizeSpec(raw) {
-  if (!raw || typeof raw !== "object") {
-    console.error("Error: spec must be an object");
-    process.exit(1);
-  }
-  if (!raw.name || typeof raw.name !== "string") {
-    console.error("Error: spec.name is required");
-    process.exit(1);
-  }
-  if (!raw.command || typeof raw.command !== "string") {
-    console.error("Error: spec.command is required");
-    process.exit(1);
-  }
-  return {
-    name: raw.name,
-    command: raw.command,
-    args: Array.isArray(raw.args) ? raw.args.map(String) : [],
-    workdir: typeof raw.workdir === "string" ? raw.workdir : process.cwd(),
-    env: raw.env && typeof raw.env === "object" ? raw.env : void 0,
-    probe: raw.probe ? {
-      type: "http",
-      port: Number(raw.probe.port),
-      path: raw.probe.path ?? "/",
-      interval: raw.probe.interval !== void 0 ? Number(raw.probe.interval) : void 0,
-      timeout: raw.probe.timeout !== void 0 ? Number(raw.probe.timeout) : void 0,
-      failureThreshold: raw.probe.failureThreshold !== void 0 ? Number(raw.probe.failureThreshold) : void 0
-    } : void 0,
-    keepAlive: Boolean(raw.keepAlive ?? false),
-    maxRestarts: Number(raw.maxRestarts ?? 0),
-    restartDelay: Number(raw.restartDelay ?? 2),
-    ttl: raw.ttl !== void 0 ? Number(raw.ttl) : void 0,
-    serviceGroup: raw.serviceGroup,
-    ports: Array.isArray(raw.ports) ? raw.ports.map(Number) : void 0
-  };
-}
-function statusIcon(status) {
-  switch (status) {
-    case "running":
-      return "\u25CF";
-    case "starting":
-      return "\u25CB";
-    case "stopped":
-      return "\u25A1";
-    case "failed":
-      return "\u2716";
-    case "expired":
-      return "\u231B";
-    case "stopping":
-      return "\u2193";
-    default:
-      return "?";
-  }
-}
-function formatUptime(startedAt) {
-  if (!startedAt) return "";
-  const s = Math.floor((Date.now() - startedAt) / 1e3);
-  if (s < 60) return `${s}s`;
-  if (s < 3600) return `${Math.floor(s / 60)}m${s % 60}s`;
-  return `${Math.floor(s / 3600)}h${Math.floor(s % 3600 / 60)}m`;
-}
-function formatTTL(spec) {
-  if (spec.ttl === void 0) return "";
-  const remaining = Math.floor((spec.createdAt + spec.ttl * 1e3 - Date.now()) / 1e3);
-  if (remaining <= 0) return "expired";
-  if (remaining < 60) return `ttl:${remaining}s`;
-  if (remaining < 3600) return `ttl:${Math.floor(remaining / 60)}m`;
-  return `ttl:${Math.floor(remaining / 3600)}h`;
-}
-function printProcessTable(processes) {
-  if (processes.length === 0) {
-    console.log("No supervised processes.");
-    return;
-  }
-  const cols = ["NAME", "STATUS", "PID", "RESTARTS", "UPTIME", "PROBE", "TTL"];
-  const widths = [24, 12, 8, 10, 10, 8, 8];
-  const header = cols.map((c, i) => c.padEnd(widths[i])).join(" ");
-  console.log(header);
-  console.log("\u2500".repeat(header.length));
-  for (const { spec, state } of processes) {
-    const row = [
-      spec.name.padEnd(widths[0]),
-      `${statusIcon(state.status)} ${state.status}`.padEnd(widths[1]),
-      (state.pid?.toString() ?? "\u2014").padEnd(widths[2]),
-      state.restartCount.toString().padEnd(widths[3]),
-      formatUptime(state.startedAt).padEnd(widths[4]),
-      (spec.probe ? state.lastProbe ? state.lastProbe.ok ? "ok" : "fail" : "wait" : "\u2014").padEnd(widths[5]),
-      formatTTL(spec).padEnd(widths[6])
-    ];
-    console.log(row.join(" "));
-  }
-}
-function printProcessDetail(info) {
-  const { spec, state } = info;
-  console.log(`
-Process: ${spec.name}`);
-  console.log(`  ID:         ${spec.id}`);
-  console.log(`  Status:     ${statusIcon(state.status)} ${state.status}${state.pid ? ` (pid ${state.pid})` : ""}`);
-  console.log(`  Command:    ${spec.command} ${spec.args.join(" ")}`);
-  console.log(`  Workdir:    ${spec.workdir}`);
-  console.log(`  Keep-alive: ${spec.keepAlive}${spec.maxRestarts > 0 ? ` (max ${spec.maxRestarts})` : ""}`);
-  if (state.restartCount > 0) console.log(`  Restarts:   ${state.restartCount}`);
-  if (state.startedAt) console.log(`  Uptime:     ${formatUptime(state.startedAt)}`);
-  if (spec.probe) {
-    const p = spec.probe;
-    const lp = state.lastProbe;
-    const result = lp ? lp.ok ? `OK (HTTP ${lp.statusCode})` : `FAIL (${lp.error ?? `HTTP ${lp.statusCode}`})` : "waiting...";
-    console.log(`  Probe:      http://localhost:${p.port}${p.path ?? "/"} [${result}]`);
-    if (state.consecutiveProbeFailures > 0) {
-      console.log(`              \u26A0 ${state.consecutiveProbeFailures} consecutive failure(s)`);
-    }
-  }
-  if (spec.ttl !== void 0) console.log(`  TTL:        ${spec.ttl}s (${formatTTL(spec) || "no expiry"})`);
-  if (spec.serviceGroup) console.log(`  Service:    ${spec.serviceGroup} port(s): ${spec.ports?.join(", ")}`);
-  if (spec.env && Object.keys(spec.env).length > 0) {
-    console.log(`  Env:        ${Object.entries(spec.env).map(([k, v]) => `${k}=${v}`).join(", ")}`);
-  }
-  console.log(`  Created:    ${new Date(spec.createdAt).toLocaleString()}`);
-}
-async function processCommand(args, machineId) {
-  const sub = args[0];
-  if (!sub || sub === "help" || sub === "--help" || sub === "-h") {
-    printHelp();
-    return;
-  }
-  const subArgs = args.slice(1);
-  switch (sub) {
-    case "apply":
-      return applyCommand(subArgs, machineId);
-    case "list":
-    case "ls":
-      return listCommand(subArgs, machineId);
-    case "get":
-      return getCommand(subArgs, machineId);
-    case "start":
-      return startCommand(subArgs, machineId);
-    case "stop":
-      return stopCommand(subArgs, machineId);
-    case "restart":
-      return restartCommand(subArgs, machineId);
-    case "delete":
-    case "remove":
-    case "rm":
-      return deleteCommand(subArgs, machineId);
-    case "logs":
-    case "log":
-      return logsCommand(subArgs, machineId);
-    default:
-      if (sub.endsWith(".yaml") || sub.endsWith(".yml") || sub.endsWith(".json")) {
-        return applyCommand(args, machineId);
-      }
-      console.error(`Unknown process subcommand: '${sub}'`);
-      printHelp();
-      process.exit(1);
-  }
-}
-async function applyCommand(args, machineId) {
-  const filePath = args.find((a) => !a.startsWith("-"));
-  if (!filePath) {
-    console.error("Error: spec file required");
-    console.error("Usage: svamp process apply <file.yaml>");
-    process.exit(1);
-  }
-  const save = hasFlag(args, "--save");
-  const spec = await readSpecFile(filePath);
-  const { server, machine } = await connectAndGetMachine(machineId);
-  try {
-    const result = await machine.processApply({ spec, _rkwargs: true });
-    const { action, info } = result;
-    if (action === "no-change") {
-      console.log(`process/${info.spec.name} unchanged`);
-    } else if (action === "created") {
-      console.log(`process/${info.spec.name} created`);
-    } else {
-      console.log(`process/${info.spec.name} configured`);
-    }
-    if (info.state.pid) {
-      console.log(`  pid: ${info.state.pid}, status: ${info.state.status}`);
-    }
-    if (save) {
-      await writeSpecFile(filePath, info.spec);
-      console.log(`  Spec saved to ${filePath}`);
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function listCommand(args, machineId) {
-  const json = hasFlag(args, "--json");
-  const { server, machine } = await connectAndGetMachine(machineId);
-  try {
-    const processes = await machine.processList({ _rkwargs: true });
-    if (json) {
-      console.log(JSON.stringify(processes, null, 2));
-    } else {
-      printProcessTable(processes);
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function getCommand(args, machineId) {
-  const idOrName = args.find((a) => !a.startsWith("-"));
-  if (!idOrName) {
-    console.error("Error: process name or id required");
-    process.exit(1);
-  }
-  const outputFormat = getFlag(args, "-o") ?? getFlag(args, "--output") ?? "human";
-  const outFile = getFlag(args, "--save");
-  const { server, machine } = await connectAndGetMachine(machineId);
-  try {
-    const info = await machine.processGet({ idOrName, _rkwargs: true });
-    if (!info) {
-      console.error(`Error: process '${idOrName}' not found`);
-      process.exit(1);
-    }
-    if (outputFormat === "yaml" || outputFormat === "yml") {
-      const yaml = await loadYaml();
-      const content = specToYaml(info.spec, yaml);
-      if (outFile) {
-        writeFileSync(outFile, `# svamp process spec \u2014 apply with: svamp process apply ${outFile}
-${content}`, "utf-8");
-        console.log(`Spec written to ${outFile}`);
-      } else {
-        process.stdout.write(content);
-      }
-    } else if (outputFormat === "json") {
-      const out = JSON.stringify(info, null, 2);
-      if (outFile) {
-        writeFileSync(outFile, out, "utf-8");
-        console.log(`Written to ${outFile}`);
-      } else {
-        console.log(out);
-      }
-    } else {
-      printProcessDetail(info);
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function startCommand(args, machineId) {
-  const { flagArgs, cmdArgs } = splitOnDoubleDash(args);
-  const idOrName = flagArgs.find((a) => !a.startsWith("-"));
-  if (!idOrName) {
-    console.error("Error: process name or id required");
-    process.exit(1);
-  }
-  if (cmdArgs.length === 0) {
-    const { server: server2, machine: machine2 } = await connectAndGetMachine(machineId);
-    try {
-      await machine2.processStart({ idOrName, _rkwargs: true });
-      console.log(`Started '${idOrName}'`);
-    } finally {
-      await server2.disconnect();
-    }
-    return;
-  }
-  const command = cmdArgs[0];
-  const cmdArgList = cmdArgs.slice(1);
-  const workdir = getFlag(flagArgs, "--workdir") ?? process.cwd();
-  const keepAlive = hasFlag(flagArgs, "--keep-alive", "--keepalive");
-  const maxRestarts = parseIntFlag(flagArgs, "--max-restarts", 0);
-  const restartDelay = parseIntFlag(flagArgs, "--restart-delay", 2);
-  const ttlRaw = getFlag(flagArgs, "--ttl");
-  const ttl = ttlRaw !== void 0 ? parseInt(ttlRaw, 10) : void 0;
-  const probePortRaw = getFlag(flagArgs, "--probe-port");
-  let probe;
-  if (probePortRaw !== void 0) {
-    const probePort = parseInt(probePortRaw, 10);
-    if (isNaN(probePort) || probePort < 1) {
-      console.error("Error: --probe-port must be a valid port number");
-      process.exit(1);
-    }
-    probe = {
-      type: "http",
-      port: probePort,
-      ...getFlag(flagArgs, "--probe-path") ? { path: getFlag(flagArgs, "--probe-path") } : {},
-      ...parseIntFlagOpt(flagArgs, "--probe-interval") !== void 0 ? { interval: parseIntFlagOpt(flagArgs, "--probe-interval") } : {},
-      ...parseIntFlagOpt(flagArgs, "--probe-timeout") !== void 0 ? { timeout: parseIntFlagOpt(flagArgs, "--probe-timeout") } : {},
-      ...parseIntFlagOpt(flagArgs, "--probe-failures") !== void 0 ? { failureThreshold: parseIntFlagOpt(flagArgs, "--probe-failures") } : {}
-    };
-  }
-  const envPairs = getAllFlags(flagArgs, "--env");
-  const env = {};
-  for (const pair of envPairs) {
-    const eq = pair.indexOf("=");
-    if (eq === -1) {
-      console.error(`Error: --env value must be KEY=VALUE`);
-      process.exit(1);
-    }
-    env[pair.slice(0, eq)] = pair.slice(eq + 1);
-  }
-  const spec = {
-    name: idOrName,
-    command,
-    args: cmdArgList,
-    workdir,
-    ...Object.keys(env).length > 0 ? { env } : {},
-    keepAlive,
-    maxRestarts,
-    restartDelay,
-    ...probe ? { probe } : {},
-    ...ttl !== void 0 ? { ttl } : {}
-  };
-  const saveFile = getFlag(flagArgs, "--save");
-  const { server, machine } = await connectAndGetMachine(machineId);
-  try {
-    const result = await machine.processApply({ spec, _rkwargs: true });
-    const { info } = result;
-    console.log(`Started '${info.spec.name}' (id: ${info.spec.id}, pid: ${info.state.pid ?? "\u2014"})`);
-    if (keepAlive) console.log("  Keep-alive: enabled");
-    if (probe) console.log(`  Probe: http://localhost:${probe.port}${probe.path ?? "/"}`);
-    if (ttl !== void 0) console.log(`  TTL: ${ttl}s`);
-    if (saveFile) {
-      await writeSpecFile(saveFile, info.spec);
-      console.log(`  Spec saved to ${saveFile}`);
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function stopCommand(args, machineId) {
-  const idOrName = args.find((a) => !a.startsWith("-"));
-  if (!idOrName) {
-    console.error("Error: process name or id required");
-    process.exit(1);
-  }
-  const { server, machine } = await connectAndGetMachine(machineId);
-  try {
-    await machine.processStop({ idOrName, _rkwargs: true });
-    console.log(`Stopped '${idOrName}'`);
-  } finally {
-    await server.disconnect();
-  }
-}
-async function restartCommand(args, machineId) {
-  const idOrName = args.find((a) => !a.startsWith("-"));
-  if (!idOrName) {
-    console.error("Error: process name or id required");
-    process.exit(1);
-  }
-  const { server, machine } = await connectAndGetMachine(machineId);
-  try {
-    await machine.processRestart({ idOrName, _rkwargs: true });
-    console.log(`Restarted '${idOrName}'`);
-  } finally {
-    await server.disconnect();
-  }
-}
-async function deleteCommand(args, machineId) {
-  const idOrName = args.find((a) => !a.startsWith("-"));
-  if (!idOrName) {
-    console.error("Error: process name or id required");
-    process.exit(1);
-  }
-  const { server, machine } = await connectAndGetMachine(machineId);
-  try {
-    await machine.processRemove({ idOrName, _rkwargs: true });
-    console.log(`Deleted '${idOrName}'`);
-  } finally {
-    await server.disconnect();
-  }
-}
-async function logsCommand(args, machineId) {
-  const idOrName = args.find((a) => !a.startsWith("-"));
-  if (!idOrName) {
-    console.error("Error: process name or id required");
-    process.exit(1);
-  }
-  const last = parseIntFlag(args, "--last", 50);
-  const { server, machine } = await connectAndGetMachine(machineId);
-  try {
-    const lines = await machine.processLogs({ idOrName, last, _rkwargs: true });
-    if (lines.length === 0) console.log("(no output yet)");
-    else console.log(lines.join("\n"));
-  } finally {
-    await server.disconnect();
-  }
-}
-function printHelp() {
-  console.log(`
-svamp process \u2014 Supervised process management (Kubernetes-style)
-
-USAGE
-  svamp process <command> [options] [-m <machine>]
-
-COMMANDS
-  apply  <file.yaml>              Apply a process spec (create or update)
-  list   [--json]                 List all supervised processes
-  get    <name|id> [-o yaml|json] Get process spec and status
-  start  <name|id>                Start a stopped process
-  start  <name> [flags] -- <cmd>  Create and start (inline shorthand)
-  stop   <name|id>                Stop (keeps config for restart)
-  restart <name|id>               Restart process
-  delete <name|id>                Stop and remove from supervision
-  logs   <name|id> [--last N]     Show recent log output
-
-APPLY (recommended workflow)
-  # Create a spec file
-  cat > myapp.yaml << EOF
-  name: myapp
-  command: python
-  args: [app.py]
-  workdir: /data/myapp
-  keepAlive: true
-  probe:
-    type: http
-    port: 8080
-    path: /health
-  ttl: 86400
-  EOF
-
-  # Apply (idempotent \u2014 re-run to update config)
-  svamp process apply myapp.yaml
-
-  # Export current spec
-  svamp process get myapp -o yaml > myapp.yaml
-
-START FLAGS (inline mode: svamp process start <name> [flags] -- <cmd>)
-  --workdir <dir>         Working directory (default: cwd)
-  --keep-alive            Restart on exit/crash
-  --max-restarts N        Max restart attempts (0 = unlimited)
-  --restart-delay N       Seconds between restarts (default: 2)
-  --probe-port N          Enable HTTP health probe on port N
-  --probe-path <path>     Health check path (default: /)
-  --probe-interval N      Check interval in seconds (default: 10)
-  --probe-timeout N       Check timeout in seconds (default: 5)
-  --probe-failures N      Consecutive failures before restart (default: 3)
-  --ttl <seconds>         Auto-kill after N seconds
-  --env KEY=VALUE         Extra environment variable (repeatable)
-  --save <file.yaml>      Save spec to file after creation
-
-SPEC FILE FORMAT (YAML or JSON)
-  name: string              Required. Unique process name.
-  command: string           Required. Executable.
-  args: string[]            Command arguments.
-  workdir: string           Working directory.
-  keepAlive: boolean        Restart on crash (default: false).
-  maxRestarts: number       Max restarts (0 = unlimited).
-  restartDelay: number      Seconds between restarts.
-  probe:
-    type: http              Only 'http' supported.
-    port: number            Port to probe.
-    path: string            HTTP path (default: /).
-    interval: number        Seconds between probes.
-    timeout: number         Probe timeout in seconds.
-    failureThreshold: number  Failures before restart.
-  ttl: number               Seconds until auto-kill.
-  env: {KEY: value}         Extra environment variables.
-  serviceGroup: string      Linked service group name.
-  ports: number[]           Ports exposed by this process.
-`);
-}
-
-export { processCommand };