gwatt 0.0.1

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "gwatt",
+  "version": "0.0.1",
+  "description": "Agent-first CLI for Growatt solar monitoring — JSON output, device filtering, hourly history",
+  "author": "",
+  "license": "MIT",
+  "keywords": [
+    "growatt",
+    "solar",
+    "cli",
+    "energy",
+    "inverter"
+  ],
+  "module": "src/index.ts",
+  "type": "module",
+  "bin": {
+    "gwat": "src/index.ts"
+  },
+  "files": [
+    "src/**/*",
+    "package.json",
+    "README.md"
+  ],
+  "engines": {
+    "bun": ">=1.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "arg": "^5.0.2"
+  }
+}

package/src/api.ts

@@ -0,0 +1,233 @@
+import { createHash } from "crypto";
+import { type Config } from "./config";
+
+const DEFAULT_SERVER = "https://mqtt.growatt.com";
+
+const HEADERS = {
+  "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+  "Accept": "application/json, text/javascript, */*; q=0.01",
+  "X-Requested-With": "XMLHttpRequest",
+  "Referer": "https://mqtt.growatt.com/",
+};
+
+export function hashPassword(password: string): string {
+  let md5 = createHash("md5").update(password).digest("hex");
+  for (let i = 0; i < md5.length; i += 2) {
+    if (md5[i] === "0") {
+      md5 = md5.slice(0, i) + "c" + md5.slice(i + 1);
+    }
+  }
+  return md5;
+}
+
+function makeRequest(
+  url: string,
+  opts: { method?: string; body?: Record<string, string>; headers?: Record<string, string> } = {},
+  cookies?: string
+) {
+  const headers = { ...HEADERS, ...opts.headers };
+  if (cookies) {
+    headers["Cookie"] = cookies;
+  }
+
+  const body = opts.body ? new URLSearchParams(opts.body) : undefined;
+  return fetch(url, {
+    method: opts.method || "GET",
+    headers,
+    body: body ? body.toString() : undefined,
+  });
+}
+
+export async function login(username: string, password: string, serverUrl = DEFAULT_SERVER) {
+  const url = `${serverUrl}/newTwoLoginAPI.do`;
+  const hashed = hashPassword(password);
+
+  const resp = await makeRequest(url, {
+    method: "POST",
+    body: { userName: username, password: hashed },
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
+  });
+
+  const data = (await resp.json()) as { back?: { success: boolean; msg?: string; data?: any[]; user?: any; deviceCount?: string } };
+
+  if (!data.back || !data.back.success) {
+    throw new Error(`Login failed: ${data.back?.msg || "Unknown error"}`);
+  }
+
+  const cookies = (resp.headers as any).getSetCookie?.() as string[] | undefined;
+  const cookieStr = cookies ? cookies.join("; ") : resp.headers.get("set-cookie") || "";
+  const token = data.back.user?.token as string | undefined;
+  const userId = data.back.user?.id as number | undefined;
+  const plant = data.back.data?.[0];
+
+  return {
+    cookies: cookieStr,
+    token,
+    userId,
+    plantId: plant?.plantId as string | undefined,
+    plantName: plant?.plantName as string | undefined,
+    deviceCount: data.back.deviceCount as string | undefined,
+  };
+}
+
+export async function getPlantList(config: Config) {
+  const url = `${config.serverUrl || DEFAULT_SERVER}/PlantListAPI.do?userId=${config.userId}`;
+
+  const resp = await makeRequest(url, {}, config.cookies);
+  const data = (await resp.json()) as {
+    back?: {
+      success: boolean;
+      totalData?: any;
+      data?: any[];
+    };
+  };
+
+  if (!data.back || !data.back.success) {
+    throw new Error("Failed to fetch plant list");
+  }
+
+  return {
+    plants: data.back.data || [],
+    total: data.back.totalData,
+  };
+}
+
+export async function getDevices(config: Config) {
+  const url = `${config.serverUrl || DEFAULT_SERVER}/newTwoPlantAPI.do?op=getAllDeviceList&plantId=${config.plantId}&language=1`;
+
+  const resp = await makeRequest(url, {}, config.cookies);
+  const data = (await resp.json()) as any;
+
+  const devices: Array<{
+    name: string;
+    serialNumber: string;
+    type: string;
+    status: number;
+    eToday: number;
+    eTotal: number;
+    currentPower: number;
+    powerStr: string;
+    eTodayStr: string;
+    raw: any;
+  }> = [];
+
+  const list = data?.deviceList;
+  if (Array.isArray(list)) {
+    for (const item of list) {
+      const eToday = parseFloat(item.eToday ?? item.etoday ?? "0");
+      const eTotal = parseFloat(item.energy ?? item.etotal ?? item.eTotal ?? "0");
+      const currentPower = parseFloat(item.power ?? item.currentPac ?? "0");
+      const deviceStatus = item.deviceStatus ?? item.status ?? 0;
+
+      devices.push({
+        name: item.deviceAilas || item.deviceAlias || item.alias || item.deviceName || item.deviceSn || "Unknown",
+        serialNumber: item.deviceSn || item.sn || "",
+        type: item.deviceType || item.type || "unknown",
+        status: deviceStatus,
+        eToday,
+        eTotal,
+        currentPower,
+        powerStr: item.powerStr || `${(currentPower / 1000).toFixed(2)}kW`,
+        eTodayStr: item.eTodayStr || `${eToday.toFixed(1)}kWh`,
+        raw: item,
+      });
+    }
+  }
+
+  return devices;
+}
+
+export async function getHistory(config: Config, type: number, date: string) {
+  const url = `${config.serverUrl || DEFAULT_SERVER}/PlantDetailAPI.do?plantId=${config.plantId}&type=${type}&date=${date}`;
+
+  const resp = await makeRequest(url, {}, config.cookies);
+  const data = (await resp.json()) as {
+    back?: {
+      success: boolean;
+      plantData?: any;
+      data?: Record<string, string>;
+    };
+  };
+
+  if (!data.back || !data.back.success) {
+    throw new Error("Failed to fetch history data");
+  }
+
+  const entries = Object.entries(data.back.data || {});
+
+  // For type=1 (day), values are Watts at each time point; convert to kWh for display
+  const isDayView = type === 1;
+
+  const points = entries.map(([key, value]) => ({
+    key,
+    value: isDayView ? Math.round((parseFloat(value) / 1000) * 1000) / 1000 : parseFloat(value),
+    unit: isDayView ? "kWh" : "kWh",
+  }));
+
+  const total = Math.round(points.reduce((sum, p) => sum + p.value, 0) * 1000) / 1000;
+
+  return {
+    plantData: data.back.plantData,
+    points,
+    total,
+    isDayView,
+  };
+}
+
+export async function getTodayData(config: Config) {
+  const url = `${config.serverUrl || DEFAULT_SERVER}/newTwoPlantAPI.do?op=getUserCenterEnertyDataByPlantid`;
+
+  const resp = await makeRequest(
+    url,
+    {
+      method: "POST",
+      body: {
+        language: "1",
+        plantId: config.plantId || "",
+      },
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+    },
+    config.cookies
+  );
+
+  const data = (await resp.json()) as {
+    yearStr?: string;
+    weatherMap?: { tmp?: string; cond_txt?: string; cond_code?: string };
+    powerValueStr?: string;
+    alarmValue?: number;
+    plantBean?: {
+      plantName?: string;
+      nominalPower?: number;
+      eToday?: number;
+      eTotal?: number;
+      formulaMoney?: number;
+      formulaMoneyUnitId?: string;
+      hasDeviceOnLine?: number;
+      hasStorage?: number;
+    };
+  };
+
+  return {
+    plantName: data.plantBean?.plantName || config.plantName,
+    today: data.plantBean?.eToday ?? 0,
+    total: data.plantBean?.eTotal ?? 0,
+    nominalPower: data.plantBean?.nominalPower ?? 0,
+    currency: data.plantBean?.formulaMoneyUnitId || "",
+    revenuePerKwh: data.plantBean?.formulaMoney ?? 0,
+    todayRevenue: data.plantBean?.eToday && data.plantBean?.formulaMoney
+      ? data.plantBean.eToday * data.plantBean.formulaMoney
+      : 0,
+    totalRevenue: data.plantBean?.eTotal && data.plantBean?.formulaMoney
+      ? data.plantBean.eTotal * data.plantBean.formulaMoney
+      : 0,
+    weather: data.weatherMap?.cond_txt,
+    temperature: data.weatherMap?.tmp,
+    alarms: data.alarmValue ?? 0,
+    devicesOnline: data.plantBean?.hasDeviceOnLine ?? 0,
+    hasStorage: data.plantBean?.hasStorage ?? 0,
+  };
+}

package/src/config.ts

@@ -0,0 +1,39 @@
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+const CONFIG_DIR = join(homedir(), ".gwat");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+export interface Config {
+  userId?: number;
+  token?: string;
+  cookies?: string;
+  serverUrl?: string;
+  plantId?: string;
+  plantName?: string;
+  username?: string;
+}
+
+export function readConfig(): Config {
+  try {
+    const data = readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(data) as Config;
+  } catch {
+    return {};
+  }
+}
+
+export function writeConfig(config: Config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+export function hasConfig(): boolean {
+  try {
+    readFileSync(CONFIG_FILE, "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/index.ts

@@ -0,0 +1,406 @@
+#!/usr/bin/env bun
+import arg from "arg";
+import { readConfig, writeConfig, hasConfig } from "./config";
+import { login, getPlantList, getTodayData, getDevices, getHistory } from "./api";
+
+const help = `Usage: gwat <command> [options]
+
+Commands:
+  login    Authenticate with Growatt
+  today    Current day energy and device breakdown
+  history  Energy data for day, month, year, or lifetime
+  status   List all plants and totals
+
+Options:
+  -u, --username   Growatt username
+  -p, --password   Growatt password
+  -s, --server     Server URL (default: https://mqtt.growatt.com)
+  -d, --day        Day to view (YYYY-MM-DD)
+  -m, --month      Month to view (YYYY-MM)
+  -y, --year       Year to view (YYYY)
+  -t, --total      Show lifetime totals
+  -n, --device     Filter to a specific device name
+  -j, --json       Output JSON (default: plain text)
+  -h, --help       Show this help
+  -v, --version    Show version
+
+Examples:
+  gwat login -u alice -p secret
+  gwat today -j
+  gwat today -n Abdulaziz
+  gwat history -m 2026-06 -j
+  gwat history -t -j
+  gwat status -j
+`;
+
+const args = arg({
+  "--username": String,
+  "-u": "--username",
+  "--password": String,
+  "-p": "--password",
+  "--server": String,
+  "-s": "--server",
+  "--day": String,
+  "-d": "--day",
+  "--month": String,
+  "-m": "--month",
+  "--year": String,
+  "-y": "--year",
+  "--total": Boolean,
+  "-t": "--total",
+  "--device": String,
+  "-n": "--device",
+  "--json": Boolean,
+  "-j": "--json",
+  "--help": Boolean,
+  "-h": "--help",
+  "--version": Boolean,
+  "-v": "--version",
+}, { permissive: true });
+
+const [cmd] = args._;
+const isJson = args["--json"] ?? false;
+
+if (args["--help"] || (!cmd && !args["--version"])) {
+  console.log(help);
+  process.exit(0);
+}
+
+if (args["--version"]) {
+  console.log(isJson ? JSON.stringify({ version: "0.0.1" }) : "gwat 0.0.1");
+  process.exit(0);
+}
+
+function out(data: unknown) {
+  if (isJson) {
+    console.log(JSON.stringify(data, null, 2));
+  }
+}
+
+function fail(err: { error: string; details?: string }) {
+  if (isJson) {
+    console.log(JSON.stringify(err, null, 2));
+  } else {
+    console.error(`Error: ${err.error}${err.details ? " - " + err.details : ""}`);
+  }
+  process.exit(1);
+}
+
+async function run() {
+  switch (cmd) {
+    case "login":
+      await handleLogin();
+      break;
+    case "today":
+      await handleToday();
+      break;
+    case "history":
+      await handleHistory();
+      break;
+    case "status":
+      await handleStatus();
+      break;
+    default:
+      fail({ error: "Unknown command", details: cmd });
+  }
+}
+
+async function handleLogin() {
+  const username = args["--username"];
+  const password = args["--password"];
+  const server = args["--server"];
+
+  if (!username || !password) {
+    fail({ error: "Missing credentials", details: "--username and --password are required" });
+  }
+
+  const result = await login(username, password, server);
+
+  writeConfig({
+    username,
+    cookies: result.cookies,
+    token: result.token,
+    userId: result.userId,
+    plantId: result.plantId,
+    plantName: result.plantName,
+    serverUrl: server || "https://mqtt.growatt.com",
+  });
+
+  out({
+    success: true,
+    username,
+    plantId: result.plantId,
+    plantName: result.plantName,
+    deviceCount: result.deviceCount,
+  });
+
+  if (!isJson) {
+    console.log(`Logged in as ${username}`);
+    console.log(`Plant: ${result.plantName || "(unknown)"}`);
+    if (result.deviceCount) {
+      console.log(`Devices: ${result.deviceCount}`);
+    }
+  }
+}
+
+async function handleToday() {
+  if (!hasConfig()) {
+    fail({ error: "Not logged in", details: "Run: gwat login -u <username> -p <password>" });
+  }
+
+  const config = readConfig();
+  const today = new Date().toISOString().slice(0, 10);
+  const deviceFilter = args["--device"];
+
+  const [data, { plants }, devices, history] = await Promise.all([
+    getTodayData(config),
+    getPlantList(config),
+    getDevices(config),
+    getHistory(config, 1, today),
+  ]);
+
+  const plant = plants.find((p: any) => p.plantId === config.plantId);
+  const todayEnergyStr = plant?.todayEnergy as string | undefined;
+  const todayEnergy = todayEnergyStr
+    ? parseFloat(todayEnergyStr.replace(/[^0-9.]/g, ""))
+    : data.today;
+
+  const todayRevenue = todayEnergy && data.revenuePerKwh
+    ? todayEnergy * data.revenuePerKwh
+    : 0;
+
+  const sortedHours = history.points.slice().sort((a, b) => a.key.localeCompare(b.key));
+
+  let filteredDevices = devices;
+  if (deviceFilter) {
+    const f = deviceFilter.toLowerCase();
+    filteredDevices = devices.filter((d) => d.name.toLowerCase().includes(f));
+    if (filteredDevices.length === 0) {
+      fail({ error: "Device not found", details: `No device matching "${deviceFilter}"` });
+    }
+  }
+
+  const isSingleDevice = deviceFilter && filteredDevices.length === 1;
+
+  if (isSingleDevice) {
+    const d = filteredDevices[0];
+    const deviceRevenue = d.eToday && data.revenuePerKwh ? d.eToday * data.revenuePerKwh : 0;
+    const status = d.status === 1 || d.status === 2 ? "Online" : "Offline";
+
+    const result = {
+      device: {
+        name: d.name,
+        serial: d.serialNumber,
+        type: d.type,
+        status,
+        todayEnergy: d.eToday,
+        power: d.currentPower,
+        powerStr: d.powerStr,
+        currency: data.currency,
+        revenuePerKwh: data.revenuePerKwh,
+        todayRevenue: deviceRevenue,
+      },
+      hours: sortedHours.map((p) => ({
+        time: p.key,
+        energy: p.value,
+        unit: "kWh",
+      })),
+    };
+
+    out(result);
+
+    if (!isJson) {
+      console.log(`Device:   ${result.device.name}`);
+      console.log(`Today:    ${result.device.todayEnergy.toFixed(1)} kWh`);
+      console.log(`Power:    ${result.device.powerStr}`);
+      console.log(`Status:   ${result.device.status}`);
+      if (result.device.currency && result.device.revenuePerKwh) {
+        console.log(`Today:    ${result.device.todayRevenue.toFixed(0)} ${result.device.currency}`);
+      }
+      console.log(`
+Hours (${result.hours.length}):`);
+      for (const h of result.hours) {
+        console.log(`  ${h.time.padStart(5)}  ${h.energy.toFixed(1).padStart(8)} kWh`);
+      }
+    }
+    return;
+  }
+
+  const result = {
+    plant: {
+      id: config.plantId,
+      name: data.plantName,
+      todayEnergy: todayEnergy,
+      nominalPower: data.nominalPower,
+      capacityKw: data.nominalPower / 1000,
+      currency: data.currency,
+      revenuePerKwh: data.revenuePerKwh,
+      todayRevenue,
+      weather: data.weather,
+      temperature: data.temperature,
+      alarms: data.alarms,
+      devicesOnline: data.devicesOnline,
+      hasStorage: data.hasStorage,
+    },
+    devices: filteredDevices.map((d) => ({
+      name: d.name,
+      serial: d.serialNumber,
+      type: d.type,
+      status: d.status,
+      eToday: d.eToday,
+      currentPower: d.currentPower,
+      powerStr: d.powerStr,
+      eTodayStr: d.eTodayStr,
+    })),
+    hours: sortedHours.map((p) => ({
+      time: p.key,
+      energy: p.value,
+      unit: "kWh",
+    })),
+  };
+
+  out(result);
+
+  if (!isJson) {
+    console.log(`Plant:    ${result.plant.name}`);
+    console.log(`Today:    ${result.plant.todayEnergy.toFixed(1)} kWh`);
+    console.log(`Capacity: ${result.plant.capacityKw.toFixed(1)} kW`);
+    if (result.plant.currency) {
+      console.log(`Today:    ${result.plant.todayRevenue.toFixed(0)} ${result.plant.currency}`);
+    }
+    if (result.plant.weather) {
+      console.log(`Weather:  ${result.plant.weather}, ${result.plant.temperature}C`);
+    }
+    console.log(`Devices:  ${result.plant.devicesOnline === 0 ? "Offline" : "Online"}`);
+    console.log(`
+Devices (${result.devices.length}):`);
+    for (const d of result.devices) {
+      console.log(`  ${d.name}: ${d.eToday.toFixed(1)} kWh (${d.powerStr})`);
+    }
+    console.log(`
+Hours (${result.hours.length}):`);
+    for (const h of result.hours) {
+      console.log(`  ${h.time.padStart(5)}  ${h.energy.toFixed(1).padStart(8)} kWh`);
+    }
+  }
+}
+
+async function handleHistory() {
+  if (!hasConfig()) {
+    fail({ error: "Not logged in", details: "Run: gwat login -u <username> -p <password>" });
+  }
+
+  const day = args["--day"];
+  const month = args["--month"];
+  const year = args["--year"];
+  const total = args["--total"];
+
+  if (!day && !month && !year && !total) {
+    fail({ error: "Missing range", details: "Specify --day, --month, --year, or --total" });
+  }
+
+  let type: number;
+  let date: string;
+  let range: string;
+
+  if (day) {
+    type = 1;
+    date = day;
+    range = "day";
+  } else if (month) {
+    type = 2;
+    date = month;
+    range = "month";
+  } else if (total) {
+    type = 4;
+    date = "";
+    range = "total";
+  } else {
+    type = 3;
+    date = year!;
+    range = "year";
+  }
+
+  const config = readConfig();
+  const result = await getHistory(config, type, date);
+
+  const sorted = result.points.slice().sort((a, b) => a.key.localeCompare(b.key));
+
+  const payload = {
+    range,
+    date: date || undefined,
+    plantId: config.plantId,
+    plantName: result.plantData?.plantName || config.plantName,
+    totalEnergy: result.total,
+    data: sorted.map((p) => ({
+      label: p.key,
+      value: p.value,
+      unit: "kWh",
+    })),
+  };
+
+  out(payload);
+
+  if (!isJson) {
+    console.log(`Plant: ${payload.plantName}`);
+    console.log(`Range: ${range}${date ? " " + date : ""}`);
+    console.log(`Total: ${payload.totalEnergy.toFixed(1)} kWh`);
+    if (sorted.length === 0) {
+      console.log("No data available.");
+      return;
+    }
+    console.log();
+    for (const p of sorted) {
+      console.log(`  ${p.key.padStart(8)}  ${p.value.toFixed(1).padStart(8)} kWh`);
+    }
+  }
+}
+
+async function handleStatus() {
+  if (!hasConfig()) {
+    fail({ error: "Not logged in", details: "Run: gwat login -u <username> -p <password>" });
+  }
+
+  const config = readConfig();
+  const { plants, total } = await getPlantList(config);
+
+  const payload = {
+    plants: plants.map((p: any) => ({
+      id: p.plantId,
+      name: p.plantName,
+      todayEnergy: p.todayEnergy,
+      totalEnergy: p.totalEnergy,
+      currentPower: p.currentPower,
+      isHaveStorage: p.isHaveStorage,
+    })),
+    total: total ? {
+      todayEnergySum: total.todayEnergySum,
+      totalEnergySum: total.totalEnergySum,
+      currentPowerSum: total.currentPowerSum,
+      co2Sum: total.CO2Sum,
+    } : undefined,
+  };
+
+  out(payload);
+
+  if (!isJson) {
+    for (const p of payload.plants) {
+      console.log(`${p.name}`);
+      console.log(`  Today:  ${p.todayEnergy || "N/A"}`);
+      console.log(`  Total:  ${p.totalEnergy || "N/A"}`);
+      console.log(`  Power:  ${p.currentPower || "N/A"}`);
+      console.log(`  ID:     ${p.id}`);
+    }
+    if (payload.total) {
+      console.log(`\nCombined`);
+      console.log(`  Today: ${payload.total.todayEnergySum || "N/A"}`);
+      console.log(`  Total: ${payload.total.totalEnergySum || "N/A"}`);
+      console.log(`  Power: ${payload.total.currentPowerSum || "N/A"}`);
+      console.log(`  CO2:   ${payload.total.co2Sum || "N/A"}`);
+    }
+  }
+}
+
+run().catch((err) => {
+  fail({ error: err.message });
+});