qapu-cli 0.78.0__tar.gz → 0.80.0__tar.gz

{qapu_cli-0.78.0 → qapu_cli-0.80.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qapu-cli
-Version: 0.78.0
+Version: 0.80.0
 Summary: CLI client for the Qapu API - built for the Hermes agent, but usable by anyone talking to api.ovoo.com.tr from outside the Swarm.
 Author: OVOO Technology
 Classifier: Programming Language :: Python :: 3

{qapu_cli-0.78.0 → qapu_cli-0.80.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qapu-cli"
-version = "0.78.0"
+version = "0.80.0"
 description = "CLI client for the Qapu API - built for the Hermes agent, but usable by anyone talking to api.ovoo.com.tr from outside the Swarm."
 readme = "README.md"
 requires-python = ">=3.10"

{qapu_cli-0.78.0 → qapu_cli-0.80.0}/qapu_cli/client.py

@@ -261,6 +261,21 @@ def _request(method: str, path: str, params: dict[str, Any] | None = None, json_
 		raise ClientError(_report_request_error(e, method, url))
 
 
+# Upload one File as multipart/form-data (2026-10-26, Firmware Files) - a
+# Longer Write/Read Timeout Than JSON Calls: the Server Also Relays it to FTP
+def post_file(path: str, file_path: str, field: str = "file", data: dict[str, Any] | None = None) -> Any:
+	url = f"{_base_url()}{path}"
+	try:
+		with open(file_path, "rb") as handle:
+			response = httpx.post(url, headers=_headers(), files={field: (os.path.basename(file_path), handle, "application/octet-stream")}, data=data or {}, timeout=httpx.Timeout(connect=5.0, read=120.0, write=120.0, pool=5.0))
+		response.raise_for_status()
+		return response.json()
+	except httpx.HTTPStatusError as e:
+		raise ClientError(_report_http_status_error(e, "POST", url))
+	except httpx.RequestError as e:
+		raise ClientError(_report_request_error(e, "POST", url))
+
+
 def post(path: str, params: dict[str, Any] | None = None, json_body: dict[str, Any] | None = None) -> Any:
 
 	# Issue a POST Request

{qapu_cli-0.78.0 → qapu_cli-0.80.0}/qapu_cli/command_packages.py

@@ -125,7 +125,11 @@ COMMAND_REQUIRED_PACKAGES: dict[str, frozenset[str]] = {
 	"fleet_data": frozenset({"telemetry:read"}),
 	"fleet_score": frozenset({"scores:read"}),
 	"fleet_status": frozenset({"devices:read", "infrastructure:read", "platform-config:read"}),
+	"fota_approvals": frozenset({"hardware-catalog:read"}),
+	"fota_approve": frozenset({"hardware-catalog:write"}),
+	"fota_confirmations": frozenset({"hardware-catalog:read"}),
 	"fota_ftp": frozenset({"device-actuation:write", "hardware-catalog:read"}),
+	"fota_revoke": frozenset({"hardware-catalog:write"}),
 	"fota_http": frozenset({"device-actuation:write", "hardware-catalog:read"}),
 	"fota_upload": frozenset({"hardware-catalog:read", "hardware-catalog:write"}),
 	"group_add": frozenset({"infrastructure:write"}),
@@ -165,8 +169,11 @@ COMMAND_REQUIRED_PACKAGES: dict[str, frozenset[str]] = {
 	"model_get": frozenset({"hardware-catalog:read"}),
 	"model_list": frozenset({"hardware-catalog:read"}),
 	"model_update": frozenset({"hardware-catalog:write"}),
+	"modem_add": frozenset({"hardware-catalog:write"}),
+	"modem_delete": frozenset({"hardware-catalog:write"}),
 	"modem_get": frozenset({"hardware-catalog:read"}),
 	"modem_list": frozenset({"hardware-catalog:read"}),
+	"modem_update": frozenset({"hardware-catalog:write"}),
 	"mqtt_provision": frozenset({"device-actuation:write"}),
 	"pipeline_stats": frozenset({"platform-config:read"}),
 	"project_add": frozenset({"platform-config:write"}),

{qapu_cli-0.78.0 → qapu_cli-0.80.0}/qapu_cli/main.py

@@ -3,7 +3,6 @@
 # from outside the Swarm. See client.py for the HTTP layer, README.md for
 # setup and the auth placeholder this currently relies on.
 
-import ftplib
 import hashlib
 import json
 import os
@@ -1428,7 +1427,7 @@ def _build_score_compact_table(rows: list[dict[str, Any]], show_device: bool = T
 	table.add_column("YÜK", justify="right")
 	table.add_column("ELEK.", justify="right")
 	table.add_column("VERİ GÜV.", justify="right")
-	table.add_column("MOTOR U%", justify="right")
+	table.add_column("MOTOR", justify="right")
 	table.add_column("DURUM")
 	table.add_column("AI")
 	table.add_column("KAYIT")
@@ -1447,7 +1446,7 @@ def _build_score_compact_table(rows: list[dict[str, Any]], show_device: bool = T
 			_colorize_score(row.get("Load_Behavior_Score")),
 			_colorize_score(row.get("Electrical_Status_Score")),
 			_colorize_score(data_reliability),
-			_colorize_motor_stress(row.get("Motor_Stress_U_Nema_Pct")),
+			_colorize_score(row.get("Motor_Stress_Score")),
 			_colorize_status(row.get("Calculation_Status")),
 			row.get("Ai_Status") or "-",
 			row.get("Record_Status") or "-",
@@ -1490,8 +1489,8 @@ def _build_score_trend_table(rows: list[dict[str, Any]]) -> Optional[Table]:
 	chronological = list(reversed(rows))
 	columns = [
 		("GRID", "Grid_Score"), ("REAKTİF", "Reactive_Score"), ("YÜK", "Load_Behavior_Score"),
-		("ELEK.", "Electrical_Status_Score"), ("VERİ GÜV.", "Data_Reliability_Completeness_Score"),
-		("MOTOR U%", "Motor_Stress_U_Nema_Pct"),
+		("ELEK.", "Electrical_Status_Score"), ("VERİ GÜV.", "Data_Reliability_Score"),
+		("MOTOR", "Motor_Stress_Score"),
 	]
 	table = Table(show_header=True, header_style="bold", title=f"Trend ({len(chronological)} kayıt, eski→yeni)", title_justify="left", box=box.SIMPLE)
 	table.add_column("KART")
@@ -1708,6 +1707,8 @@ def _build_score_detail_view(row: dict[str, Any], previous: Optional[dict[str, A
 			("Seviye", _format_score_value(row.get("Grid_Voltage_Level_Score"))),
 			("Denge", _format_score_value(row.get("Grid_Voltage_Balance_Score"))),
 			("Harmonik", _format_score_value(row.get("Grid_Harmonic_Score"))),
+			("Frekans", _format_score_value(grid_det.get("S_freq"))),
+			("Kesinti", f"{grid_det.get('interruption_count')} kez / {round((grid_det.get('interruption_seconds') or 0) / 60)} dk" if grid_det.get("interruption_count") else "-"),
 			("Belirleyici", grid_det.get("determinant_dimension")),
 		], status_row=("Durum", row.get("Grid_Status")), method_code="CINGA-GRID-SCORE", version=_mv("CINGA-GRID-SCORE")),
 		_score_detail_panel("Reaktif — Ceza Riski", _score_color(row.get("Reactive_Score")), "Skor", row.get("Reactive_Score"), previous.get("Reactive_Score"), [
@@ -1719,14 +1720,15 @@ def _build_score_detail_view(row: dict[str, Any], previous: Optional[dict[str, A
 			("Seviye", _format_score_value(row.get("Reactive_Compensation_Level_Score"))),
 			("Faz Dengesi", _format_score_value(row.get("Reactive_Compensation_Phase_Balance_Score"))),
 			("Kararlılık", _format_score_value(row.get("Reactive_Compensation_Stability_Score"))),
+			("Boşta Reaktif", _format_score_value((row.get("Reactive_Compensation_Determinants") or {}).get("S_idle"))),
 			("Yön", row.get("Reactive_Compensation_Direction")),
 		], status_row=("Durum", row.get("Reactive_Compensation_Status")), method_code="CINGA-REACTIVE-SCORE", version=_mv("CINGA-REACTIVE-SCORE")),
 		_score_detail_panel("Yük Davranışı", _score_color(row.get("Load_Behavior_Score")), "Skor", row.get("Load_Behavior_Score"), previous.get("Load_Behavior_Score"), [
 			("Yüklenme", _format_score_value(row.get("Load_Operating_Point_Score"))),
 			("Faz Dengesi", _format_score_value(row.get("Load_Current_Balance_Score"))),
 			("Dalga Biçimi", _format_score_value(row.get("Load_Current_Waveform_Score"))),
-			("Güç Dönüşümü", _format_score_value(row.get("Load_Power_Conversion_Score"))),
-			("Rejim Kararlılığı", _format_score_value(row.get("Load_Regime_Stability_Score"))),
+			("Güç Kararlılığı", _format_score_value(row.get("Load_Regime_Stability_Score"))),
+			("Bağlantı", (row.get("Load_Determinants") or {}).get("connection_type") or "-"),
 		], status_row=("Durum", row.get("Load_Status")), method_code="CINGA-LOAD-BEHAVIOR-SCORE", version=_mv("CINGA-LOAD-BEHAVIOR-SCORE")),
 		_score_detail_panel("Elektriksel Durum", _score_color(row.get("Electrical_Status_Score")), "Skor", row.get("Electrical_Status_Score"), previous.get("Electrical_Status_Score"), [
 			("Dahil", ", ".join(row.get("Included_Dimensions") or []) or "-"),
@@ -1735,11 +1737,14 @@ def _build_score_detail_view(row: dict[str, Any], previous: Optional[dict[str, A
 		Panel(Group(*[
 			f"{label}: [{_score_color(row.get(field))}]{_format_score_value(row.get(field))}[/{_score_color(row.get(field))}]{_delta_suffix(row.get(field), previous.get(field))}"
 			for label, field in (
-				("Tamlık", "Data_Reliability_Completeness_Score"), ("Güncellik", "Data_Reliability_Timeliness_Score"),
-				("Tutarlılık", "Data_Reliability_Consistency_Score"), ("İzlenebilirlik", "Data_Reliability_Traceability_Score"),
+				("Toplam", "Data_Reliability_Score"),
+				("Tamlık", "Data_Reliability_Completeness_Score"), ("Tutarlılık", "Data_Reliability_Consistency_Score"),
+				("Güncellik (gecikme)", "Data_Reliability_Timeliness_Score"), ("İzlenebilirlik", "Data_Reliability_Traceability_Score"),
 			)
 		]), title="Veri Güvenilirliği", subtitle=(f"[dim]DATA-RELIABILITY-SCORE v{_mv('CINGA-DATA-RELIABILITY-SCORE')}[/dim]" if _mv("CINGA-DATA-RELIABILITY-SCORE") else None), subtitle_align="right", border_style="blue", width=36, height=SCORE_PANEL_HEIGHT),
-		_score_detail_panel("Motor Zorlanması", _motor_stress_color(row.get("Motor_Stress_U_Nema_Pct")), "U_NEMA %", row.get("Motor_Stress_U_Nema_Pct"), previous.get("Motor_Stress_U_Nema_Pct"), [
+		_score_detail_panel("Motor Zorlanması", _score_color(row.get("Motor_Stress_Score")), "Skor", row.get("Motor_Stress_Score"), previous.get("Motor_Stress_Score"), [
+			("NEMA LVUR %", _format_score_value(row.get("Motor_Stress_U_Nema_Pct"))),
+			("Düşürme Katsayısı", row.get("Motor_Stress_K_D_Reference")),
 			("Aşım Süresi (sn)", row.get("Motor_Stress_Exceedance_Duration_Seconds")),
 			("Aşım Sayısı", row.get("Motor_Stress_Exceedance_Count")),
 			("Tahmini Ek Isınma (%)", _format_score_value(row.get("Motor_Stress_Estimated_Extra_Heating_Pct"))),
@@ -4271,12 +4276,62 @@ def modem_get(imei: str = typer.Argument(...), as_json: bool = typer.Option(Fals
 	_print_detail(result)
 
 
+# Modem Writes (2026-10-26) - PUT/POST/DELETE /hermes/modems
+def _modem_body(model_id: Optional[int], status_id: Optional[int]) -> dict[str, Any]:
+	body: dict[str, Any] = {}
+	if model_id is not None:
+		body["Model"] = {"ID": model_id}
+	if status_id is not None:
+		body["Status"] = {"ID": status_id}
+	return body
+
+
+@modem_app.command("add")
+def modem_add(
+	imei: str = typer.Argument(..., help="15-digit IMEI."),
+	model_id: Optional[int] = typer.Option(None, "--model-id", help="A modem model (manufacturer in the 2000 block, e.g. 2007 LE910C1-EUX) or 0 Unknown."),
+	status_id: Optional[int] = typer.Option(None, "--status-id", help="Modem status 301-399 (e.g. 304 In Stock) or 0."),
+):
+	"""Add a modem (POST /hermes/modems). Devices also register their modem automatically on the first packet."""
+	result = client.post("/hermes/modems", json_body={"IMEI": imei, **_modem_body(model_id, status_id)})
+	typer.echo(result.get("Message", result))
+
+
+@modem_app.command("update")
+def modem_update(
+	imei: str = typer.Argument(...),
+	model_id: Optional[int] = typer.Option(None, "--model-id"),
+	status_id: Optional[int] = typer.Option(None, "--status-id"),
+):
+	"""Change a modem's model and/or status (PUT /hermes/modems/{imei}). The IMEI can't change."""
+	body = _modem_body(model_id, status_id)
+	if not body:
+		typer.echo("Nothing to update - give --model-id and/or --status-id.")
+		raise typer.Exit(1)
+	result = client.put(f"/hermes/modems/{imei}", json_body=body)
+	typer.echo(result.get("Message", result))
+
+
+@modem_app.command("delete")
+def modem_delete(imei: str = typer.Argument(...), yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt.")):
+	"""Delete an unused modem (DELETE /hermes/modems/{imei}). A modem a device uses can't be deleted (it would take the device record with it) - change its status instead."""
+	if not yes and not typer.confirm(f"Delete modem {imei}?"):
+		raise typer.Exit(0)
+	result = client.delete(f"/hermes/modems/{imei}")
+	typer.echo(result.get("Message", result))
+
+
+# SIM Lifecycle States (statuses 401-406)
+_SIM_STATE_HELP = "SIM state: 401 Stokta, 402 Aktif, 403 Askıda, 404 Arızalı, 405 İptal, 406 Test SIM'i."
+
+
 # List SIMs
 @sim_app.command("list")
 def sim_list(
 	as_json: bool = typer.Option(False, "--json"),
 	operator_id: Optional[int] = typer.Option(None, "--operator-id"),
-	active: Optional[bool] = typer.Option(None, "--active/--inactive"),
+	active: Optional[bool] = typer.Option(None, "--active/--inactive", help="In service (Aktif or Test SIM'i) or not."),
+	state: Optional[int] = typer.Option(None, "--state", help=_SIM_STATE_HELP),
 	limit: Optional[int] = typer.Option(None, "--limit"),
 ):
 	"""List the SIM inventory (GET /hermes/sims)."""
@@ -4285,13 +4340,15 @@ def sim_list(
 		params["operator_id"] = operator_id
 	if active is not None:
 		params["active"] = active
+	if state is not None:
+		params["state_id"] = state
 	items: list[dict[str, Any]] = client.get("/hermes/sims", params=params)
 	if limit is not None:
 		items = items[:limit]
 	if as_json:
 		typer.echo(json.dumps(items, indent=2))
 		return
-	_print_paginated(items, _simple_table_builder([("ICCID", "ICCID"), ("NUMBER", "Number"), ("OPERATOR", "Operator.MNC_Brand"), ("APN", "APN"), ("INSTITUTIONAL", "Institutional"), ("STATIC_IP", "Static_IP"), ("STATUS", "Status")]), limit=limit, noun="SIM")
+	_print_paginated(items, _simple_table_builder([("ICCID", "ICCID"), ("NUMBER", "Number"), ("OPERATOR", "Operator.MNC_Brand"), ("APN", "APN"), ("INSTITUTIONAL", "Institutional"), ("STATIC_IP", "Static_IP"), ("STATE", "State.Name")]), limit=limit, noun="SIM")
 
 
 # Get One SIM's Detail
@@ -4306,10 +4363,12 @@ def sim_get(iccid: str = typer.Argument(...), as_json: bool = typer.Option(False
 
 
 # SIM Body From CLI Options - Only What was Given
-def _sim_body(operator_id: Optional[int], number: Optional[str], static_ip: Optional[str], apn: Optional[str], institutional: Optional[bool], active: Optional[bool]) -> dict[str, Any]:
+def _sim_body(operator_id: Optional[int], number: Optional[str], static_ip: Optional[str], apn: Optional[str], institutional: Optional[bool], active: Optional[bool], state: Optional[int] = None) -> dict[str, Any]:
 	body: dict[str, Any] = {}
 	if operator_id is not None:
 		body["Operator"] = {"ID": operator_id}
+	if state is not None:
+		body["State"] = {"ID": state}
 	for key, value in (("Number", number), ("Static_IP", static_ip), ("APN", apn), ("Institutional", institutional), ("Status", active)):
 		if value is not None:
 			body[key] = value
@@ -4325,10 +4384,11 @@ def sim_add(
 	static_ip: Optional[str] = typer.Option(None, "--static-ip"),
 	apn: Optional[str] = typer.Option(None, "--apn"),
 	institutional: Optional[bool] = typer.Option(None, "--institutional/--not-institutional", help="SIM supplied by a customer institution."),
-	active: Optional[bool] = typer.Option(None, "--active/--inactive"),
+	active: Optional[bool] = typer.Option(None, "--active/--inactive", help="Shortcut for --state 402/403."),
+	state: Optional[int] = typer.Option(None, "--state", help=_SIM_STATE_HELP + " Default 402."),
 ):
 	"""Add a SIM (POST /hermes/sims)."""
-	result = client.post("/hermes/sims", json_body={"ICCID": iccid, **_sim_body(operator_id, number, static_ip, apn, institutional, active)})
+	result = client.post("/hermes/sims", json_body={"ICCID": iccid, **_sim_body(operator_id, number, static_ip, apn, institutional, active, state)})
 	typer.echo(result.get("Message", result))
 
 
@@ -4341,10 +4401,11 @@ def sim_update(
 	static_ip: Optional[str] = typer.Option(None, "--static-ip"),
 	apn: Optional[str] = typer.Option(None, "--apn"),
 	institutional: Optional[bool] = typer.Option(None, "--institutional/--not-institutional"),
-	active: Optional[bool] = typer.Option(None, "--active/--inactive"),
+	active: Optional[bool] = typer.Option(None, "--active/--inactive", help="Shortcut for --state 402/403 (only if that changes whether it is in service)."),
+	state: Optional[int] = typer.Option(None, "--state", help=_SIM_STATE_HELP),
 ):
 	"""Update a SIM - only the options given change (PUT /hermes/sims/{iccid}). APN/operator are also refreshed from the device's own reports."""
-	body = _sim_body(operator_id, number, static_ip, apn, institutional, active)
+	body = _sim_body(operator_id, number, static_ip, apn, institutional, active, state)
 	if not body:
 		typer.echo("Nothing to update - give at least one option.")
 		raise typer.Exit(1)
@@ -4355,7 +4416,7 @@ def sim_update(
 # Delete a SIM - Refused by the API if a Device or any Stored Packet Uses it
 @sim_app.command("delete")
 def sim_delete(iccid: str = typer.Argument(...), yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt.")):
-	"""Delete an unused SIM (DELETE /hermes/sims/{iccid}). A SIM used by a device or any stored packet can't be deleted - deactivate it with `qapu sim update ICCID --inactive`."""
+	"""Delete an unused SIM (DELETE /hermes/sims/{iccid}). A SIM used by a device or any stored packet can't be deleted - retire it with `qapu sim update ICCID --state 405`."""
 	if not yes and not typer.confirm(f"Delete SIM {iccid}?"):
 		raise typer.Exit(0)
 	result = client.delete(f"/hermes/sims/{iccid}")
@@ -7473,68 +7534,47 @@ def mqtt_provision(device_id: str = typer.Argument(..., help="Device ID to provi
 # Metadata to Hermes.
 @fota_app.command("upload")
 def fota_upload(
-	file_path: str = typer.Argument(..., help="Local path to the firmware file to publish."),
+	file_path: str = typer.Argument(..., help="Local firmware binary. Name rules: 1-23 chars [A-Za-z0-9._-], ending .bin, first two characters = the version's major (e.g. 01.00.24.bin), at most 4 MB."),
 	version: str = typer.Option(..., "--version", help="MAJOR.MINOR.PATCH, e.g. 01.00.24."),
 	title: Optional[str] = typer.Option(None, "--title"),
 	description: Optional[str] = typer.Option(None, "--description"),
 	channel: Optional[str] = typer.Option(None, "--channel"),
-	active: Optional[bool] = typer.Option(None, "--active/--inactive"),
+	active: Optional[bool] = typer.Option(None, "--active/--inactive", help="Open (or close) the version for FOTA after the upload. Not the same as `qapu fota approve` (trial-boot confirmation)."),
 	release_notes: Optional[str] = typer.Option(None, "--release-notes"),
-	ftp_host: str = typer.Option(_FIRMWARE_SERVER_DEFAULT, "--ftp-host", help="The firmware FTP server's address - already resolves to the real public IP (confirmed live), same hostname `fota http`/`fota ftp` default to."),
-	http_base_url: str = typer.Option(f"https://{_FIRMWARE_SERVER_DEFAULT}", "--http-base-url", help="Base URL the file is reachable at over HTTP - used to build the catalog's File_URL."),
 ):
-	"""Publish a real firmware file end to end: compute its MD5, upload it to the firmware FTP server as cinga_ftp_admin, then add/update the version's catalog entry with the real file metadata. Needs QAPU_FTP_ADMIN_PASSWORD set."""
+	"""Publish a firmware file end to end through the API (2026-10-26): register the version in the catalog if it's new, upload the file (POST /hermes/firmware/{version}/file - the server stores it on the firmware FTP server and records name/size/MD5), then apply --active if given. No FTP password needed locally any more."""
 
 	# Validate Local File
 	if not os.path.isfile(file_path):
 		typer.echo(f"Error: '{file_path}' is not a file.", err=True)
 		raise typer.Exit(code=1)
 
-	# Resolve the FTP Admin Password - Same env-var Convention as QAPU_HERMES_KEY, Never Hardcoded
-	ftp_password = os.environ.get("QAPU_FTP_ADMIN_PASSWORD")
-	if not ftp_password:
-		typer.echo("Error: QAPU_FTP_ADMIN_PASSWORD environment variable is not set.", err=True)
-		raise typer.Exit(code=1)
-
-	file_name = os.path.basename(file_path)
-	file_size = os.path.getsize(file_path)
-
-	# Compute MD5 - Streamed, not Loaded Whole into Memory
+	# Local MD5 - the Server Recomputes it and Refuses (422) if They Differ
 	md5_hash = hashlib.md5()
 	with open(file_path, "rb") as handle:
-		for chunk in iter(lambda: handle.read(8192), b""):
+		for chunk in iter(lambda: handle.read(65536), b""):
 			md5_hash.update(chunk)
 	md5_hex = md5_hash.hexdigest()
 
-	typer.echo(f"Yükleniyor: {file_name} ({file_size} byte, md5={md5_hex}) -> {ftp_host}")
-
-	# Upload via FTP - the cinga_ftp_admin Account, Read-Write Home =
-	# /data/shared/firmware (see deploy/ops/ftp/docker-compose.yml)
-	try:
-		with ftplib.FTP(ftp_host, timeout=30) as ftp:
-			ftp.login("cinga_ftp_admin", ftp_password)
-			with open(file_path, "rb") as handle:
-				ftp.storbinary(f"STOR {file_name}", handle)
-	except ftplib.all_errors as e:
-		typer.echo(f"Error: FTP upload failed: {e}", err=True)
-		raise typer.Exit(code=1)
-
-	file_url = f"{http_base_url.rstrip('/')}/{file_name}"
+	# Register the Version First if it's New (Without File Fields or Active -
+	# Active Needs a File, so it's Applied Only After the Upload)
+	metadata = _firmware_field_body(title, description, channel, None, None, None, None, None, None, None, release_notes)
+	if client.get_or_none(f"/hermes/firmware/{version}") is None:
+		client.post("/hermes/firmware", json_body={"Version": version, **metadata})
+		typer.echo(f"Katalog kaydı açıldı: {version}")
+	elif metadata:
+		client.put(f"/hermes/firmware/{version}", json_body=metadata)
 
-	body = _firmware_field_body(title, description, channel, active, file_name, file_size, file_url, md5_hex, None, None, release_notes)
-	body["Version"] = version
+	typer.echo(f"Yükleniyor: {os.path.basename(file_path)} ({os.path.getsize(file_path)} byte, md5={md5_hex})")
+	result = client.post_file(f"/hermes/firmware/{version}/file", file_path, data={"md5": md5_hex})
+	typer.echo(f"Yüklendi: {result.get('File_Name')} ({result.get('File_Size')} byte, md5={result.get('Hash_MD5')})")
 
-	# Add if This Version is New, Update if it Already Exists - get_or_none()
-	# Treats a 404 as a Normal "Not Yet Registered" Outcome, not an Error
-	existing = client.get_or_none(f"/hermes/firmware/{version}")
-	if existing is not None:
-		result = client.put(f"/hermes/firmware/{version}", json_body=body)
-	else:
-		result = client.post("/hermes/firmware", json_body=body)
+	if active is not None:
+		client.put(f"/hermes/firmware/{version}", json_body={"Active": active})
+		typer.echo(f"Active={active}")
 
-	typer.echo(result.get("Message", result))
 	console.print()
-	console.print(f"[bold]Gönder:[/bold]  qapu fota ftp <device_id> --version {version}   (veya: qapu fota http <device_id> --version {version})")
+	console.print(f"[bold]Gönder:[/bold]  qapu fota ftp <device_id> --version {version}")
 
 
 # Send a `fotahttp` MQTT Command - no --auto-retry Option, FOTA Commands
@@ -7575,9 +7615,9 @@ def fota_http(
 @fota_app.command("ftp")
 def fota_ftp(
 	device_id: str = typer.Argument(..., help="Target device ID."),
-	server: str = typer.Option(_FIRMWARE_SERVER_DEFAULT, "--server", help="FTP server host (max 31 chars)."),
-	user: str = typer.Option("cinga_fota", "--user", help="FTP username (max 23 chars) - defaults to the standing read-only device account."),
-	password: Optional[str] = typer.Option(None, "--password", help="FTP password (max 23 chars) - falls back to QAPU_FTP_FOTA_PASSWORD if not given."),
+	server: Optional[str] = typer.Option(None, "--server", help="FTP server host (max 31 chars). Omitted: the server's own default (firmware.ovoo.com.tr)."),
+	user: Optional[str] = typer.Option(None, "--user", help="FTP username (max 23 chars). Omitted: the server's own download account (cinga_fota)."),
+	password: Optional[str] = typer.Option(None, "--password", help="FTP password (max 23 chars) - falls back to QAPU_FTP_FOTA_PASSWORD; if neither is set the server fills its own (2026-10-27)."),
 	version: Optional[str] = typer.Option(None, "--version", help="Look up --firmware/--md5 from the firmware catalog by version (GET /hermes/firmware/{version}) instead of passing them by hand."),
 	firmware: Optional[str] = typer.Option(None, "--firmware", help="Firmware file name (max 23 chars) - first two characters must match the device's compiled hardware version. Required unless --version is given."),
 	md5: Optional[str] = typer.Option(None, "--md5", help="MD5 hex digest of the firmware file (32 hex characters). Required unless --version is given."),
@@ -7586,11 +7626,11 @@ def fota_ftp(
 ):
 	"""Send a fotaftp command over MQTT - the device downloads firmware via FTP (POST /hermes/iot/mqtt/fotaftp/{device_id}). No duplicate protection on the device side - never auto-retried. Real sends transparently go through the two-phase prepare/execute confirmation model server-side - this command still reads as one call."""
 	password = password or os.environ.get("QAPU_FTP_FOTA_PASSWORD")
-	if not password:
-		typer.echo("Error: pass --password, or set QAPU_FTP_FOTA_PASSWORD.", err=True)
-		raise typer.Exit(code=1)
 	firmware, md5 = _resolve_firmware_fields(version, firmware, md5)
-	body: dict[str, Any] = {"server": server, "user": user, "password": password, "firmware": firmware, "md5": md5}
+	body: dict[str, Any] = {"firmware": firmware, "md5": md5}
+	for key, value in (("server", server), ("user", user), ("password", password)):
+		if value:
+			body[key] = value
 	if mode is not None:
 		body["mode"] = mode
 	params: dict[str, Any] = {"dry_run": dry_run}
@@ -7606,6 +7646,53 @@ def fota_ftp(
 		typer.echo(f"Preview: {result['Preview']}")
 
 
+# Firmware Confirmation (2026-10-26, Firmware Confirmation Protocol 1) -
+# Approve a Version so its Trial Boots are Confirmed Automatically
+# (fwconfirm), and Watch What Happens per Boot
+@fota_app.command("approve")
+def fota_approve(version: str = typer.Argument(..., help="Catalog version, e.g. 01.00.01."), note: Optional[str] = typer.Option(None, "--note")):
+	"""Approve a firmware version for automatic trial-boot confirmation (PUT /hermes/firmware-approvals/{version}). From now on every healthy trial boot of it gets a fwconfirm."""
+	result = client.put(f"/hermes/firmware-approvals/{version}", json_body={"Approved": True, **({"Note": note} if note else {})})
+	typer.echo(result.get("Message", result))
+
+
+@fota_app.command("revoke")
+def fota_revoke(version: str = typer.Argument(...), note: Optional[str] = typer.Option(None, "--note")):
+	"""Revoke a version's confirmation approval - no further fwconfirm (never a rollback; that is a separate FOTA)."""
+	result = client.put(f"/hermes/firmware-approvals/{version}", json_body={"Approved": False, **({"Note": note} if note else {})})
+	typer.echo(result.get("Message", result))
+
+
+@fota_app.command("approvals")
+def fota_approvals(as_json: bool = typer.Option(False, "--json")):
+	"""List versions approved (or revoked) for trial-boot confirmation (GET /hermes/firmware-approvals)."""
+	items: list[dict[str, Any]] = client.get("/hermes/firmware-approvals")
+	if as_json:
+		typer.echo(json.dumps(items, indent=2))
+		return
+	_print_paginated(items, _simple_table_builder([("VERSION", "Version"), ("APPROVED", "Approved"), ("CHANNEL", "Channel"), ("APPROVED_AT", "Approved_At"), ("REVOKED_AT", "Revoked_At"), ("NOTE", "Note")]), limit=None, noun="sürüm")
+
+
+@fota_app.command("confirmations")
+def fota_confirmations(
+	device_id: Optional[str] = typer.Option(None, "--device"),
+	state: Optional[str] = typer.Option(None, "--state", help="waiting, sent, acked, confirmed, superseded, review"),
+	limit: int = typer.Option(50, "--limit"),
+	as_json: bool = typer.Option(False, "--json"),
+):
+	"""Trial boots and their confirmation state, newest first (GET /hermes/firmware-confirmations). --state review = retry limit hit."""
+	params: dict[str, Any] = {"limit": limit}
+	if device_id:
+		params["device_id"] = device_id
+	if state:
+		params["state"] = state
+	items: list[dict[str, Any]] = client.get("/hermes/firmware-confirmations", params=params)
+	if as_json:
+		typer.echo(json.dumps(items, indent=2))
+		return
+	_print_paginated(items, _simple_table_builder([("DEVICE", "Device_ID"), ("FIRMWARE", "Firmware"), ("TOKEN", "Token"), ("STATE", "State"), ("TRIES", "Attempts"), ("ACK", "Ack_Code"), ("LAST_SEEN", "Last_Seen_At"), ("NOTE", "Last_Error")]), limit=limit, noun="açılış")
+
+
 # ------------------------------------------------------------
 # `qapu console` Lived Here (2026-09-13/14) Until the TUI (`qapu tui`)
 # Fully Superseded it (2026-10-12, Direct Request: "tui yaptıkdan sonra

{qapu_cli-0.78.0 → qapu_cli-0.80.0}/qapu_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qapu-cli
-Version: 0.78.0
+Version: 0.80.0
 Summary: CLI client for the Qapu API - built for the Hermes agent, but usable by anyone talking to api.ovoo.com.tr from outside the Swarm.
 Author: OVOO Technology
 Classifier: Programming Language :: Python :: 3