svamp-cli 0.2.225 → 0.2.226

package/dist/commands-Ci-jYuU7.mjs

@@ -0,0 +1,265 @@
+import * as path from 'path';
+
+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;
+}
+async function serviceExpose(args) {
+  const positional = positionalArgs(args);
+  const name = positional[0];
+  const ports = parsePorts(args);
+  const group = getFlag(args, "--group");
+  const groupKey = getFlag(args, "--group-key");
+  const healthCheck = getFlag(args, "--health-check");
+  const healthPath = getFlag(args, "--health-path");
+  const healthInterval = getFlag(args, "--health-interval");
+  const foreground = hasFlag(args, "--foreground");
+  if (!name || ports.length === 0) {
+    console.error("Usage: svamp service expose <name> --port <port> [--port <port2>] [options]");
+    console.error("       --foreground    run frpc in this shell (legacy, dies with shell)");
+    process.exit(1);
+  }
+  if (foreground) {
+    const { runFrpcTunnel } = await import('./frpc-CjX2a7K3.mjs');
+    await runFrpcTunnel(name, ports, void 0, {
+      group,
+      groupKey,
+      healthCheckType: healthCheck,
+      healthCheckPath: healthPath,
+      healthCheckInterval: healthInterval ? parseInt(healthInterval, 10) : void 0
+    });
+    return;
+  }
+  const { connectAndGetMachine } = await import('./commands-Ctop57By.mjs');
+  const { server, machine } = await connectAndGetMachine();
+  try {
+    const status = await machine.tunnelStart({
+      name,
+      ports,
+      group: group || void 0,
+      groupKey: groupKey || void 0,
+      healthCheckType: healthCheck,
+      healthCheckPath: healthPath || void 0,
+      healthCheckInterval: healthInterval ? parseInt(healthInterval, 10) : void 0
+    });
+    console.log(`Tunnel '${name}' registered with daemon \u2014 supervised + restart-persistent.`);
+    if (status && status.urls) {
+      const urlEntries = Object.entries(status.urls);
+      for (const [port, url] of urlEntries) {
+        console.log(`  port ${port}: ${url}`);
+      }
+      if (process.env.SVAMP_SESSION_ID) {
+        const { autoAddSessionLink } = await import('./agentCommands-CGLZ9Nn0.mjs');
+        let added = 0;
+        for (const [port, url] of urlEntries) {
+          const label = urlEntries.length > 1 ? `${name}:${port}` : name;
+          if (autoAddSessionLink(String(url), label)) added++;
+        }
+        if (added) console.log(`  \u21B3 added to this session's Launch Pad`);
+      }
+    }
+    console.log(`To stop: svamp service delete ${name}  (or: svamp tunnel stop ${name})`);
+  } catch (err) {
+    if (/already running/i.test(err?.message || "")) {
+      console.error(`Tunnel '${name}' is already running. Use \`svamp service delete ${name}\` first.`);
+    } else {
+      console.error(`Failed to register tunnel: ${err?.message || err}`);
+      console.error(`Falling back to foreground mode? Add --foreground to run in this shell.`);
+    }
+    process.exit(1);
+  } finally {
+    await server.disconnect();
+  }
+}
+async function serviceServe(args) {
+  const positional = positionalArgs(args);
+  const name = positional[0];
+  const directory = positional[1] || ".";
+  const noListing = hasFlag(args, "--no-listing");
+  if (!name) {
+    console.error("Usage: svamp service serve <name> [directory] [--no-listing]");
+    console.error("  directory defaults to current directory");
+    process.exit(1);
+  }
+  try {
+    const resolvedDir = path.resolve(directory);
+    console.log(`Serving ${resolvedDir}`);
+    const caddyPort = 18080;
+    const { CaddyManager } = await import('./caddy-CuTbE3NY.mjs');
+    const caddy = new CaddyManager({ listenPort: caddyPort });
+    await caddy.addMount(name, resolvedDir, !noListing);
+    await caddy.start();
+    const cleanup = () => {
+      caddy.stop();
+      process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    const { runFrpcTunnel } = await import('./frpc-CjX2a7K3.mjs');
+    await runFrpcTunnel(name, [caddyPort]);
+  } catch (err) {
+    console.error(`Error serving directory: ${err.message}`);
+    process.exit(1);
+  }
+}
+async function serviceList(_args) {
+  try {
+    const { connectAndGetMachine } = await import('./commands-Ctop57By.mjs');
+    const { server, machine } = await connectAndGetMachine();
+    try {
+      const tunnels = await machine.tunnelList({});
+      if (!tunnels || tunnels.length === 0) {
+        console.log("No daemon-managed tunnels configured.");
+        console.log("Standalone foreground tunnels (from `svamp service expose`) are not listed here \u2014 check `pgrep -af frpc`.");
+        return;
+      }
+      const label = (t) => typeof t.state === "string" ? t.state : t.connected ? "connected" : "disconnected";
+      const icon = { connected: "\u2713", reconnecting: "\u21BB", failed: "\u2717", disconnected: "\u2717" };
+      console.log("Daemon-managed tunnels:");
+      for (const t of tunnels) {
+        const st = label(t);
+        const ports = Array.isArray(t.ports) && t.ports.length ? ` :${t.ports.join(",")}` : "";
+        let extra = "";
+        if (st !== "connected") {
+          const bits = [];
+          if (t.restartAttempts) bits.push(`${t.restartAttempts} restarts`);
+          if (t.probe && !t.probe.ok && t.probe.stalenessMs) bits.push(`probe stale ${Math.round(t.probe.stalenessMs / 1e3)}s`);
+          if (bits.length) extra = ` (${bits.join(", ")})`;
+        }
+        console.log(`  ${icon[st] ?? "\u2022"} ${t.name}${ports} \u2014 ${st}${extra}`);
+      }
+    } finally {
+      await server.disconnect();
+    }
+  } catch (err) {
+    console.error(`Error listing tunnels: ${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 {
+    const { connectAndGetMachine } = await import('./commands-Ctop57By.mjs');
+    const { server, machine } = await connectAndGetMachine();
+    try {
+      await machine.tunnelStop({ name });
+      console.log(`Stopped tunnel '${name}'.`);
+    } catch (err) {
+      if (/not found/i.test(err.message)) {
+        console.error(`No daemon-managed tunnel named '${name}'.`);
+        console.error("If this was a standalone foreground tunnel (from `svamp service expose`), the daemon can't stop it.");
+        console.error(`Kill the frpc process directly: pkill -f 'frpc.*${name}'`);
+      } else {
+        console.error(`Error stopping tunnel: ${err.message}`);
+      }
+      process.exit(1);
+    } finally {
+      await server.disconnect();
+    }
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+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 === "expose" || sub === "tunnel") {
+    await serviceExpose(commandArgs);
+  } else if (sub === "serve") {
+    await serviceServe(commandArgs);
+  } else if (sub === "list" || sub === "ls") {
+    await serviceList();
+  } else if (sub === "delete" || sub === "rm") {
+    await serviceDelete(commandArgs);
+  } else {
+    console.error(`Unknown service command: ${sub}`);
+    printServiceHelp();
+    process.exit(1);
+  }
+}
+function printServiceHelp() {
+  console.log(`
+svamp service \u2014 Expose local services via frpc tunnels
+
+Usage:
+  svamp service expose <name> --port <port> [options]    Expose local ports via tunnel
+  svamp service serve <name> [directory] [--no-listing]   Serve static files via tunnel
+  svamp service list                                      List active tunnels (daemon)
+  svamp service delete <name>                             Stop a tunnel (daemon)
+
+Options:
+  --port <port>              Port to expose (repeatable for multi-port)
+  --group <name>             Service group \u2014 multiple machines share the same URL
+  --group-key <secret>       Shared key for the service group
+  --health-check <tcp|http>  Enable health checks on local backend
+  --health-path <path>       HTTP health check path (e.g., /health)
+  --health-interval <sec>    Health check interval (default: 10s)
+
+Service Groups:
+  Run the same command on different machines with --group to create a
+  load-balanced service. frps round-robins traffic across all group members.
+
+  Machine A:  svamp service expose my-api --port 8000 --group my-api --group-key s3cret
+  Machine B:  svamp service expose my-api --port 8000 --group my-api --group-key s3cret
+  \u2192 Both serve at the same URL, frps load-balances between them
+
+Examples:
+  svamp service expose my-api --port 8000
+  svamp service expose my-api --port 8000 --health-check http --health-path /health
+  svamp service expose my-api --port 8000 --port 3000
+  svamp service expose my-api --port 8000 --group my-api --group-key s3cret
+  svamp service serve my-site ./dist
+`.trim());
+}
+
+export { handleServiceCommand, serviceDelete, serviceExpose, serviceList, serviceServe };