| import type { Command } from "commander"; |
| import { gatewayStatusCommand } from "../../commands/gateway-status.js"; |
| import { formatHealthChannelLines, type HealthSummary } from "../../commands/health.js"; |
| import { loadConfig } from "../../config/config.js"; |
| import { discoverGatewayBeacons } from "../../infra/bonjour-discovery.js"; |
| import type { CostUsageSummary } from "../../infra/session-cost-usage.js"; |
| import { resolveWideAreaDiscoveryDomain } from "../../infra/widearea-dns.js"; |
| import { defaultRuntime } from "../../runtime.js"; |
| import { formatDocsLink } from "../../terminal/links.js"; |
| import { colorize, isRich, theme } from "../../terminal/theme.js"; |
| import { formatTokenCount, formatUsd } from "../../utils/usage-format.js"; |
| import { withProgress } from "../progress.js"; |
| import { runCommandWithRuntime } from "../cli-utils.js"; |
| import { |
| runDaemonInstall, |
| runDaemonRestart, |
| runDaemonStart, |
| runDaemonStatus, |
| runDaemonStop, |
| runDaemonUninstall, |
| } from "../daemon-cli.js"; |
| import { callGatewayCli, gatewayCallOpts } from "./call.js"; |
| import type { GatewayDiscoverOpts } from "./discover.js"; |
| import { |
| dedupeBeacons, |
| parseDiscoverTimeoutMs, |
| pickBeaconHost, |
| pickGatewayPort, |
| renderBeaconLines, |
| } from "./discover.js"; |
| import { addGatewayRunCommand } from "./run.js"; |
|
|
| function styleHealthChannelLine(line: string, rich: boolean): string { |
| if (!rich) { |
| return line; |
| } |
| const colon = line.indexOf(":"); |
| if (colon === -1) { |
| return line; |
| } |
|
|
| const label = line.slice(0, colon + 1); |
| const detail = line.slice(colon + 1).trimStart(); |
| const normalized = detail.toLowerCase(); |
|
|
| const applyPrefix = (prefix: string, color: (value: string) => string) => |
| `${label} ${color(detail.slice(0, prefix.length))}${detail.slice(prefix.length)}`; |
|
|
| if (normalized.startsWith("failed")) { |
| return applyPrefix("failed", theme.error); |
| } |
| if (normalized.startsWith("ok")) { |
| return applyPrefix("ok", theme.success); |
| } |
| if (normalized.startsWith("linked")) { |
| return applyPrefix("linked", theme.success); |
| } |
| if (normalized.startsWith("configured")) { |
| return applyPrefix("configured", theme.success); |
| } |
| if (normalized.startsWith("not linked")) { |
| return applyPrefix("not linked", theme.warn); |
| } |
| if (normalized.startsWith("not configured")) { |
| return applyPrefix("not configured", theme.muted); |
| } |
| if (normalized.startsWith("unknown")) { |
| return applyPrefix("unknown", theme.warn); |
| } |
|
|
| return line; |
| } |
|
|
| function runGatewayCommand(action: () => Promise<void>, label?: string) { |
| return runCommandWithRuntime(defaultRuntime, action, (err) => { |
| const message = String(err); |
| defaultRuntime.error(label ? `${label}: ${message}` : message); |
| defaultRuntime.exit(1); |
| }); |
| } |
|
|
| function parseDaysOption(raw: unknown, fallback = 30): number { |
| if (typeof raw === "number" && Number.isFinite(raw)) { |
| return Math.max(1, Math.floor(raw)); |
| } |
| if (typeof raw === "string" && raw.trim() !== "") { |
| const parsed = Number(raw); |
| if (Number.isFinite(parsed)) { |
| return Math.max(1, Math.floor(parsed)); |
| } |
| } |
| return fallback; |
| } |
|
|
| function renderCostUsageSummary(summary: CostUsageSummary, days: number, rich: boolean): string[] { |
| const totalCost = formatUsd(summary.totals.totalCost) ?? "$0.00"; |
| const totalTokens = formatTokenCount(summary.totals.totalTokens) ?? "0"; |
| const lines = [ |
| colorize(rich, theme.heading, `Usage cost (${days} days)`), |
| `${colorize(rich, theme.muted, "Total:")} ${totalCost} · ${totalTokens} tokens`, |
| ]; |
|
|
| if (summary.totals.missingCostEntries > 0) { |
| lines.push( |
| `${colorize(rich, theme.muted, "Missing entries:")} ${summary.totals.missingCostEntries}`, |
| ); |
| } |
|
|
| const latest = summary.daily.at(-1); |
| if (latest) { |
| const latestCost = formatUsd(latest.totalCost) ?? "$0.00"; |
| const latestTokens = formatTokenCount(latest.totalTokens) ?? "0"; |
| lines.push( |
| `${colorize(rich, theme.muted, "Latest day:")} ${latest.date} · ${latestCost} · ${latestTokens} tokens`, |
| ); |
| } |
|
|
| return lines; |
| } |
|
|
| export function registerGatewayCli(program: Command) { |
| const gateway = addGatewayRunCommand( |
| program |
| .command("gateway") |
| .description("Run the WebSocket Gateway") |
| .addHelpText( |
| "after", |
| () => |
| `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/gateway", "docs.openclaw.ai/cli/gateway")}\n`, |
| ), |
| ); |
|
|
| addGatewayRunCommand( |
| gateway.command("run").description("Run the WebSocket Gateway (foreground)"), |
| ); |
|
|
| gateway |
| .command("status") |
| .description("Show gateway service status + probe the Gateway") |
| .option("--url <url>", "Gateway WebSocket URL (defaults to config/remote/local)") |
| .option("--token <token>", "Gateway token (if required)") |
| .option("--password <password>", "Gateway password (password auth)") |
| .option("--timeout <ms>", "Timeout in ms", "10000") |
| .option("--no-probe", "Skip RPC probe") |
| .option("--deep", "Scan system-level services", false) |
| .option("--json", "Output JSON", false) |
| .action(async (opts) => { |
| await runDaemonStatus({ |
| rpc: opts, |
| probe: Boolean(opts.probe), |
| deep: Boolean(opts.deep), |
| json: Boolean(opts.json), |
| }); |
| }); |
|
|
| gateway |
| .command("install") |
| .description("Install the Gateway service (launchd/systemd/schtasks)") |
| .option("--port <port>", "Gateway port") |
| .option("--runtime <runtime>", "Daemon runtime (node|bun). Default: node") |
| .option("--token <token>", "Gateway token (token auth)") |
| .option("--force", "Reinstall/overwrite if already installed", false) |
| .option("--json", "Output JSON", false) |
| .action(async (opts) => { |
| await runDaemonInstall(opts); |
| }); |
|
|
| gateway |
| .command("uninstall") |
| .description("Uninstall the Gateway service (launchd/systemd/schtasks)") |
| .option("--json", "Output JSON", false) |
| .action(async (opts) => { |
| await runDaemonUninstall(opts); |
| }); |
|
|
| gateway |
| .command("start") |
| .description("Start the Gateway service (launchd/systemd/schtasks)") |
| .option("--json", "Output JSON", false) |
| .action(async (opts) => { |
| await runDaemonStart(opts); |
| }); |
|
|
| gateway |
| .command("stop") |
| .description("Stop the Gateway service (launchd/systemd/schtasks)") |
| .option("--json", "Output JSON", false) |
| .action(async (opts) => { |
| await runDaemonStop(opts); |
| }); |
|
|
| gateway |
| .command("restart") |
| .description("Restart the Gateway service (launchd/systemd/schtasks)") |
| .option("--json", "Output JSON", false) |
| .action(async (opts) => { |
| await runDaemonRestart(opts); |
| }); |
|
|
| gatewayCallOpts( |
| gateway |
| .command("call") |
| .description("Call a Gateway method") |
| .argument("<method>", "Method name (health/status/system-presence/cron.*)") |
| .option("--params <json>", "JSON object string for params", "{}") |
| .action(async (method, opts) => { |
| await runGatewayCommand(async () => { |
| const params = JSON.parse(String(opts.params ?? "{}")); |
| const result = await callGatewayCli(method, opts, params); |
| if (opts.json) { |
| defaultRuntime.log(JSON.stringify(result, null, 2)); |
| return; |
| } |
| const rich = isRich(); |
| defaultRuntime.log( |
| `${colorize(rich, theme.heading, "Gateway call")}: ${colorize(rich, theme.muted, String(method))}`, |
| ); |
| defaultRuntime.log(JSON.stringify(result, null, 2)); |
| }, "Gateway call failed"); |
| }), |
| ); |
|
|
| gatewayCallOpts( |
| gateway |
| .command("usage-cost") |
| .description("Fetch usage cost summary from session logs") |
| .option("--days <days>", "Number of days to include", "30") |
| .action(async (opts) => { |
| await runGatewayCommand(async () => { |
| const days = parseDaysOption(opts.days); |
| const result = await callGatewayCli("usage.cost", opts, { days }); |
| if (opts.json) { |
| defaultRuntime.log(JSON.stringify(result, null, 2)); |
| return; |
| } |
| const rich = isRich(); |
| const summary = result as CostUsageSummary; |
| for (const line of renderCostUsageSummary(summary, days, rich)) { |
| defaultRuntime.log(line); |
| } |
| }, "Gateway usage cost failed"); |
| }), |
| ); |
|
|
| gatewayCallOpts( |
| gateway |
| .command("health") |
| .description("Fetch Gateway health") |
| .action(async (opts) => { |
| await runGatewayCommand(async () => { |
| const result = await callGatewayCli("health", opts); |
| if (opts.json) { |
| defaultRuntime.log(JSON.stringify(result, null, 2)); |
| return; |
| } |
| const rich = isRich(); |
| const obj: Record<string, unknown> = result && typeof result === "object" ? result : {}; |
| const durationMs = typeof obj.durationMs === "number" ? obj.durationMs : null; |
| defaultRuntime.log(colorize(rich, theme.heading, "Gateway Health")); |
| defaultRuntime.log( |
| `${colorize(rich, theme.success, "OK")}${durationMs != null ? ` (${durationMs}ms)` : ""}`, |
| ); |
| if (obj.channels && typeof obj.channels === "object") { |
| for (const line of formatHealthChannelLines(obj as HealthSummary)) { |
| defaultRuntime.log(styleHealthChannelLine(line, rich)); |
| } |
| } |
| }); |
| }), |
| ); |
|
|
| gateway |
| .command("probe") |
| .description("Show gateway reachability + discovery + health + status summary (local + remote)") |
| .option("--url <url>", "Explicit Gateway WebSocket URL (still probes localhost)") |
| .option("--ssh <target>", "SSH target for remote gateway tunnel (user@host or user@host:port)") |
| .option("--ssh-identity <path>", "SSH identity file path") |
| .option("--ssh-auto", "Try to derive an SSH target from Bonjour discovery", false) |
| .option("--token <token>", "Gateway token (applies to all probes)") |
| .option("--password <password>", "Gateway password (applies to all probes)") |
| .option("--timeout <ms>", "Overall probe budget in ms", "3000") |
| .option("--json", "Output JSON", false) |
| .action(async (opts) => { |
| await runGatewayCommand(async () => { |
| await gatewayStatusCommand(opts, defaultRuntime); |
| }); |
| }); |
|
|
| gateway |
| .command("discover") |
| .description("Discover gateways via Bonjour (local + wide-area if configured)") |
| .option("--timeout <ms>", "Per-command timeout in ms", "2000") |
| .option("--json", "Output JSON", false) |
| .action(async (opts: GatewayDiscoverOpts) => { |
| await runGatewayCommand(async () => { |
| const cfg = loadConfig(); |
| const wideAreaDomain = resolveWideAreaDiscoveryDomain({ |
| configDomain: cfg.discovery?.wideArea?.domain, |
| }); |
| const timeoutMs = parseDiscoverTimeoutMs(opts.timeout, 2000); |
| const domains = ["local.", ...(wideAreaDomain ? [wideAreaDomain] : [])]; |
| const beacons = await withProgress( |
| { |
| label: "Scanning for gateways…", |
| indeterminate: true, |
| enabled: opts.json !== true, |
| delayMs: 0, |
| }, |
| async () => await discoverGatewayBeacons({ timeoutMs, wideAreaDomain }), |
| ); |
|
|
| const deduped = dedupeBeacons(beacons).toSorted((a, b) => |
| String(a.displayName || a.instanceName).localeCompare( |
| String(b.displayName || b.instanceName), |
| ), |
| ); |
|
|
| if (opts.json) { |
| const enriched = deduped.map((b) => { |
| const host = pickBeaconHost(b); |
| const port = pickGatewayPort(b); |
| return { ...b, wsUrl: host ? `ws://${host}:${port}` : null }; |
| }); |
| defaultRuntime.log( |
| JSON.stringify( |
| { |
| timeoutMs, |
| domains, |
| count: enriched.length, |
| beacons: enriched, |
| }, |
| null, |
| 2, |
| ), |
| ); |
| return; |
| } |
|
|
| const rich = isRich(); |
| defaultRuntime.log(colorize(rich, theme.heading, "Gateway Discovery")); |
| defaultRuntime.log( |
| colorize( |
| rich, |
| theme.muted, |
| `Found ${deduped.length} gateway(s) · domains: ${domains.join(", ")}`, |
| ), |
| ); |
| if (deduped.length === 0) { |
| return; |
| } |
|
|
| for (const beacon of deduped) { |
| for (const line of renderBeaconLines(beacon, rich)) { |
| defaultRuntime.log(line); |
| } |
| } |
| }, "gateway discover failed"); |
| }); |
| } |
|
|
