@geolonia/geonicdb-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,3413 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { createRequire as createRequire3 } from "module";
+import { Command as Command2 } from "commander";
+
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function getConfigDir() {
+  return process.env.GEONIC_CONFIG_DIR ?? join(homedir(), ".config", "geonic");
+}
+function getConfigFile() {
+  return join(getConfigDir(), "config.json");
+}
+function ensureConfigDir() {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function migrateV1ToV2(data) {
+  const profile = {};
+  const knownKeys = [
+    "url",
+    "service",
+    "token",
+    "refreshToken",
+    "format",
+    "apiKey"
+  ];
+  for (const key of knownKeys) {
+    if (key in data) {
+      profile[key] = data[key];
+    }
+  }
+  return {
+    version: 2,
+    currentProfile: "default",
+    profiles: { default: profile }
+  };
+}
+function isGdbConfigFile(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return v.version === 2 && typeof v.currentProfile === "string" && typeof v.profiles === "object" && v.profiles !== null;
+}
+function defaultConfig() {
+  return { version: 2, currentProfile: "default", profiles: { default: {} } };
+}
+function loadConfigFile() {
+  try {
+    const raw = readFileSync(getConfigFile(), "utf-8");
+    const data = JSON.parse(raw);
+    if (!("version" in data)) {
+      const migrated = migrateV1ToV2(data);
+      saveConfigFile(migrated);
+      return migrated;
+    }
+    if (!isGdbConfigFile(data)) {
+      return defaultConfig();
+    }
+    return data;
+  } catch {
+    return defaultConfig();
+  }
+}
+function saveConfigFile(configFile) {
+  ensureConfigDir();
+  writeFileSync(getConfigFile(), JSON.stringify(configFile, null, 2) + "\n", "utf-8");
+}
+function loadConfig(profileName) {
+  const configFile = loadConfigFile();
+  const name = profileName ?? configFile.currentProfile;
+  return configFile.profiles[name] ?? {};
+}
+function saveConfig(config, profileName) {
+  const configFile = loadConfigFile();
+  const name = profileName ?? configFile.currentProfile;
+  configFile.profiles[name] = config;
+  saveConfigFile(configFile);
+}
+function getConfigValue(key, profileName) {
+  const config = loadConfig(profileName);
+  return config[key];
+}
+function validateUrl(url) {
+  url = url.trim();
+  if (!url) {
+    throw new Error("URL must not be empty.");
+  }
+  if (!/^https?:\/\//i.test(url)) {
+    throw new Error(`Invalid URL: "${url}". URL must start with http:// or https://.`);
+  }
+  try {
+    new URL(url);
+  } catch {
+    throw new Error(`Invalid URL: "${url}".`);
+  }
+  return url.replace(/\/+$/, "") + "/";
+}
+function setConfigValue(key, value, profileName) {
+  const config = loadConfig(profileName);
+  if (key === "url") {
+    value = validateUrl(value);
+  }
+  config[key] = value;
+  saveConfig(config, profileName);
+}
+function deleteConfigValue(key, profileName) {
+  const config = loadConfig(profileName);
+  delete config[key];
+  saveConfig(config, profileName);
+}
+function getConfigPath() {
+  return getConfigFile();
+}
+function listProfiles() {
+  const configFile = loadConfigFile();
+  return Object.keys(configFile.profiles).map((name) => ({
+    name,
+    active: name === configFile.currentProfile
+  }));
+}
+function getCurrentProfile() {
+  return loadConfigFile().currentProfile;
+}
+function setCurrentProfile(name) {
+  const configFile = loadConfigFile();
+  if (!(name in configFile.profiles)) {
+    throw new Error(`Profile "${name}" does not exist.`);
+  }
+  configFile.currentProfile = name;
+  saveConfigFile(configFile);
+}
+function createProfile(name) {
+  const configFile = loadConfigFile();
+  if (name in configFile.profiles) {
+    throw new Error(`Profile "${name}" already exists.`);
+  }
+  configFile.profiles[name] = {};
+  saveConfigFile(configFile);
+}
+function deleteProfile(name) {
+  if (name === "default") {
+    throw new Error('Cannot delete the "default" profile.');
+  }
+  const configFile = loadConfigFile();
+  if (!(name in configFile.profiles)) {
+    throw new Error(`Profile "${name}" does not exist.`);
+  }
+  delete configFile.profiles[name];
+  if (configFile.currentProfile === name) {
+    configFile.currentProfile = "default";
+  }
+  saveConfigFile(configFile);
+}
+
+// src/output.ts
+import chalk from "chalk";
+function formatOutput(data, format) {
+  switch (format) {
+    case "json":
+      return JSON.stringify(data, null, 2);
+    case "table":
+      return formatTable(data);
+    case "geojson":
+      return JSON.stringify(toGeoJSON(data), null, 2);
+    default:
+      return JSON.stringify(data, null, 2);
+  }
+}
+function printOutput(data, format) {
+  console.log(formatOutput(data, format));
+}
+function printSuccess(message) {
+  console.log(chalk.green(message));
+}
+function printError(message) {
+  console.error(chalk.red(`Error: ${message}`));
+}
+function printInfo(message) {
+  console.log(chalk.cyan(message));
+}
+function printWarning(message) {
+  console.error(chalk.yellow(message));
+}
+function printCount(count) {
+  console.log(chalk.dim(`Count: ${count}`));
+}
+function formatTable(data) {
+  if (!Array.isArray(data)) {
+    if (typeof data === "object" && data !== null) {
+      return formatObjectTable(data);
+    }
+    return String(data);
+  }
+  if (data.length === 0) return "(empty)";
+  const items = data;
+  const keys = collectKeys(items);
+  const widths = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    widths.set(key, key.length);
+  }
+  for (const item of items) {
+    for (const key of keys) {
+      const val = cellValue(item[key]);
+      widths.set(key, Math.max(widths.get(key), val.length));
+    }
+  }
+  const header2 = keys.map((k) => chalk.bold(k.padEnd(widths.get(k)))).join("  ");
+  const separator = keys.map((k) => "\u2500".repeat(widths.get(k))).join("\u2500\u2500");
+  const rows = items.map(
+    (item) => keys.map((k) => cellValue(item[k]).padEnd(widths.get(k))).join("  ")
+  );
+  return [header2, separator, ...rows].join("\n");
+}
+function formatObjectTable(obj) {
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return "(empty)";
+  const keyWidth = Math.max(...entries.map(([k]) => k.length));
+  return entries.map(([k, v]) => `${chalk.bold(k.padEnd(keyWidth))}  ${cellValue(v)}`).join("\n");
+}
+function collectKeys(items) {
+  const priority = ["id", "type"];
+  const keySet = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    for (const key of Object.keys(item)) {
+      keySet.add(key);
+    }
+  }
+  const sorted = [];
+  for (const p of priority) {
+    if (keySet.has(p)) {
+      sorted.push(p);
+      keySet.delete(p);
+    }
+  }
+  sorted.push(...Array.from(keySet).sort());
+  return sorted;
+}
+function cellValue(val) {
+  if (val === void 0 || val === null) return "";
+  if (typeof val === "object") {
+    const obj = val;
+    if ("value" in obj) return String(obj.value);
+    return JSON.stringify(val);
+  }
+  return String(val);
+}
+function toGeoJSON(data) {
+  if (Array.isArray(data)) {
+    return {
+      type: "FeatureCollection",
+      features: data.map(entityToFeature)
+    };
+  }
+  return entityToFeature(data);
+}
+function entityToFeature(entity) {
+  if (typeof entity !== "object" || entity === null) {
+    return { type: "Feature", geometry: null, properties: entity };
+  }
+  const obj = entity;
+  let geometry = null;
+  if (obj.location) {
+    const loc = obj.location;
+    geometry = loc.value ?? loc;
+  }
+  const properties = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (key === "location") continue;
+    if (typeof value === "object" && value !== null && "value" in value) {
+      properties[key] = value.value;
+    } else {
+      properties[key] = value;
+    }
+  }
+  return { type: "Feature", geometry, properties };
+}
+
+// src/commands/help.ts
+import chalk2 from "chalk";
+var examplesMap = /* @__PURE__ */ new WeakMap();
+function addExamples(cmd, examples) {
+  examplesMap.set(cmd, examples);
+}
+function header(title) {
+  return chalk2.yellow.bold(title);
+}
+function findCommand(parent, name) {
+  return parent.commands.find(
+    (c) => c.name() === name || c.aliases().includes(name)
+  );
+}
+function getCommandPath(cmd) {
+  const parts = [];
+  let current = cmd;
+  while (current) {
+    parts.unshift(current.name());
+    current = current.parent;
+  }
+  return parts.join(" ");
+}
+function getRootProgram(cmd) {
+  let root = cmd;
+  while (root.parent) {
+    root = root.parent;
+  }
+  return root;
+}
+function formatOptionSynopsis(opt) {
+  const flag = opt.long || opt.short || "";
+  if (opt.required) {
+    const match = opt.flags.match(/<([^>]+)>/);
+    const valueName = match ? match[1] : "value";
+    return `[${flag}=<${valueName}>]`;
+  } else if (opt.optional) {
+    const match = opt.flags.match(/\[([^\]]+)\]/);
+    const valueName = match ? match[1] : "value";
+    return `[${flag}[=<${valueName}>]]`;
+  }
+  return `[${flag}]`;
+}
+function formatSynopsis(path, cmd) {
+  const parts = [path];
+  for (const arg of cmd.registeredArguments) {
+    if (arg.required) {
+      parts.push(`<${arg.name()}>`);
+    } else {
+      parts.push(`[<${arg.name()}>]`);
+    }
+  }
+  for (const opt of cmd.options) {
+    if (opt.hidden) continue;
+    parts.push(formatOptionSynopsis(opt));
+  }
+  return parts.join(" ");
+}
+function formatOptionList(options) {
+  const maxLen = Math.max(...options.map((o) => o.flags.length));
+  return options.map((opt) => {
+    const flags = opt.flags.padEnd(maxLen + 2);
+    return `  ${chalk2.green(flags)}${opt.description ?? ""}`;
+  });
+}
+function formatGlobalParameters(program2) {
+  const lines = [];
+  lines.push(header("GLOBAL PARAMETERS"));
+  lines.push("");
+  lines.push(...formatOptionList(program2.options));
+  lines.push("");
+  return lines.join("\n");
+}
+function formatTopLevelHelp(program2) {
+  const lines = [];
+  lines.push(header("NAME"));
+  lines.push("");
+  lines.push(`  ${program2.name()}`);
+  lines.push("");
+  lines.push(header("DESCRIPTION"));
+  lines.push("");
+  lines.push(`  ${program2.description()}`);
+  lines.push("");
+  lines.push(header("AVAILABLE COMMANDS"));
+  lines.push("");
+  const commands = program2.commands.filter((c) => !c._hidden).slice().sort((a, b) => a.name().localeCompare(b.name()));
+  const maxLen = Math.max(...commands.map((c) => c.name().length));
+  for (const cmd of commands) {
+    const name = cmd.name().padEnd(maxLen + 2);
+    lines.push(`  ${chalk2.green(name)}${cmd.summary() || cmd.description()}`);
+  }
+  lines.push("");
+  lines.push(formatGlobalParameters(program2));
+  return lines.join("\n");
+}
+function formatCommandDetails(program2, cmd, path) {
+  const lines = [];
+  lines.push(header("NAME"));
+  lines.push("");
+  const aliases = cmd.aliases().filter((a) => a.length > 0);
+  if (aliases.length > 0) {
+    lines.push(`  ${path} ${chalk2.dim(`(alias: ${aliases.join(", ")})`)}`);
+  } else {
+    lines.push(`  ${path}`);
+  }
+  lines.push("");
+  lines.push(header("DESCRIPTION"));
+  lines.push("");
+  for (const descLine of cmd.description().split("\n")) {
+    lines.push(`  ${descLine}`);
+  }
+  const subcommands = cmd.commands.filter(
+    (c) => !c._hidden
+  );
+  if (subcommands.length > 0) {
+    lines.push("");
+    lines.push(header("SYNOPSIS"));
+    lines.push("");
+    lines.push(`  ${path} <command>`);
+    lines.push("");
+    lines.push(header("SUBCOMMANDS"));
+    lines.push("");
+    const maxLen = Math.max(...subcommands.map((c) => c.name().length));
+    for (const sub of subcommands) {
+      const name = sub.name().padEnd(maxLen + 2);
+      lines.push(`  ${chalk2.green(name)}${sub.summary() || sub.description()}`);
+    }
+  } else {
+    lines.push("");
+    lines.push(header("SYNOPSIS"));
+    lines.push("");
+    lines.push(`  ${formatSynopsis(path, cmd)}`);
+    const options = cmd.options.filter((o) => !o.hidden);
+    if (options.length > 0) {
+      lines.push("");
+      lines.push(header("OPTIONS"));
+      lines.push("");
+      lines.push(...formatOptionList(options));
+    }
+  }
+  const examples = examplesMap.get(cmd);
+  if (examples && examples.length > 0) {
+    lines.push("");
+    lines.push(header("EXAMPLES"));
+    lines.push("");
+    for (const ex of examples) {
+      lines.push(`  ${ex.description}:`);
+      lines.push(`    $ ${ex.command}`);
+      lines.push("");
+    }
+  }
+  lines.push("");
+  lines.push(formatGlobalParameters(program2));
+  return lines.join("\n");
+}
+function showHelp(program2, args) {
+  if (args.length === 0) {
+    console.log(formatTopLevelHelp(program2));
+    return;
+  }
+  let current = program2;
+  const resolved = [];
+  for (let i = 0; i < args.length; i++) {
+    const found = findCommand(current, args[i]);
+    if (!found) {
+      const attempted = args.slice(0, i + 1).join(" ");
+      console.error(
+        chalk2.red(`Error: '${attempted}' is not a geonic command.`)
+      );
+      console.error(`
+See 'geonic help' for available commands.`);
+      process.exit(1);
+    }
+    resolved.push(found);
+    current = found;
+  }
+  const target = resolved[resolved.length - 1];
+  const path = [program2.name(), ...resolved.map((c) => c.name())].join(" ");
+  console.log(formatCommandDetails(program2, target, path));
+}
+function registerHelpCommand(program2) {
+  program2.addHelpCommand(false);
+  program2.configureHelp({
+    formatHelp: (cmd, _helper) => {
+      const root = getRootProgram(cmd);
+      if (cmd === root) {
+        return formatTopLevelHelp(root);
+      }
+      const path = getCommandPath(cmd);
+      return formatCommandDetails(root, cmd, path);
+    }
+  });
+  program2.command("help").description("Get help on a specific command").argument("[args...]").allowUnknownOption().action((args) => {
+    showHelp(program2, args);
+  });
+  program2.argument("[command...]").action((commands) => {
+    if (commands.length > 0) {
+      console.error(
+        `geonic: '${commands[0]}' is not a geonic command. See 'geonic help'.`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    showHelp(program2, []);
+  });
+}
+
+// src/commands/config.ts
+var SENSITIVE_CONFIG_KEYS = /* @__PURE__ */ new Set(["token", "refreshToken", "apiKey"]);
+function registerConfigCommand(program2) {
+  const config = program2.command("config").description("Manage CLI configuration");
+  const set = config.command("set").description("Save a config value").argument(
+    "<key>",
+    "Configuration key (url, service, token, refreshToken, format, apiKey)"
+  ).argument("<value>", "Configuration value").action((...args) => {
+    const cmd = args[args.length - 1];
+    const key = args[0];
+    const value = args[1];
+    const profile = cmd.optsWithGlobals().profile;
+    setConfigValue(key, value, profile);
+    const display = SENSITIVE_CONFIG_KEYS.has(key) ? "***" : value;
+    printSuccess(`Set ${key} = ${display}`);
+  });
+  addExamples(set, [
+    {
+      description: "Set server URL",
+      command: "geonic config set url https://api.example.com"
+    },
+    {
+      description: "Set tenant (NGSILD-Tenant header)",
+      command: "geonic config set service my-tenant"
+    },
+    {
+      description: "Set authentication token",
+      command: "geonic config set token eyJhbGciOi..."
+    },
+    {
+      description: "Set API key",
+      command: "geonic config set apiKey your-api-key"
+    },
+    {
+      description: "Set default output format",
+      command: "geonic config set format table"
+    },
+    {
+      description: "Set config for a specific profile",
+      command: "geonic config set url https://staging.example.com --profile staging"
+    }
+  ]);
+  const get = config.command("get").description("Get a config value").argument("<key>", "Configuration key").action((...args) => {
+    const cmd = args[args.length - 1];
+    const key = args[0];
+    const profile = cmd.optsWithGlobals().profile;
+    const value = getConfigValue(key, profile);
+    if (value === void 0) {
+      printInfo(`Key "${key}" is not set.`);
+    } else {
+      printOutput(value, "json");
+    }
+  });
+  addExamples(get, [
+    {
+      description: "Get server URL",
+      command: "geonic config get url"
+    },
+    {
+      description: "Get config value for a specific profile",
+      command: "geonic config get url --profile staging"
+    }
+  ]);
+  const list = config.command("list").description("List all config values").action((...args) => {
+    const cmd = args[args.length - 1];
+    const profile = cmd.optsWithGlobals().profile;
+    const all = loadConfig(profile);
+    if (Object.keys(all).length === 0) {
+      printInfo(`No configuration set. Config path: ${getConfigPath()}`);
+    } else {
+      printOutput(all, "json");
+    }
+  });
+  addExamples(list, [
+    {
+      description: "List all configuration values",
+      command: "geonic config list"
+    }
+  ]);
+  const del = config.command("delete").description("Delete a config value").argument("<key>", "Configuration key").action((...args) => {
+    const cmd = args[args.length - 1];
+    const key = args[0];
+    const profile = cmd.optsWithGlobals().profile;
+    deleteConfigValue(key, profile);
+    printSuccess(`Deleted key "${key}".`);
+  });
+  addExamples(del, [
+    {
+      description: "Delete a config value",
+      command: "geonic config delete url"
+    }
+  ]);
+}
+
+// src/commands/auth.ts
+import { Command } from "commander";
+
+// src/client.ts
+var GdbClient = class _GdbClient {
+  baseUrl;
+  service;
+  token;
+  refreshToken;
+  apiKey;
+  onTokenRefresh;
+  verbose;
+  refreshPromise;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.service = options.service;
+    this.token = options.token;
+    this.refreshToken = options.refreshToken;
+    this.apiKey = options.apiKey;
+    this.onTokenRefresh = options.onTokenRefresh;
+    this.verbose = options.verbose ?? false;
+  }
+  buildHeaders(extra) {
+    const headers = {};
+    headers["Content-Type"] = "application/ld+json";
+    headers["Accept"] = "application/ld+json";
+    if (this.service) headers["NGSILD-Tenant"] = this.service;
+    if (this.token) {
+      headers["Authorization"] = `Bearer ${this.token}`;
+    } else if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    if (extra) {
+      Object.assign(headers, extra);
+    }
+    return headers;
+  }
+  buildUrl(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== "") {
+          url.searchParams.set(key, value);
+        }
+      }
+    }
+    return url.toString();
+  }
+  getBasePath() {
+    return "/ngsi-ld/v1";
+  }
+  static SENSITIVE_HEADERS = /* @__PURE__ */ new Set(["authorization"]);
+  static SENSITIVE_BODY_KEYS = /* @__PURE__ */ new Set([
+    "password",
+    "refreshToken",
+    "token",
+    "client_secret",
+    "clientSecret"
+  ]);
+  logRequest(method, url, headers, body) {
+    if (!this.verbose) return;
+    process.stderr.write(`> ${method} ${url}
+`);
+    for (const [k, v] of Object.entries(headers)) {
+      if (_GdbClient.SENSITIVE_HEADERS.has(k.toLowerCase())) {
+        process.stderr.write(`> ${k}: ***
+`);
+      } else {
+        process.stderr.write(`> ${k}: ${v}
+`);
+      }
+    }
+    if (body) {
+      process.stderr.write(`> Body: ${_GdbClient.maskBodySecrets(body)}
+`);
+    }
+    process.stderr.write("\n");
+  }
+  static maskBodySecrets(raw) {
+    try {
+      const obj = JSON.parse(raw);
+      for (const key of Object.keys(obj)) {
+        if (_GdbClient.SENSITIVE_BODY_KEYS.has(key)) {
+          obj[key] = "***";
+        }
+      }
+      return JSON.stringify(obj);
+    } catch {
+      return raw;
+    }
+  }
+  logResponse(response) {
+    if (!this.verbose) return;
+    process.stderr.write(`< ${response.status} ${response.statusText}
+`);
+    response.headers.forEach((v, k) => {
+      process.stderr.write(`< ${k}: ${v}
+`);
+    });
+    process.stderr.write("\n");
+  }
+  canRefresh() {
+    return !!this.refreshToken && !this.apiKey;
+  }
+  async performTokenRefresh() {
+    if (this.refreshPromise) return this.refreshPromise;
+    this.refreshPromise = this.doRefresh();
+    try {
+      return await this.refreshPromise;
+    } finally {
+      this.refreshPromise = void 0;
+    }
+  }
+  async doRefresh() {
+    if (!this.refreshToken) return false;
+    try {
+      const url = this.buildUrl("/auth/refresh");
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ refreshToken: this.refreshToken })
+      });
+      if (!response.ok) return false;
+      const data = await response.json();
+      const newToken = data.accessToken ?? data.token;
+      const newRefreshToken = data.refreshToken;
+      if (!newToken) return false;
+      this.token = newToken;
+      if (newRefreshToken) this.refreshToken = newRefreshToken;
+      this.onTokenRefresh?.(newToken, newRefreshToken);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async executeRequest(method, path, options) {
+    const url = this.buildUrl(`${this.getBasePath()}${path}`, options?.params);
+    const headers = this.buildHeaders(options?.headers);
+    const body = options?.body ? JSON.stringify(options.body) : void 0;
+    this.logRequest(method, url, headers, body);
+    const response = await fetch(url, { method, headers, body });
+    this.logResponse(response);
+    const countHeader = response.headers.get("NGSILD-Results-Count");
+    const count = countHeader ? parseInt(countHeader, 10) : void 0;
+    let data;
+    const contentType = response.headers.get("content-type") ?? "";
+    const text = await response.text();
+    if (text && (contentType.includes("json") || contentType.includes("ld+json"))) {
+      data = JSON.parse(text);
+    } else {
+      data = text;
+    }
+    if (!response.ok) {
+      const err = data;
+      const message = err?.description || err?.detail || err?.error || err?.title || `HTTP ${response.status}`;
+      throw new GdbClientError(message, response.status, err);
+    }
+    return { status: response.status, headers: response.headers, data, count };
+  }
+  async executeRawRequest(method, path, options) {
+    const url = this.buildUrl(path, options?.params);
+    const headers = this.buildHeaders(options?.headers);
+    const body = options?.body ? JSON.stringify(options.body) : void 0;
+    this.logRequest(method, url, headers, body);
+    const response = await fetch(url, { method, headers, body });
+    this.logResponse(response);
+    let data;
+    const contentType = response.headers.get("content-type") ?? "";
+    const text = await response.text();
+    if (text && (contentType.includes("json") || contentType.includes("ld+json"))) {
+      data = JSON.parse(text);
+    } else {
+      data = text;
+    }
+    if (!response.ok) {
+      const err = data;
+      const message = err?.description || err?.detail || err?.error || err?.title || `HTTP ${response.status}`;
+      throw new GdbClientError(message, response.status, err);
+    }
+    return { status: response.status, headers: response.headers, data };
+  }
+  async request(method, path, options) {
+    try {
+      return await this.executeRequest(method, path, options);
+    } catch (err) {
+      if (err instanceof GdbClientError && err.status === 401 && this.canRefresh()) {
+        const refreshed = await this.performTokenRefresh();
+        if (refreshed) {
+          return await this.executeRequest(method, path, options);
+        }
+      }
+      throw err;
+    }
+  }
+  async get(path, params, headers) {
+    return this.request("GET", path, { params, headers });
+  }
+  async post(path, body, params) {
+    return this.request("POST", path, { body, params });
+  }
+  async patch(path, body, params) {
+    return this.request("PATCH", path, { body, params });
+  }
+  async put(path, body, params) {
+    return this.request("PUT", path, { body, params });
+  }
+  async delete(path, params) {
+    return this.request("DELETE", path, { params });
+  }
+  /** Make a request to a raw URL path (not prefixed with API base path) */
+  async rawRequest(method, path, options) {
+    try {
+      return await this.executeRawRequest(method, path, options);
+    } catch (err) {
+      if (err instanceof GdbClientError && err.status === 401 && this.canRefresh()) {
+        const refreshed = await this.performTokenRefresh();
+        if (refreshed) {
+          return await this.executeRawRequest(method, path, options);
+        }
+      }
+      throw err;
+    }
+  }
+};
+var GdbClientError = class extends Error {
+  constructor(message, status, ngsiError) {
+    super(message);
+    this.status = status;
+    this.ngsiError = ngsiError;
+    this.name = "GdbClientError";
+  }
+};
+
+// src/helpers.ts
+function resolveOptions(cmd) {
+  const opts = cmd.optsWithGlobals();
+  const config = loadConfig(opts.profile);
+  return {
+    url: opts.url ?? config.url,
+    service: opts.service ?? config.service,
+    token: opts.token ?? config.token,
+    format: opts.format ?? config.format ?? "json",
+    color: opts.color,
+    verbose: opts.verbose,
+    profile: opts.profile,
+    apiKey: opts.apiKey ?? process.env.GDB_API_KEY ?? config.apiKey
+  };
+}
+function createClient(cmd) {
+  const opts = resolveOptions(cmd);
+  if (!opts.url) {
+    printError("No URL configured. Use `geonic config set url <url>` or pass --url.");
+    process.exit(1);
+  }
+  opts.url = validateUrl(opts.url);
+  const cliOpts = cmd.optsWithGlobals();
+  const usingCliToken = !!cliOpts.token;
+  const config = loadConfig(opts.profile);
+  return new GdbClient({
+    baseUrl: opts.url,
+    service: opts.service,
+    token: opts.token,
+    refreshToken: usingCliToken ? void 0 : config.refreshToken,
+    apiKey: opts.apiKey,
+    onTokenRefresh: usingCliToken ? void 0 : (token, refreshToken) => {
+      const cfg = loadConfig(opts.profile);
+      cfg.token = token;
+      if (refreshToken) cfg.refreshToken = refreshToken;
+      saveConfig(cfg, opts.profile);
+    },
+    verbose: opts.verbose
+  });
+}
+function getFormat(cmd) {
+  const opts = resolveOptions(cmd);
+  return opts.format;
+}
+function outputResponse(response, format, showCount) {
+  if (showCount && response.count !== void 0) {
+    printCount(response.count);
+  }
+  if (response.data !== void 0 && response.data !== "") {
+    printOutput(response.data, format);
+  }
+}
+function withErrorHandler(fn) {
+  return async (...args) => {
+    try {
+      await fn(...args);
+    } catch (err) {
+      if (err instanceof GdbClientError && err.status === 401) {
+        printError("Authentication failed. Please run `geonic login` to re-authenticate.");
+      } else if (err instanceof Error) {
+        printError(err.message);
+      } else {
+        printError(String(err));
+      }
+      process.exit(1);
+    }
+  };
+}
+
+// src/prompt.ts
+import { createInterface } from "readline/promises";
+function isInteractive() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+async function promptEmail() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const email = await rl.question("Email: ");
+    return email.trim();
+  } finally {
+    rl.close();
+  }
+}
+async function promptPassword() {
+  return new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    stdout.write("Password: ");
+    if (!stdin.isTTY) {
+      let data = "";
+      stdin.setEncoding("utf-8");
+      stdin.resume();
+      const cleanup = () => {
+        stdin.removeListener("data", onData2);
+        stdin.removeListener("end", onEnd);
+        stdin.removeListener("error", onError2);
+        stdin.pause();
+      };
+      const onData2 = (chunk) => {
+        const newline = chunk.indexOf("\n");
+        if (newline !== -1) {
+          data += chunk.slice(0, newline);
+          cleanup();
+          stdout.write("\n");
+          resolve(data);
+        } else {
+          data += chunk;
+        }
+      };
+      const onEnd = () => {
+        cleanup();
+        stdout.write("\n");
+        resolve(data);
+      };
+      const onError2 = (err) => {
+        cleanup();
+        reject(err);
+      };
+      stdin.on("data", onData2);
+      stdin.on("end", onEnd);
+      stdin.on("error", onError2);
+      return;
+    }
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf-8");
+    let password = "";
+    const restoreTerminal = () => {
+      stdin.removeListener("data", onData);
+      stdin.removeListener("error", onError);
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+    };
+    const onError = (err) => {
+      restoreTerminal();
+      stdout.write("\n");
+      reject(err);
+    };
+    const onData = (char) => {
+      const code = char.charCodeAt(0);
+      if (char === "\r" || char === "\n") {
+        restoreTerminal();
+        stdout.write("\n");
+        resolve(password);
+      } else if (code === 3) {
+        restoreTerminal();
+        stdout.write("\n");
+        reject(new Error("User cancelled"));
+      } else if (code === 127 || code === 8) {
+        if (password.length > 0) {
+          password = password.slice(0, -1);
+          stdout.write("\b \b");
+        }
+      } else if (code >= 32) {
+        password += char;
+        stdout.write("*");
+      }
+    };
+    stdin.on("data", onData);
+    stdin.on("error", onError);
+  });
+}
+
+// src/token.ts
+function decodeJwtPayload(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    const payload = parts[1];
+    const json = Buffer.from(payload, "base64").toString("utf-8");
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+}
+function getTokenStatus(token) {
+  const payload = decodeJwtPayload(token);
+  if (!payload || typeof payload.exp !== "number") {
+    return { expiresAt: null, isExpired: false, isExpiringSoon: false, remainingMs: null };
+  }
+  const expiresAt = new Date(payload.exp * 1e3);
+  const now = Date.now();
+  const remainingMs = expiresAt.getTime() - now;
+  const fiveMinutes = 5 * 60 * 1e3;
+  return {
+    expiresAt,
+    isExpired: remainingMs <= 0,
+    isExpiringSoon: remainingMs > 0 && remainingMs <= fiveMinutes,
+    remainingMs
+  };
+}
+function formatDuration(ms) {
+  if (ms <= 0) return "expired";
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const parts = [];
+  if (days > 0) parts.push(`${days}d`);
+  if (hours % 24 > 0) parts.push(`${hours % 24}h`);
+  if (minutes % 60 > 0 && days === 0) parts.push(`${minutes % 60}m`);
+  if (parts.length === 0) parts.push(`${seconds}s`);
+  return parts.join(" ");
+}
+
+// src/oauth.ts
+async function clientCredentialsGrant(options) {
+  const url = new URL("/oauth/token", options.baseUrl).toString();
+  const credentials = Buffer.from(`${options.clientId}:${options.clientSecret}`).toString("base64");
+  const params = new URLSearchParams();
+  params.set("grant_type", "client_credentials");
+  if (options.scope) {
+    params.set("scope", options.scope);
+  }
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Authorization: `Basic ${credentials}`
+    },
+    body: params.toString()
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    let message;
+    try {
+      const err = JSON.parse(text);
+      message = err.error_description ?? err.error ?? text;
+    } catch {
+      message = text || `HTTP ${response.status}`;
+    }
+    throw new Error(`OAuth token request failed: ${message}`);
+  }
+  return await response.json();
+}
+
+// src/commands/auth.ts
+import chalk3 from "chalk";
+function createLoginCommand() {
+  return new Command("login").description("Authenticate and save token").option("--client-credentials", "Use OAuth 2.0 Client Credentials flow").option("--client-id <id>", "OAuth client ID").option("--client-secret <secret>", "OAuth client secret").option("--scope <scopes>", "OAuth scopes (space-separated)").option("--tenant-id <id>", "Tenant ID for scoped authentication").action(
+    withErrorHandler(async (...args) => {
+      const cmd = args[args.length - 1];
+      const loginOpts = cmd.opts();
+      const globalOpts = resolveOptions(cmd);
+      if (loginOpts.clientCredentials) {
+        const clientId = loginOpts.clientId ?? process.env.GDB_OAUTH_CLIENT_ID;
+        const clientSecret = loginOpts.clientSecret ?? process.env.GDB_OAUTH_CLIENT_SECRET;
+        if (!clientId || !clientSecret) {
+          printError(
+            "Client ID and secret are required. Use --client-id/--client-secret or GDB_OAUTH_CLIENT_ID/GDB_OAUTH_CLIENT_SECRET."
+          );
+          process.exit(1);
+        }
+        if (!globalOpts.url) {
+          printError("No URL configured. Use `geonic config set url <url>` or pass --url.");
+          process.exit(1);
+        }
+        const result = await clientCredentialsGrant({
+          baseUrl: globalOpts.url,
+          clientId,
+          clientSecret,
+          scope: loginOpts.scope
+        });
+        const config2 = loadConfig(globalOpts.profile);
+        config2.token = result.access_token;
+        delete config2.refreshToken;
+        saveConfig(config2, globalOpts.profile);
+        printSuccess("Login successful (OAuth Client Credentials). Token saved to config.");
+        return;
+      }
+      let email = process.env.GDB_EMAIL;
+      let password = process.env.GDB_PASSWORD;
+      if (!email || !password) {
+        if (isInteractive()) {
+          if (!email) email = await promptEmail();
+          if (!password) password = await promptPassword();
+        } else {
+          printError(
+            "Set GDB_EMAIL and GDB_PASSWORD environment variables, or run in a terminal for interactive login."
+          );
+          process.exit(1);
+        }
+      }
+      const client = createClient(cmd);
+      const body = { email, password };
+      if (loginOpts.tenantId) {
+        body.tenantId = loginOpts.tenantId;
+      }
+      const response = await client.rawRequest("POST", "/auth/login", { body });
+      const data = response.data;
+      const token = data.accessToken ?? data.token;
+      const refreshToken = data.refreshToken;
+      if (!token) {
+        printError("No token received from server.");
+        process.exit(1);
+      }
+      const config = loadConfig(globalOpts.profile);
+      config.token = token;
+      if (refreshToken) {
+        config.refreshToken = refreshToken;
+      } else {
+        delete config.refreshToken;
+      }
+      saveConfig(config, globalOpts.profile);
+      printSuccess("Login successful. Token saved to config.");
+    })
+  );
+}
+function createLogoutCommand() {
+  return new Command("logout").description("Clear saved authentication token").action(
+    withErrorHandler(async (...args) => {
+      const cmd = args[args.length - 1];
+      const globalOpts = resolveOptions(cmd);
+      const config = loadConfig(globalOpts.profile);
+      if (config.token && globalOpts.url) {
+        try {
+          const client = createClient(cmd);
+          await client.rawRequest("POST", "/auth/logout");
+        } catch {
+        }
+      }
+      delete config.token;
+      delete config.refreshToken;
+      saveConfig(config, globalOpts.profile);
+      printSuccess("Logged out. Token cleared from config.");
+    })
+  );
+}
+function createMeAction() {
+  return withErrorHandler(async (...args) => {
+    const cmd = args[args.length - 1];
+    const globalOpts = resolveOptions(cmd);
+    if (!globalOpts.token && !globalOpts.apiKey) {
+      printInfo("Not logged in. Use `geonic auth login` to authenticate.");
+      return;
+    }
+    const client = createClient(cmd);
+    const format = getFormat(cmd);
+    const response = await client.rawRequest("GET", "/me");
+    outputResponse(response, format);
+    if (format && format !== "table") {
+      return;
+    }
+    const latestConfig = loadConfig(globalOpts.profile);
+    if (latestConfig.token) {
+      const status = getTokenStatus(latestConfig.token);
+      if (status.expiresAt) {
+        if (status.isExpired) {
+          console.log(chalk3.red(`Token expires: ${status.expiresAt.toISOString()} (expired)`));
+        } else if (status.isExpiringSoon) {
+          printWarning(
+            `Token expires: ${status.expiresAt.toISOString()} (${formatDuration(status.remainingMs)} remaining)`
+          );
+        } else {
+          printInfo(
+            `Token expires: ${status.expiresAt.toISOString()} (${formatDuration(status.remainingMs)} remaining)`
+          );
+        }
+      }
+    }
+    const profileName = globalOpts.profile ?? getCurrentProfile();
+    printInfo(`Profile: ${profileName}`);
+  });
+}
+function registerAuthCommands(program2) {
+  const auth = program2.command("auth").description("Manage authentication");
+  const login = createLoginCommand();
+  addExamples(login, [
+    {
+      description: "Interactive login (email/password prompt)",
+      command: "geonic auth login"
+    },
+    {
+      description: "Login with OAuth client credentials",
+      command: "geonic auth login --client-credentials --client-id MY_ID --client-secret MY_SECRET"
+    },
+    {
+      description: "Login with environment variables",
+      command: "GDB_EMAIL=user@example.com GDB_PASSWORD=pass geonic auth login"
+    },
+    {
+      description: "Login to a specific tenant",
+      command: "geonic auth login --tenant-id my-tenant"
+    }
+  ]);
+  auth.addCommand(login);
+  const logout = createLogoutCommand();
+  addExamples(logout, [
+    {
+      description: "Clear saved authentication token",
+      command: "geonic auth logout"
+    }
+  ]);
+  auth.addCommand(logout);
+  const me = program2.command("me").description("Display current authenticated user").action(createMeAction());
+  addExamples(me, [
+    {
+      description: "Show current user info",
+      command: "geonic me"
+    }
+  ]);
+  program2.addCommand(createLoginCommand(), { hidden: true });
+  program2.addCommand(createLogoutCommand(), { hidden: true });
+  const hiddenWhoami = new Command("whoami").description("Display current authenticated user").action(createMeAction());
+  program2.addCommand(hiddenWhoami, { hidden: true });
+}
+
+// src/commands/profile.ts
+function registerProfileCommands(program2) {
+  const profile = program2.command("profile").description("Manage connection profiles");
+  const list = profile.command("list").description("List all profiles").action(() => {
+    const profiles = listProfiles();
+    for (const p of profiles) {
+      const marker = p.active ? " *" : "";
+      console.log(`${p.name}${marker}`);
+    }
+  });
+  addExamples(list, [
+    {
+      description: "List all profiles (active profile marked with *)",
+      command: "geonic profile list"
+    }
+  ]);
+  const use = profile.command("use <name>").description("Switch active profile").action((name) => {
+    try {
+      setCurrentProfile(name);
+      printSuccess(`Switched to profile "${name}".`);
+    } catch (err) {
+      printError(err.message);
+      process.exit(1);
+    }
+  });
+  addExamples(use, [
+    {
+      description: "Switch to staging profile",
+      command: "geonic profile use staging"
+    }
+  ]);
+  const profileCreate = profile.command("create <name>").description("Create a new profile").action((name) => {
+    try {
+      createProfile(name);
+      printSuccess(`Profile "${name}" created.`);
+    } catch (err) {
+      printError(err.message);
+      process.exit(1);
+    }
+  });
+  addExamples(profileCreate, [
+    {
+      description: "Create a new profile for staging",
+      command: "geonic profile create staging"
+    }
+  ]);
+  const del = profile.command("delete <name>").description("Delete a profile").action((name) => {
+    try {
+      deleteProfile(name);
+      printSuccess(`Profile "${name}" deleted.`);
+    } catch (err) {
+      printError(err.message);
+      process.exit(1);
+    }
+  });
+  addExamples(del, [
+    {
+      description: "Delete a profile",
+      command: "geonic profile delete staging"
+    }
+  ]);
+  const show = profile.command("show [name]").description("Show profile settings").action((name) => {
+    const profileName = name ?? getCurrentProfile();
+    const config = loadConfig(profileName);
+    const entries = Object.entries(config).filter(([, v]) => v !== void 0);
+    if (entries.length === 0) {
+      printInfo(`Profile "${profileName}" has no settings.`);
+      return;
+    }
+    for (const [key, value] of entries) {
+      if ((key === "token" || key === "refreshToken" || key === "apiKey") && typeof value === "string") {
+        console.log(`${key}: ***`);
+      } else {
+        console.log(`${key}: ${value}`);
+      }
+    }
+  });
+  addExamples(show, [
+    {
+      description: "Show current profile settings",
+      command: "geonic profile show"
+    },
+    {
+      description: "Show settings for a specific profile",
+      command: "geonic profile show production"
+    }
+  ]);
+}
+
+// src/input.ts
+import JSON5 from "json5";
+import { readFileSync as readFileSync2 } from "fs";
+import { createInterface as createInterface2 } from "readline";
+async function parseJsonInput(input) {
+  if (input !== void 0) {
+    if (input === "-") return parseData(readFileSync2(0, "utf-8"));
+    if (input.startsWith("@")) return parseData(readFileSync2(input.slice(1), "utf-8"));
+    return parseData(input);
+  }
+  if (!process.stdin.isTTY) {
+    return parseData(readFileSync2(0, "utf-8"));
+  }
+  return readInteractiveJson();
+}
+function parseData(text) {
+  return JSON5.parse(text.trim());
+}
+async function readInteractiveJson() {
+  const rl = createInterface2({
+    input: process.stdin,
+    output: process.stderr,
+    prompt: "json> "
+  });
+  process.stderr.write("Enter JSON (auto-submits when braces close, Ctrl+C to cancel):\n");
+  rl.prompt();
+  const lines = [];
+  let depth = 0;
+  let started = false;
+  let inBlockComment = false;
+  let inString = false;
+  let stringChar = "";
+  let cancelled = false;
+  return new Promise((resolve, reject) => {
+    rl.on("SIGINT", () => {
+      cancelled = true;
+      rl.close();
+    });
+    rl.on("line", (line) => {
+      lines.push(line);
+      const result = trackDepth(line, depth, started, inBlockComment, inString, stringChar);
+      depth = result.depth;
+      started = result.started;
+      inBlockComment = result.inBlockComment;
+      inString = result.inString;
+      stringChar = result.stringChar;
+      if (started && depth <= 0 && !inBlockComment && !inString) {
+        rl.close();
+        try {
+          resolve(parseData(lines.join("\n")));
+        } catch (err) {
+          reject(err);
+        }
+      } else {
+        rl.setPrompt("...  ");
+        rl.prompt();
+      }
+    });
+    rl.on("close", () => {
+      if (cancelled) {
+        reject(new Error("Input cancelled."));
+        return;
+      }
+      if (lines.length > 0 && (!started || depth > 0 || inBlockComment || inString)) {
+        try {
+          resolve(parseData(lines.join("\n")));
+        } catch (err) {
+          reject(err);
+        }
+      } else if (lines.length === 0) {
+        reject(new Error("No input provided."));
+      }
+    });
+  });
+}
+function trackDepth(line, depth, started, inBlockComment, inString, stringChar) {
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    const next = i + 1 < line.length ? line[i + 1] : "";
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        inBlockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (inString) {
+      if (ch === "\\" && i + 1 < line.length) {
+        i++;
+      } else if (ch === stringChar) {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === "/" && next === "/") break;
+    if (ch === "/" && next === "*") {
+      inBlockComment = true;
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inString = true;
+      stringChar = ch;
+    } else if (ch === "{" || ch === "[") {
+      depth++;
+      started = true;
+    } else if (ch === "}" || ch === "]") {
+      depth--;
+    }
+  }
+  return { depth, started, inBlockComment, inString, stringChar };
+}
+
+// src/commands/attrs.ts
+function addAttrsSubcommands(attrs) {
+  const list = attrs.command("list").description("List all attributes of an entity").argument("<entityId>", "Entity ID").action(
+    withErrorHandler(
+      async (entityId, _opts, cmd) => {
+        const client = createClient(cmd);
+        const format = getFormat(cmd);
+        const response = await client.get(
+          `/entities/${encodeURIComponent(entityId)}/attrs`
+        );
+        outputResponse(response, format);
+      }
+    )
+  );
+  addExamples(list, [
+    {
+      description: "List all attributes of an entity",
+      command: "geonic entities attrs list urn:ngsi-ld:Sensor:001"
+    }
+  ]);
+  const get = attrs.command("get").description("Get a specific attribute of an entity").argument("<entityId>", "Entity ID").argument("<attrName>", "Attribute name").action(
+    withErrorHandler(
+      async (entityId, attrName, _opts, cmd) => {
+        const client = createClient(cmd);
+        const format = getFormat(cmd);
+        const response = await client.get(
+          `/entities/${encodeURIComponent(entityId)}/attrs/${encodeURIComponent(attrName)}`
+        );
+        outputResponse(response, format);
+      }
+    )
+  );
+  addExamples(get, [
+    {
+      description: "Get a specific attribute",
+      command: "geonic entities attrs get urn:ngsi-ld:Sensor:001 temperature"
+    }
+  ]);
+  const add = attrs.command("add").description("Add attributes to an entity").argument("<entityId>", "Entity ID").argument("[json]", "JSON payload (inline, @file, - for stdin, or omit for interactive/pipe)").action(
+    withErrorHandler(
+      async (entityId, json, _opts, cmd) => {
+        const client = createClient(cmd);
+        const data = await parseJsonInput(json);
+        await client.post(
+          `/entities/${encodeURIComponent(entityId)}/attrs`,
+          data
+        );
+        printSuccess("Attributes added.");
+      }
+    )
+  );
+  addExamples(add, [
+    {
+      description: "Add attributes from a file",
+      command: "geonic entities attrs add urn:ngsi-ld:Sensor:001 @attrs.json"
+    }
+  ]);
+  const attrUpdate = attrs.command("update").description("Update a specific attribute of an entity").argument("<entityId>", "Entity ID").argument("<attrName>", "Attribute name").argument("[json]", "JSON payload (inline, @file, - for stdin, or omit for interactive/pipe)").action(
+    withErrorHandler(
+      async (entityId, attrName, json, _opts, cmd) => {
+        const client = createClient(cmd);
+        const data = await parseJsonInput(json);
+        await client.put(
+          `/entities/${encodeURIComponent(entityId)}/attrs/${encodeURIComponent(attrName)}`,
+          data
+        );
+        printSuccess("Attribute updated.");
+      }
+    )
+  );
+  addExamples(attrUpdate, [
+    {
+      description: "Update a specific attribute",
+      command: `geonic entities attrs update urn:ngsi-ld:Sensor:001 temperature '{"value":25}'`
+    }
+  ]);
+  const del = attrs.command("delete").description("Delete a specific attribute from an entity").argument("<entityId>", "Entity ID").argument("<attrName>", "Attribute name").action(
+    withErrorHandler(
+      async (entityId, attrName, _opts, cmd) => {
+        const client = createClient(cmd);
+        await client.delete(
+          `/entities/${encodeURIComponent(entityId)}/attrs/${encodeURIComponent(attrName)}`
+        );
+        printSuccess("Attribute deleted.");
+      }
+    )
+  );
+  addExamples(del, [
+    {
+      description: "Delete a specific attribute",
+      command: "geonic entities attrs delete urn:ngsi-ld:Sensor:001 temperature"
+    }
+  ]);
+}
+function registerAttrsSubcommand(entitiesCmd) {
+  const attrs = entitiesCmd.command("attrs").description("Manage entity attributes");
+  addAttrsSubcommands(attrs);
+}
+
+// src/commands/entities.ts
+function registerEntitiesCommand(program2) {
+  const entities = program2.command("entities").description("Manage context entities");
+  const list = entities.command("list").description("List entities with optional filters").option("--type <type>", "Filter by entity type").option("--id-pattern <pat>", "Filter by entity ID pattern (regex)").option("--query <q>", "NGSI query expression").option("--attrs <a,b>", "Comma-separated list of attributes to include").option("--georel <rel>", "Geo-relationship (e.g. near;maxDistance:1000)").option("--geometry <geo>", "Geometry type for geo-query (e.g. point)").option("--coords <coords>", "Coordinates for geo-query").option("--spatial-id <zfxy>", "Spatial ID filter (ZFXY tile)").option("--limit <n>", "Maximum number of entities to return", parseInt).option("--offset <n>", "Skip first N entities", parseInt).option("--order-by <field>", "Order results by field").option("--count", "Include total count in response").option("--key-values", "Request simplified key-value format").action(
+    withErrorHandler(async (opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const params = {};
+      if (opts.type) params.type = String(opts.type);
+      if (opts.idPattern) params.idPattern = String(opts.idPattern);
+      if (opts.query) params.q = String(opts.query);
+      if (opts.attrs) params.attrs = String(opts.attrs);
+      if (opts.georel) params.georel = String(opts.georel);
+      if (opts.geometry) params.geometry = String(opts.geometry);
+      if (opts.coords) params.coords = String(opts.coords);
+      if (opts.spatialId) params.spatialId = String(opts.spatialId);
+      if (opts.limit !== void 0) params.limit = String(opts.limit);
+      if (opts.offset !== void 0) params.offset = String(opts.offset);
+      if (opts.orderBy) params.orderBy = String(opts.orderBy);
+      if (opts.count) params.options = "count";
+      if (opts.keyValues) {
+        params.options = params.options ? `${params.options},keyValues` : "keyValues";
+      }
+      const response = await client.get("/entities", params);
+      outputResponse(response, format, !!opts.count);
+    })
+  );
+  addExamples(list, [
+    {
+      description: "Filter by entity type",
+      command: "geonic entities list --type Sensor"
+    },
+    {
+      description: "Filter by entity ID pattern (regex)",
+      command: "geonic entities list --id-pattern 'urn:ngsi-ld:Sensor:.*'"
+    },
+    {
+      description: "Filter by attribute value",
+      command: "geonic entities list --query 'temperature>30'"
+    },
+    {
+      description: "AND conditions (semicolon)",
+      command: "geonic entities list --query 'temperature>30;humidity<50'"
+    },
+    {
+      description: "String match",
+      command: `geonic entities list --query 'name=="Tokyo"'`
+    },
+    {
+      description: "Pattern match",
+      command: `geonic entities list --query 'name~="Tok.*"'`
+    },
+    {
+      description: "Check attribute existence",
+      command: "geonic entities list --query 'temperature'"
+    },
+    {
+      description: "Select specific attributes",
+      command: "geonic entities list --attrs temperature,humidity"
+    },
+    {
+      description: "Geo-query: entities near a point (within 1km)",
+      command: "geonic entities list --georel 'near;maxDistance==1000' --geometry Point --coords '[139.7671,35.6812]'"
+    },
+    {
+      description: "Geo-query: entities within a polygon",
+      command: "geonic entities list --georel within --geometry Polygon --coords '[[[139.7,35.7],[139.8,35.7],[139.8,35.6],[139.7,35.6],[139.7,35.7]]]'"
+    },
+    {
+      description: "Filter by Spatial ID (ZFXY tile)",
+      command: "geonic entities list --spatial-id 15/0/29101/12903"
+    },
+    {
+      description: "Paginate results",
+      command: "geonic entities list --limit 20 --offset 40"
+    },
+    {
+      description: "Order by attribute",
+      command: "geonic entities list --order-by temperature"
+    },
+    {
+      description: "Get total count with results",
+      command: "geonic entities list --type Sensor --count"
+    }
+  ]);
+  const get = entities.command("get").description("Get a single entity by ID").argument("<id>", "Entity ID").option("--key-values", "Request simplified key-value format").action(
+    withErrorHandler(async (id, opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const params = {};
+      if (opts.keyValues) {
+        params.options = "keyValues";
+      }
+      const response = await client.get(
+        `/entities/${encodeURIComponent(id)}`,
+        params
+      );
+      outputResponse(response, format);
+    })
+  );
+  addExamples(get, [
+    {
+      description: "Get entity by ID",
+      command: "geonic entities get urn:ngsi-ld:Sensor:001"
+    },
+    {
+      description: "Get entity in keyValues format",
+      command: "geonic entities get urn:ngsi-ld:Sensor:001 --key-values"
+    }
+  ]);
+  const create = entities.command("create").description("Create a new entity").argument("[json]", "JSON payload (inline, @file, - for stdin, or omit for interactive/pipe)").action(
+    withErrorHandler(async (json, _opts, cmd) => {
+      const client = createClient(cmd);
+      const data = await parseJsonInput(json);
+      await client.post("/entities", data);
+      printSuccess("Entity created.");
+    })
+  );
+  addExamples(create, [
+    {
+      description: "Create from inline JSON",
+      command: `geonic entities create '{"id":"urn:ngsi-ld:Sensor:001","type":"Sensor"}'`
+    },
+    {
+      description: "Create from a file",
+      command: "geonic entities create @entity.json"
+    },
+    {
+      description: "Create from stdin pipe",
+      command: "cat entity.json | geonic entities create"
+    }
+  ]);
+  const update = entities.command("update").description("Update attributes of an entity (PATCH)").argument("<id>", "Entity ID").argument("[json]", "JSON payload (inline, @file, - for stdin, or omit for interactive/pipe)").action(
+    withErrorHandler(
+      async (id, json, _opts, cmd) => {
+        const client = createClient(cmd);
+        const data = await parseJsonInput(json);
+        await client.patch(
+          `/entities/${encodeURIComponent(id)}/attrs`,
+          data
+        );
+        printSuccess("Entity updated.");
+      }
+    )
+  );
+  addExamples(update, [
+    {
+      description: "Update entity attributes from inline JSON",
+      command: `geonic entities update urn:ngsi-ld:Sensor:001 '{"temperature":{"value":25}}'`
+    },
+    {
+      description: "Update entity attributes from a file",
+      command: "geonic entities update urn:ngsi-ld:Sensor:001 @attrs.json"
+    }
+  ]);
+  const replace = entities.command("replace").description("Replace all attributes of an entity (PUT)").argument("<id>", "Entity ID").argument("[json]", "JSON payload (inline, @file, - for stdin, or omit for interactive/pipe)").action(
+    withErrorHandler(
+      async (id, json, _opts, cmd) => {
+        const client = createClient(cmd);
+        const data = await parseJsonInput(json);
+        await client.put(
+          `/entities/${encodeURIComponent(id)}/attrs`,
+          data
+        );
+        printSuccess("Entity replaced.");
+      }
+    )
+  );
+  addExamples(replace, [
+    {
+      description: "Replace all attributes from a file",
+      command: "geonic entities replace urn:ngsi-ld:Sensor:001 @attrs.json"
+    }
+  ]);
+  const upsert = entities.command("upsert").description("Create or update entities").argument("[json]", "JSON payload (inline, @file, - for stdin, or omit for interactive/pipe)").action(
+    withErrorHandler(async (json, _opts, cmd) => {
+      const client = createClient(cmd);
+      const data = await parseJsonInput(json);
+      await client.post("/entityOperations/upsert", data);
+      printSuccess("Entity upserted.");
+    })
+  );
+  addExamples(upsert, [
+    {
+      description: "Upsert entities from a file",
+      command: "geonic entities upsert @entities.json"
+    },
+    {
+      description: "Upsert from stdin pipe",
+      command: "cat entities.json | geonic entities upsert"
+    }
+  ]);
+  const del = entities.command("delete").description("Delete an entity by ID").argument("<id>", "Entity ID").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.delete(`/entities/${encodeURIComponent(id)}`);
+      printSuccess("Entity deleted.");
+    })
+  );
+  addExamples(del, [
+    {
+      description: "Delete an entity by ID",
+      command: "geonic entities delete urn:ngsi-ld:Sensor:001"
+    }
+  ]);
+  registerAttrsSubcommand(entities);
+}
+
+// src/commands/batch.ts
+function registerBatchCommand(program2) {
+  const batch = program2.command("entityOperations").alias("batch").description("Perform batch operations on entities");
+  const create = batch.command("create [json]").description("Batch create entities").action(
+    withErrorHandler(async (json, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const data = await parseJsonInput(json);
+      const response = await client.post("/entityOperations/create", data);
+      outputResponse(response, format);
+    })
+  );
+  addExamples(create, [
+    {
+      description: "Batch create from a file",
+      command: "geonic batch create @entities.json"
+    },
+    {
+      description: "Batch create from stdin",
+      command: "cat entities.json | geonic batch create"
+    }
+  ]);
+  const upsert = batch.command("upsert [json]").description("Batch upsert entities").action(
+    withErrorHandler(async (json, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const data = await parseJsonInput(json);
+      const response = await client.post("/entityOperations/upsert", data);
+      outputResponse(response, format);
+    })
+  );
+  addExamples(upsert, [
+    {
+      description: "Batch upsert from a file",
+      command: "geonic batch upsert @entities.json"
+    },
+    {
+      description: "Batch upsert from stdin",
+      command: "cat entities.json | geonic batch upsert"
+    }
+  ]);
+  const update = batch.command("update [json]").description("Batch update entity attributes").action(
+    withErrorHandler(async (json, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const data = await parseJsonInput(json);
+      const response = await client.post("/entityOperations/update", data);
+      outputResponse(response, format);
+    })
+  );
+  addExamples(update, [
+    {
+      description: "Batch update from a file",
+      command: "geonic batch update @updates.json"
+    },
+    {
+      description: "Batch update from stdin",
+      command: "cat updates.json | geonic batch update"
+    }
+  ]);
+  const del = batch.command("delete [json]").description("Batch delete entities by ID").action(
+    withErrorHandler(async (json, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const data = await parseJsonInput(json);
+      const response = await client.post("/entityOperations/delete", data);
+      outputResponse(response, format);
+    })
+  );
+  addExamples(del, [
+    {
+      description: "Batch delete from a file",
+      command: "geonic batch delete @entity-ids.json"
+    },
+    {
+      description: "Batch delete from stdin",
+      command: "cat entity-ids.json | geonic batch delete"
+    }
+  ]);
+  const query = batch.command("query [json]").description("Query entities by posting a query payload").action(
+    withErrorHandler(async (json, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const data = await parseJsonInput(json);
+      const response = await client.post("/entityOperations/query", data);
+      outputResponse(response, format);
+    })
+  );
+  addExamples(query, [
+    {
+      description: "Query entities from a file",
+      command: "geonic batch query @query.json"
+    },
+    {
+      description: "Query entities from stdin",
+      command: "cat query.json | geonic batch query"
+    }
+  ]);
+  const merge = batch.command("merge [json]").description("Batch merge-patch entities").action(
+    withErrorHandler(async (json, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const data = await parseJsonInput(json);
+      const response = await client.post("/entityOperations/merge", data);
+      outputResponse(response, format);
+    })
+  );
+  addExamples(merge, [
+    {
+      description: "Batch merge-patch from a file",
+      command: "geonic batch merge @patches.json"
+    },
+    {
+      description: "Batch merge-patch from stdin",
+      command: "cat patches.json | geonic batch merge"
+    }
+  ]);
+}
+
+// src/commands/subscriptions.ts
+function registerSubscriptionsCommand(program2) {
+  const subscriptions = program2.command("subscriptions").alias("sub").description("Manage context subscriptions");
+  const list = subscriptions.command("list").description("List subscriptions").option("--limit <n>", "Maximum number of results", parseInt).option("--offset <n>", "Skip N results", parseInt).option("--count", "Include total count in response").action(
+    withErrorHandler(async (_opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const cmdOpts = cmd.opts();
+      const params = {};
+      if (cmdOpts.limit !== void 0) params["limit"] = String(cmdOpts.limit);
+      if (cmdOpts.offset !== void 0) params["offset"] = String(cmdOpts.offset);
+      if (cmdOpts.count) params["options"] = "count";
+      const response = await client.get("/subscriptions", params);
+      outputResponse(response, format, !!cmdOpts.count);
+    })
+  );
+  addExamples(list, [
+    {
+      description: "List all subscriptions",
+      command: "geonic subscriptions list"
+    },
+    {
+      description: "List with pagination",
+      command: "geonic subscriptions list --limit 10 --offset 20"
+    },
+    {
+      description: "List with total count",
+      command: "geonic subscriptions list --count"
+    }
+  ]);
+  const get = subscriptions.command("get <id>").description("Get a subscription by ID").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.get(
+        `/subscriptions/${encodeURIComponent(String(id))}`
+      );
+      outputResponse(response, format);
+    })
+  );
+  addExamples(get, [
+    {
+      description: "Get subscription by ID",
+      command: "geonic subscriptions get urn:ngsi-ld:Subscription:001"
+    }
+  ]);
+  const create = subscriptions.command("create [json]").description("Create a subscription").action(
+    withErrorHandler(async (json, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const data = await parseJsonInput(json);
+      const response = await client.post("/subscriptions", data);
+      outputResponse(response, format);
+      printSuccess("Subscription created.");
+    })
+  );
+  addExamples(create, [
+    {
+      description: "Create from a JSON file",
+      command: "geonic subscriptions create @subscription.json"
+    },
+    {
+      description: "Create from stdin",
+      command: "cat subscription.json | geonic subscriptions create"
+    }
+  ]);
+  const update = subscriptions.command("update <id> [json]").description("Update a subscription").action(
+    withErrorHandler(
+      async (id, json, _opts, cmd) => {
+        const client = createClient(cmd);
+        const format = getFormat(cmd);
+        const data = await parseJsonInput(json);
+        const response = await client.patch(
+          `/subscriptions/${encodeURIComponent(String(id))}`,
+          data
+        );
+        outputResponse(response, format);
+        printSuccess("Subscription updated.");
+      }
+    )
+  );
+  addExamples(update, [
+    {
+      description: "Update a subscription from a file",
+      command: "geonic subscriptions update urn:ngsi-ld:Subscription:001 @sub.json"
+    }
+  ]);
+  const del = subscriptions.command("delete <id>").description("Delete a subscription").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.delete(
+        `/subscriptions/${encodeURIComponent(String(id))}`
+      );
+      printSuccess("Subscription deleted.");
+    })
+  );
+  addExamples(del, [
+    {
+      description: "Delete a subscription",
+      command: "geonic subscriptions delete urn:ngsi-ld:Subscription:001"
+    }
+  ]);
+}
+
+// src/commands/registrations.ts
+function registerRegistrationsCommand(program2) {
+  const registrations = program2.command("registrations").alias("reg").description("Manage context registrations");
+  const list = registrations.command("list").description("List registrations").option("--limit <n>", "Maximum number of results", parseInt).option("--offset <n>", "Skip N results", parseInt).option("--count", "Include total count in response").action(
+    withErrorHandler(async (_opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const cmdOpts = cmd.opts();
+      const params = {};
+      if (cmdOpts.limit !== void 0) params["limit"] = String(cmdOpts.limit);
+      if (cmdOpts.offset !== void 0) params["offset"] = String(cmdOpts.offset);
+      if (cmdOpts.count) params["options"] = "count";
+      const response = await client.get("/registrations", params);
+      outputResponse(response, format, !!cmdOpts.count);
+    })
+  );
+  addExamples(list, [
+    {
+      description: "List all registrations",
+      command: "geonic registrations list"
+    },
+    {
+      description: "List with pagination",
+      command: "geonic registrations list --limit 10"
+    }
+  ]);
+  const get = registrations.command("get <id>").description("Get a registration by ID").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.get(
+        `/registrations/${encodeURIComponent(String(id))}`
+      );
+      outputResponse(response, format);
+    })
+  );
+  addExamples(get, [
+    {
+      description: "Get registration by ID",
+      command: "geonic registrations get urn:ngsi-ld:ContextSourceRegistration:001"
+    }
+  ]);
+  const create = registrations.command("create [json]").description("Create a registration").action(
+    withErrorHandler(async (json, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const data = await parseJsonInput(json);
+      const response = await client.post("/registrations", data);
+      outputResponse(response, format);
+      printSuccess("Registration created.");
+    })
+  );
+  addExamples(create, [
+    {
+      description: "Create a registration from a file",
+      command: "geonic registrations create @registration.json"
+    }
+  ]);
+  const regUpdate = registrations.command("update <id> [json]").description("Update a registration").action(
+    withErrorHandler(
+      async (id, json, _opts, cmd) => {
+        const client = createClient(cmd);
+        const format = getFormat(cmd);
+        const data = await parseJsonInput(json);
+        const response = await client.patch(
+          `/registrations/${encodeURIComponent(String(id))}`,
+          data
+        );
+        outputResponse(response, format);
+        printSuccess("Registration updated.");
+      }
+    )
+  );
+  addExamples(regUpdate, [
+    {
+      description: "Update a registration from a file",
+      command: "geonic registrations update urn:ngsi-ld:ContextSourceRegistration:001 @registration.json"
+    }
+  ]);
+  const del = registrations.command("delete <id>").description("Delete a registration").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.delete(
+        `/registrations/${encodeURIComponent(String(id))}`
+      );
+      printSuccess("Registration deleted.");
+    })
+  );
+  addExamples(del, [
+    {
+      description: "Delete a registration",
+      command: "geonic registrations delete urn:ngsi-ld:ContextSourceRegistration:001"
+    }
+  ]);
+}
+
+// src/commands/types.ts
+function registerTypesCommand(program2) {
+  const types = program2.command("types").description("Browse entity types");
+  const list = types.command("list").description("List available entity types").action(
+    withErrorHandler(async (_opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.get("/types");
+      outputResponse(response, format);
+    })
+  );
+  addExamples(list, [
+    {
+      description: "List all entity types",
+      command: "geonic types list"
+    }
+  ]);
+  const get = types.command("get <typeName>").description("Get details for an entity type").action(
+    withErrorHandler(
+      async (typeName, _opts, cmd) => {
+        const client = createClient(cmd);
+        const format = getFormat(cmd);
+        const response = await client.get(
+          `/types/${encodeURIComponent(String(typeName))}`
+        );
+        outputResponse(response, format);
+      }
+    )
+  );
+  addExamples(get, [
+    {
+      description: "Get details for a specific type",
+      command: "geonic types get Sensor"
+    }
+  ]);
+}
+
+// src/commands/temporal.ts
+function addTemporalListOptions(cmd) {
+  return cmd.option("--type <type>", "Filter by entity type").option("--attrs <a,b>", "Comma-separated list of attributes to include").option("--query <q>", "NGSI query expression").option("--georel <rel>", "Geo-relationship (e.g. near;maxDistance:1000)").option("--geometry <geo>", "Geometry type for geo-query (e.g. point)").option("--coords <coords>", "Coordinates for geo-query").option("--time-rel <rel>", "Temporal relationship (before, after, between)").option("--time-at <time>", "Temporal query start time (ISO 8601)").option("--end-time-at <time>", "Temporal query end time (ISO 8601)").option("--last-n <n>", "Return last N temporal values", parseInt).option("--limit <n>", "Maximum number of entities to return", parseInt).option("--offset <n>", "Skip first N entities", parseInt).option("--count", "Include total count in response");
+}
+function createListAction() {
+  return withErrorHandler(async (_opts, cmd) => {
+    const client = createClient(cmd);
+    const format = getFormat(cmd);
+    const cmdOpts = cmd.opts();
+    const params = {};
+    if (cmdOpts.type) params["type"] = cmdOpts.type;
+    if (cmdOpts.attrs) params["attrs"] = cmdOpts.attrs;
+    if (cmdOpts.query) params["q"] = cmdOpts.query;
+    if (cmdOpts.georel) params["georel"] = cmdOpts.georel;
+    if (cmdOpts.geometry) params["geometry"] = cmdOpts.geometry;
+    if (cmdOpts.coords) params["coords"] = cmdOpts.coords;
+    if (cmdOpts.timeRel) params["timerel"] = cmdOpts.timeRel;
+    if (cmdOpts.timeAt) params["timeAt"] = cmdOpts.timeAt;
+    if (cmdOpts.endTimeAt) params["endTimeAt"] = cmdOpts.endTimeAt;
+    if (cmdOpts.lastN !== void 0) params["lastN"] = String(cmdOpts.lastN);
+    if (cmdOpts.limit !== void 0) params["limit"] = String(cmdOpts.limit);
+    if (cmdOpts.offset !== void 0) params["offset"] = String(cmdOpts.offset);
+    if (cmdOpts.count) params["options"] = "count";
+    const response = await client.get("/temporal/entities", params);
+    outputResponse(response, format, cmdOpts.count);
+  });
+}
+function addTemporalGetOptions(cmd) {
+  return cmd.option("--attrs <a,b>", "Comma-separated list of attributes to include").option("--time-rel <rel>", "Temporal relationship (before, after, between)").option("--time-at <time>", "Temporal query start time (ISO 8601)").option("--end-time-at <time>", "Temporal query end time (ISO 8601)").option("--last-n <n>", "Return last N temporal values", parseInt);
+}
+function createGetAction() {
+  return withErrorHandler(async (id, _opts, cmd) => {
+    const client = createClient(cmd);
+    const format = getFormat(cmd);
+    const cmdOpts = cmd.opts();
+    const params = {};
+    if (cmdOpts.attrs) params["attrs"] = cmdOpts.attrs;
+    if (cmdOpts.timeRel) params["timerel"] = cmdOpts.timeRel;
+    if (cmdOpts.timeAt) params["timeAt"] = cmdOpts.timeAt;
+    if (cmdOpts.endTimeAt) params["endTimeAt"] = cmdOpts.endTimeAt;
+    if (cmdOpts.lastN !== void 0) params["lastN"] = String(cmdOpts.lastN);
+    const response = await client.get(
+      `/temporal/entities/${encodeURIComponent(String(id))}`,
+      params
+    );
+    outputResponse(response, format);
+  });
+}
+function createCreateAction() {
+  return withErrorHandler(async (json, _opts, cmd) => {
+    const body = await parseJsonInput(json);
+    const client = createClient(cmd);
+    await client.post("/temporal/entities", body);
+    printSuccess("Temporal entity created.");
+  });
+}
+function createDeleteAction() {
+  return withErrorHandler(async (id, _opts, cmd) => {
+    const client = createClient(cmd);
+    await client.delete(
+      `/temporal/entities/${encodeURIComponent(String(id))}`
+    );
+    printSuccess("Temporal entity deleted.");
+  });
+}
+function createQueryAction() {
+  return withErrorHandler(async (json, _opts, cmd) => {
+    const body = await parseJsonInput(json);
+    const client = createClient(cmd);
+    const format = getFormat(cmd);
+    const cmdOpts = cmd.opts();
+    const params = {};
+    if (cmdOpts.aggrMethods) params["aggrMethods"] = cmdOpts.aggrMethods;
+    if (cmdOpts.aggrPeriod) params["aggrPeriodDuration"] = cmdOpts.aggrPeriod;
+    const response = await client.post(
+      "/temporal/entityOperations/query",
+      body,
+      params
+    );
+    outputResponse(response, format);
+  });
+}
+function addQueryOptions(cmd) {
+  return cmd.option("--aggr-methods <methods>", "Aggregation methods (e.g. totalCount,sum)").option("--aggr-period <period>", "Aggregation period (e.g. PT1H)");
+}
+function registerTemporalCommand(program2) {
+  const temporal = program2.command("temporal").description("Manage temporal entities");
+  const entities = temporal.command("entities").description("List, get, create, and delete temporal entities");
+  const entityOperations = temporal.command("entityOperations").description("Perform batch operations on temporal entities");
+  const entitiesList = addTemporalListOptions(
+    entities.command("list").description("List temporal entities with optional filters")
+  );
+  entitiesList.action(createListAction());
+  addExamples(entitiesList, [
+    {
+      description: "List by type with time range",
+      command: "geonic temporal entities list --type Sensor --time-rel between --time-at 2025-01-01T00:00:00Z --end-time-at 2025-01-31T23:59:59Z"
+    },
+    {
+      description: "Get last 5 temporal values",
+      command: "geonic temporal entities list --type Sensor --last-n 5"
+    },
+    {
+      description: "Filter by time (after a point)",
+      command: "geonic temporal entities list --time-rel after --time-at 2025-06-01T00:00:00Z"
+    }
+  ]);
+  const entitiesGet = addTemporalGetOptions(
+    entities.command("get <id>").description("Get a temporal entity by ID")
+  );
+  entitiesGet.action(createGetAction());
+  addExamples(entitiesGet, [
+    {
+      description: "Get temporal entity with specific attributes",
+      command: "geonic temporal entities get urn:ngsi-ld:Sensor:001 --attrs temperature,humidity"
+    },
+    {
+      description: "Get last 10 values for an entity",
+      command: "geonic temporal entities get urn:ngsi-ld:Sensor:001 --last-n 10"
+    }
+  ]);
+  const create = entities.command("create [json]").description("Create a temporal entity").action(createCreateAction());
+  addExamples(create, [
+    {
+      description: "Create temporal entity from a file",
+      command: "geonic temporal entities create @temporal-entity.json"
+    }
+  ]);
+  const del = entities.command("delete <id>").description("Delete a temporal entity by ID").action(createDeleteAction());
+  addExamples(del, [
+    {
+      description: "Delete temporal data for an entity",
+      command: "geonic temporal entities delete urn:ngsi-ld:Sensor:001"
+    }
+  ]);
+  const opsQuery = addQueryOptions(
+    entityOperations.command("query [json]").description("Query temporal entities (POST)")
+  );
+  opsQuery.action(createQueryAction());
+  addExamples(opsQuery, [
+    {
+      description: "Query with aggregation (hourly count)",
+      command: "geonic temporal entityOperations query @query.json --aggr-methods totalCount --aggr-period PT1H"
+    },
+    {
+      description: "Query from a file",
+      command: "geonic temporal entityOperations query @query.json"
+    }
+  ]);
+  addTemporalListOptions(
+    temporal.command("list", { hidden: true }).description("List temporal entities (deprecated: use temporal entities list)")
+  ).action(createListAction());
+  addTemporalGetOptions(
+    temporal.command("get <id>", { hidden: true }).description("Get a temporal entity (deprecated: use temporal entities get)")
+  ).action(createGetAction());
+  temporal.command("create [json]", { hidden: true }).description("Create a temporal entity (deprecated: use temporal entities create)").action(createCreateAction());
+  temporal.command("delete <id>", { hidden: true }).description("Delete a temporal entity (deprecated: use temporal entities delete)").action(createDeleteAction());
+  addQueryOptions(
+    temporal.command("query [json]", { hidden: true }).description("Query temporal entities (deprecated: use temporal entityOperations query)")
+  ).action(createQueryAction());
+}
+
+// src/commands/snapshots.ts
+function registerSnapshotsCommand(program2) {
+  const snapshots = program2.command("snapshots").description("Manage snapshots");
+  const list = snapshots.command("list").description("List snapshots").option("--limit <n>", "Maximum number of snapshots to return", parseInt).option("--offset <n>", "Skip first N snapshots", parseInt).action(
+    withErrorHandler(async (_opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const cmdOpts = cmd.opts();
+      const params = {};
+      if (cmdOpts.limit !== void 0) params["limit"] = String(cmdOpts.limit);
+      if (cmdOpts.offset !== void 0) params["offset"] = String(cmdOpts.offset);
+      const response = await client.get("/snapshots", params);
+      outputResponse(response, format);
+    })
+  );
+  addExamples(list, [
+    {
+      description: "List all snapshots",
+      command: "geonic snapshots list"
+    },
+    {
+      description: "List with a limit",
+      command: "geonic snapshots list --limit 10"
+    }
+  ]);
+  const get = snapshots.command("get <id>").description("Get a snapshot by ID").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.get(
+        `/snapshots/${encodeURIComponent(String(id))}`
+      );
+      outputResponse(response, format);
+    })
+  );
+  addExamples(get, [
+    {
+      description: "Get a specific snapshot",
+      command: "geonic snapshots get <snapshot-id>"
+    }
+  ]);
+  const create = snapshots.command("create").description("Create a new snapshot").action(
+    withErrorHandler(async (_opts, cmd) => {
+      const client = createClient(cmd);
+      await client.post("/snapshots");
+      printSuccess("Snapshot created.");
+    })
+  );
+  addExamples(create, [
+    {
+      description: "Create a new snapshot",
+      command: "geonic snapshots create"
+    }
+  ]);
+  const del = snapshots.command("delete <id>").description("Delete a snapshot by ID").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.delete(
+        `/snapshots/${encodeURIComponent(String(id))}`
+      );
+      printSuccess("Snapshot deleted.");
+    })
+  );
+  addExamples(del, [
+    {
+      description: "Delete a snapshot",
+      command: "geonic snapshots delete <snapshot-id>"
+    }
+  ]);
+  const clone = snapshots.command("clone <id>").description("Clone a snapshot by ID").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.post(
+        `/snapshots/${encodeURIComponent(String(id))}/clone`
+      );
+      if (response.data !== void 0 && response.data !== "") {
+        outputResponse(response, format);
+      } else {
+        printSuccess("Snapshot cloned.");
+      }
+    })
+  );
+  addExamples(clone, [
+    {
+      description: "Clone a snapshot",
+      command: "geonic snapshots clone <snapshot-id>"
+    }
+  ]);
+}
+
+// src/commands/admin/tenants.ts
+function registerTenantsCommand(parent) {
+  const tenants = parent.command("tenants").description("Manage tenants");
+  const list = tenants.command("list").description("List all tenants").action(
+    withErrorHandler(async (_opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest("GET", "/admin/tenants");
+      outputResponse(response, format);
+    })
+  );
+  addExamples(list, [
+    {
+      description: "List all tenants",
+      command: "geonic admin tenants list"
+    }
+  ]);
+  const get = tenants.command("get <id>").description("Get a tenant by ID").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest(
+        "GET",
+        `/admin/tenants/${encodeURIComponent(String(id))}`
+      );
+      outputResponse(response, format);
+    })
+  );
+  addExamples(get, [
+    {
+      description: "Get a tenant by ID",
+      command: "geonic admin tenants get <tenant-id>"
+    }
+  ]);
+  const create = tenants.command("create [json]").description("Create a new tenant").action(
+    withErrorHandler(async (json, _opts, cmd) => {
+      const body = await parseJsonInput(json);
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest("POST", "/admin/tenants", {
+        body
+      });
+      outputResponse(response, format);
+      printSuccess("Tenant created.");
+    })
+  );
+  addExamples(create, [
+    {
+      description: "Create a tenant from a JSON file",
+      command: "geonic admin tenants create @tenant.json"
+    }
+  ]);
+  const update = tenants.command("update <id> [json]").description("Update a tenant").action(
+    withErrorHandler(
+      async (id, json, _opts, cmd) => {
+        const body = await parseJsonInput(json);
+        const client = createClient(cmd);
+        const format = getFormat(cmd);
+        const response = await client.rawRequest(
+          "PATCH",
+          `/admin/tenants/${encodeURIComponent(String(id))}`,
+          { body }
+        );
+        outputResponse(response, format);
+        printSuccess("Tenant updated.");
+      }
+    )
+  );
+  addExamples(update, [
+    {
+      description: "Update a tenant from a JSON file",
+      command: "geonic admin tenants update <tenant-id> @tenant.json"
+    }
+  ]);
+  const del = tenants.command("delete <id>").description("Delete a tenant").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.rawRequest(
+        "DELETE",
+        `/admin/tenants/${encodeURIComponent(String(id))}`
+      );
+      printSuccess("Tenant deleted.");
+    })
+  );
+  addExamples(del, [
+    {
+      description: "Delete a tenant",
+      command: "geonic admin tenants delete <tenant-id>"
+    }
+  ]);
+  const activate = tenants.command("activate <id>").description("Activate a tenant").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.rawRequest(
+        "POST",
+        `/admin/tenants/${encodeURIComponent(String(id))}/activate`
+      );
+      printSuccess("Tenant activated.");
+    })
+  );
+  addExamples(activate, [
+    {
+      description: "Activate a tenant",
+      command: "geonic admin tenants activate <tenant-id>"
+    }
+  ]);
+  const deactivate = tenants.command("deactivate <id>").description("Deactivate a tenant").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.rawRequest(
+        "POST",
+        `/admin/tenants/${encodeURIComponent(String(id))}/deactivate`
+      );
+      printSuccess("Tenant deactivated.");
+    })
+  );
+  addExamples(deactivate, [
+    {
+      description: "Deactivate a tenant",
+      command: "geonic admin tenants deactivate <tenant-id>"
+    }
+  ]);
+}
+
+// src/commands/admin/users.ts
+function registerUsersCommand(parent) {
+  const users = parent.command("users").description("Manage users");
+  const list = users.command("list").description("List all users").action(
+    withErrorHandler(async (_opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest("GET", "/admin/users");
+      outputResponse(response, format);
+    })
+  );
+  addExamples(list, [
+    {
+      description: "List all users",
+      command: "geonic admin users list"
+    }
+  ]);
+  const get = users.command("get <id>").description("Get a user by ID").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest(
+        "GET",
+        `/admin/users/${encodeURIComponent(String(id))}`
+      );
+      outputResponse(response, format);
+    })
+  );
+  addExamples(get, [
+    {
+      description: "Get a user by ID",
+      command: "geonic admin users get <user-id>"
+    }
+  ]);
+  const create = users.command("create [json]").description("Create a new user").action(
+    withErrorHandler(async (json, _opts, cmd) => {
+      const body = await parseJsonInput(json);
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest("POST", "/admin/users", {
+        body
+      });
+      outputResponse(response, format);
+      printSuccess("User created.");
+    })
+  );
+  addExamples(create, [
+    {
+      description: "Create a user from a JSON file",
+      command: "geonic admin users create @user.json"
+    }
+  ]);
+  const update = users.command("update <id> [json]").description("Update a user").action(
+    withErrorHandler(
+      async (id, json, _opts, cmd) => {
+        const body = await parseJsonInput(json);
+        const client = createClient(cmd);
+        const format = getFormat(cmd);
+        const response = await client.rawRequest(
+          "PATCH",
+          `/admin/users/${encodeURIComponent(String(id))}`,
+          { body }
+        );
+        outputResponse(response, format);
+        printSuccess("User updated.");
+      }
+    )
+  );
+  addExamples(update, [
+    {
+      description: "Update a user from a JSON file",
+      command: "geonic admin users update <user-id> @user.json"
+    }
+  ]);
+  const del = users.command("delete <id>").description("Delete a user").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.rawRequest(
+        "DELETE",
+        `/admin/users/${encodeURIComponent(String(id))}`
+      );
+      printSuccess("User deleted.");
+    })
+  );
+  addExamples(del, [
+    {
+      description: "Delete a user",
+      command: "geonic admin users delete <user-id>"
+    }
+  ]);
+  const activate = users.command("activate <id>").description("Activate a user").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.rawRequest(
+        "POST",
+        `/admin/users/${encodeURIComponent(String(id))}/activate`
+      );
+      printSuccess("User activated.");
+    })
+  );
+  addExamples(activate, [
+    {
+      description: "Activate a user",
+      command: "geonic admin users activate <user-id>"
+    }
+  ]);
+  const deactivate = users.command("deactivate <id>").description("Deactivate a user").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.rawRequest(
+        "POST",
+        `/admin/users/${encodeURIComponent(String(id))}/deactivate`
+      );
+      printSuccess("User deactivated.");
+    })
+  );
+  addExamples(deactivate, [
+    {
+      description: "Deactivate a user",
+      command: "geonic admin users deactivate <user-id>"
+    }
+  ]);
+  const unlock = users.command("unlock <id>").description("Unlock a user").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.rawRequest(
+        "POST",
+        `/admin/users/${encodeURIComponent(String(id))}/unlock`
+      );
+      printSuccess("User unlocked.");
+    })
+  );
+  addExamples(unlock, [
+    {
+      description: "Unlock a locked user account",
+      command: "geonic admin users unlock <user-id>"
+    }
+  ]);
+}
+
+// src/commands/admin/policies.ts
+function registerPoliciesCommand(parent) {
+  const policies = parent.command("policies").description("Manage policies");
+  const list = policies.command("list").description("List all policies").action(
+    withErrorHandler(async (_opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest("GET", "/admin/policies");
+      outputResponse(response, format);
+    })
+  );
+  addExamples(list, [
+    {
+      description: "List all policies",
+      command: "geonic admin policies list"
+    }
+  ]);
+  const get = policies.command("get <id>").description("Get a policy by ID").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest(
+        "GET",
+        `/admin/policies/${encodeURIComponent(String(id))}`
+      );
+      outputResponse(response, format);
+    })
+  );
+  addExamples(get, [
+    {
+      description: "Get a policy by ID",
+      command: "geonic admin policies get <policy-id>"
+    }
+  ]);
+  const create = policies.command("create [json]").description("Create a new policy").action(
+    withErrorHandler(async (json, _opts, cmd) => {
+      const body = await parseJsonInput(json);
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest("POST", "/admin/policies", {
+        body
+      });
+      outputResponse(response, format);
+      printSuccess("Policy created.");
+    })
+  );
+  addExamples(create, [
+    {
+      description: "Create a policy from a JSON file",
+      command: "geonic admin policies create @policy.json"
+    }
+  ]);
+  const update = policies.command("update <id> [json]").description("Update a policy").action(
+    withErrorHandler(
+      async (id, json, _opts, cmd) => {
+        const body = await parseJsonInput(json);
+        const client = createClient(cmd);
+        const format = getFormat(cmd);
+        const response = await client.rawRequest(
+          "PATCH",
+          `/admin/policies/${encodeURIComponent(String(id))}`,
+          { body }
+        );
+        outputResponse(response, format);
+        printSuccess("Policy updated.");
+      }
+    )
+  );
+  addExamples(update, [
+    {
+      description: "Update a policy from a JSON file",
+      command: "geonic admin policies update <policy-id> @policy.json"
+    }
+  ]);
+  const del = policies.command("delete <id>").description("Delete a policy").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.rawRequest(
+        "DELETE",
+        `/admin/policies/${encodeURIComponent(String(id))}`
+      );
+      printSuccess("Policy deleted.");
+    })
+  );
+  addExamples(del, [
+    {
+      description: "Delete a policy",
+      command: "geonic admin policies delete <policy-id>"
+    }
+  ]);
+  const activate = policies.command("activate <id>").description("Activate a policy").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.rawRequest(
+        "POST",
+        `/admin/policies/${encodeURIComponent(String(id))}/activate`
+      );
+      printSuccess("Policy activated.");
+    })
+  );
+  addExamples(activate, [
+    {
+      description: "Activate a policy",
+      command: "geonic admin policies activate <policy-id>"
+    }
+  ]);
+  const deactivate = policies.command("deactivate <id>").description("Deactivate a policy").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.rawRequest(
+        "POST",
+        `/admin/policies/${encodeURIComponent(String(id))}/deactivate`
+      );
+      printSuccess("Policy deactivated.");
+    })
+  );
+  addExamples(deactivate, [
+    {
+      description: "Deactivate a policy",
+      command: "geonic admin policies deactivate <policy-id>"
+    }
+  ]);
+}
+
+// src/commands/admin/oauth-clients.ts
+function registerOAuthClientsCommand(parent) {
+  const oauthClients = parent.command("oauth-clients").description("Manage OAuth clients");
+  const list = oauthClients.command("list").description("List all OAuth clients").action(
+    withErrorHandler(async (_opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest("GET", "/admin/oauth-clients");
+      outputResponse(response, format);
+    })
+  );
+  addExamples(list, [
+    {
+      description: "List all OAuth clients",
+      command: "geonic admin oauth-clients list"
+    }
+  ]);
+  const get = oauthClients.command("get <id>").description("Get an OAuth client by ID").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest(
+        "GET",
+        `/admin/oauth-clients/${encodeURIComponent(String(id))}`
+      );
+      outputResponse(response, format);
+    })
+  );
+  addExamples(get, [
+    {
+      description: "Get an OAuth client by ID",
+      command: "geonic admin oauth-clients get <client-id>"
+    }
+  ]);
+  const create = oauthClients.command("create [json]").description("Create a new OAuth client").action(
+    withErrorHandler(async (json, _opts, cmd) => {
+      const body = await parseJsonInput(json);
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest("POST", "/admin/oauth-clients", {
+        body
+      });
+      outputResponse(response, format);
+      printSuccess("OAuth client created.");
+    })
+  );
+  addExamples(create, [
+    {
+      description: "Create an OAuth client from a JSON file",
+      command: "geonic admin oauth-clients create @client.json"
+    }
+  ]);
+  const update = oauthClients.command("update <id> [json]").description("Update an OAuth client").action(
+    withErrorHandler(
+      async (id, json, _opts, cmd) => {
+        const body = await parseJsonInput(json);
+        const client = createClient(cmd);
+        const format = getFormat(cmd);
+        const response = await client.rawRequest(
+          "PATCH",
+          `/admin/oauth-clients/${encodeURIComponent(String(id))}`,
+          { body }
+        );
+        outputResponse(response, format);
+        printSuccess("OAuth client updated.");
+      }
+    )
+  );
+  addExamples(update, [
+    {
+      description: "Update an OAuth client from a JSON file",
+      command: "geonic admin oauth-clients update <client-id> @client.json"
+    }
+  ]);
+  const del = oauthClients.command("delete <id>").description("Delete an OAuth client").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.rawRequest(
+        "DELETE",
+        `/admin/oauth-clients/${encodeURIComponent(String(id))}`
+      );
+      printSuccess("OAuth client deleted.");
+    })
+  );
+  addExamples(del, [
+    {
+      description: "Delete an OAuth client",
+      command: "geonic admin oauth-clients delete <client-id>"
+    }
+  ]);
+}
+function registerCaddeCommand(parent) {
+  const cadde = parent.command("cadde").description("Manage CADDE configuration");
+  const caddeGet = cadde.command("get").description("Get CADDE configuration").action(
+    withErrorHandler(async (_opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest("GET", "/admin/cadde");
+      outputResponse(response, format);
+    })
+  );
+  addExamples(caddeGet, [
+    {
+      description: "Get CADDE configuration",
+      command: "geonic admin cadde get"
+    }
+  ]);
+  const caddeSet = cadde.command("set [json]").description("Set CADDE configuration").action(
+    withErrorHandler(async (json, _opts, cmd) => {
+      const body = await parseJsonInput(json);
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest("PUT", "/admin/cadde", {
+        body
+      });
+      outputResponse(response, format);
+      printSuccess("CADDE configuration set.");
+    })
+  );
+  addExamples(caddeSet, [
+    {
+      description: "Set CADDE configuration from a JSON file",
+      command: "geonic admin cadde set @cadde-config.json"
+    }
+  ]);
+  const caddeDelete = cadde.command("delete").description("Delete CADDE configuration").action(
+    withErrorHandler(async (_opts, cmd) => {
+      const client = createClient(cmd);
+      await client.rawRequest("DELETE", "/admin/cadde");
+      printSuccess("CADDE configuration deleted.");
+    })
+  );
+  addExamples(caddeDelete, [
+    {
+      description: "Delete CADDE configuration",
+      command: "geonic admin cadde delete"
+    }
+  ]);
+}
+
+// src/commands/admin/index.ts
+function registerAdminCommand(program2) {
+  const admin = program2.command("admin").description("Manage admin resources");
+  registerTenantsCommand(admin);
+  registerUsersCommand(admin);
+  registerPoliciesCommand(admin);
+  registerOAuthClientsCommand(admin);
+  registerCaddeCommand(admin);
+}
+
+// src/commands/rules.ts
+function registerRulesCommand(program2) {
+  const rules = program2.command("rules").description("Manage rule engine");
+  const list = rules.command("list").description("List all rules").action(
+    withErrorHandler(async (_opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest("GET", "/rules");
+      outputResponse(response, format);
+    })
+  );
+  addExamples(list, [
+    {
+      description: "List all rules",
+      command: "geonic rules list"
+    }
+  ]);
+  const get = rules.command("get <id>").description("Get a rule by ID").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest(
+        "GET",
+        `/rules/${encodeURIComponent(String(id))}`
+      );
+      outputResponse(response, format);
+    })
+  );
+  addExamples(get, [
+    {
+      description: "Get a specific rule",
+      command: "geonic rules get <rule-id>"
+    }
+  ]);
+  const create = rules.command("create [json]").description("Create a new rule").action(
+    withErrorHandler(async (json, _opts, cmd) => {
+      const body = await parseJsonInput(json);
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest("POST", "/rules", { body });
+      outputResponse(response, format);
+      printSuccess("Rule created.");
+    })
+  );
+  addExamples(create, [
+    {
+      description: "Create a rule from a file",
+      command: "geonic rules create @rule.json"
+    }
+  ]);
+  const update = rules.command("update <id> [json]").description("Update a rule").action(
+    withErrorHandler(
+      async (id, json, _opts, cmd) => {
+        const body = await parseJsonInput(json);
+        const client = createClient(cmd);
+        const format = getFormat(cmd);
+        const response = await client.rawRequest(
+          "PATCH",
+          `/rules/${encodeURIComponent(String(id))}`,
+          { body }
+        );
+        outputResponse(response, format);
+        printSuccess("Rule updated.");
+      }
+    )
+  );
+  addExamples(update, [
+    {
+      description: "Update a rule from a file",
+      command: "geonic rules update <rule-id> @rule.json"
+    }
+  ]);
+  const del = rules.command("delete <id>").description("Delete a rule").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.rawRequest(
+        "DELETE",
+        `/rules/${encodeURIComponent(String(id))}`
+      );
+      printSuccess("Rule deleted.");
+    })
+  );
+  addExamples(del, [
+    {
+      description: "Delete a rule",
+      command: "geonic rules delete <rule-id>"
+    }
+  ]);
+  const activate = rules.command("activate <id>").description("Activate a rule").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.rawRequest(
+        "POST",
+        `/rules/${encodeURIComponent(String(id))}/activate`
+      );
+      printSuccess("Rule activated.");
+    })
+  );
+  addExamples(activate, [
+    {
+      description: "Activate a rule",
+      command: "geonic rules activate <rule-id>"
+    }
+  ]);
+  const deactivate = rules.command("deactivate <id>").description("Deactivate a rule").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.rawRequest(
+        "POST",
+        `/rules/${encodeURIComponent(String(id))}/deactivate`
+      );
+      printSuccess("Rule deactivated.");
+    })
+  );
+  addExamples(deactivate, [
+    {
+      description: "Deactivate a rule",
+      command: "geonic rules deactivate <rule-id>"
+    }
+  ]);
+}
+
+// src/commands/models.ts
+function registerModelsCommand(program2) {
+  const models = program2.command("custom-data-models").alias("models").description("Manage custom data models");
+  const list = models.command("list").description("List all models").action(
+    withErrorHandler(async (_opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest("GET", "/custom-data-models");
+      outputResponse(response, format);
+    })
+  );
+  addExamples(list, [
+    {
+      description: "List all models",
+      command: "geonic models list"
+    }
+  ]);
+  const get = models.command("get <id>").description("Get a model by ID").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest(
+        "GET",
+        `/custom-data-models/${encodeURIComponent(String(id))}`
+      );
+      outputResponse(response, format);
+    })
+  );
+  addExamples(get, [
+    {
+      description: "Get a specific model",
+      command: "geonic models get <model-id>"
+    }
+  ]);
+  const create = models.command("create [json]").description("Create a new model").action(
+    withErrorHandler(async (json, _opts, cmd) => {
+      const body = await parseJsonInput(json);
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest("POST", "/custom-data-models", { body });
+      outputResponse(response, format);
+      printSuccess("Model created.");
+    })
+  );
+  addExamples(create, [
+    {
+      description: "Create a model from a file",
+      command: "geonic models create @model.json"
+    }
+  ]);
+  const update = models.command("update <id> [json]").description("Update a model").action(
+    withErrorHandler(
+      async (id, json, _opts, cmd) => {
+        const body = await parseJsonInput(json);
+        const client = createClient(cmd);
+        const format = getFormat(cmd);
+        const response = await client.rawRequest(
+          "PATCH",
+          `/custom-data-models/${encodeURIComponent(String(id))}`,
+          { body }
+        );
+        outputResponse(response, format);
+        printSuccess("Model updated.");
+      }
+    )
+  );
+  addExamples(update, [
+    {
+      description: "Update a model from a file",
+      command: "geonic models update <model-id> @model.json"
+    }
+  ]);
+  const del = models.command("delete <id>").description("Delete a model").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      await client.rawRequest(
+        "DELETE",
+        `/custom-data-models/${encodeURIComponent(String(id))}`
+      );
+      printSuccess("Model deleted.");
+    })
+  );
+  addExamples(del, [
+    {
+      description: "Delete a model",
+      command: "geonic models delete <model-id>"
+    }
+  ]);
+}
+
+// src/commands/catalog.ts
+function registerCatalogCommand(program2) {
+  const catalog = program2.command("catalog").description("Browse DCAT-AP catalog");
+  const get = catalog.command("get").description("Get the catalog").action(
+    withErrorHandler(async (_opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest("GET", "/catalog");
+      outputResponse(response, format);
+    })
+  );
+  addExamples(get, [
+    {
+      description: "Get the DCAT-AP catalog",
+      command: "geonic catalog get"
+    }
+  ]);
+  const datasets = catalog.command("datasets").description("Manage catalog datasets");
+  const datasetsList = datasets.command("list").description("List all datasets").action(
+    withErrorHandler(async (_opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest("GET", "/catalog/datasets");
+      outputResponse(response, format);
+    })
+  );
+  addExamples(datasetsList, [
+    {
+      description: "List all catalog datasets",
+      command: "geonic catalog datasets list"
+    }
+  ]);
+  const datasetsGet = datasets.command("get <id>").description("Get a dataset by ID").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest(
+        "GET",
+        `/catalog/datasets/${encodeURIComponent(String(id))}`
+      );
+      outputResponse(response, format);
+    })
+  );
+  addExamples(datasetsGet, [
+    {
+      description: "Get a specific dataset",
+      command: "geonic catalog datasets get <dataset-id>"
+    }
+  ]);
+  const datasetsSample = datasets.command("sample <id>").description("Get sample data for a dataset").action(
+    withErrorHandler(async (id, _opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest(
+        "GET",
+        `/catalog/datasets/${encodeURIComponent(String(id))}/sample`
+      );
+      outputResponse(response, format);
+    })
+  );
+  addExamples(datasetsSample, [
+    {
+      description: "Get sample data for a dataset",
+      command: "geonic catalog datasets sample <dataset-id>"
+    }
+  ]);
+}
+
+// src/commands/health.ts
+import { createRequire } from "module";
+function registerHealthCommand(program2) {
+  const health = program2.command("health").description("Check the health status of the server").action(
+    withErrorHandler(async (_opts, cmd) => {
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest("GET", "/health");
+      outputResponse(response, format);
+    })
+  );
+  addExamples(health, [
+    {
+      description: "Check server health",
+      command: "geonic health"
+    }
+  ]);
+}
+function registerVersionCommand(program2) {
+  const version = program2.command("version").description("Display CLI and server version information").action(
+    withErrorHandler(async (_opts, cmd) => {
+      const require2 = createRequire(import.meta.url);
+      const pkg = require2("../package.json");
+      const cliVersion = pkg.version;
+      printInfo(`CLI version: ${cliVersion}`);
+      const client = createClient(cmd);
+      const format = getFormat(cmd);
+      const response = await client.rawRequest("GET", "/version");
+      printInfo("Server version:");
+      outputResponse(response, format);
+    })
+  );
+  addExamples(version, [
+    {
+      description: "Show CLI and server version",
+      command: "geonic version"
+    }
+  ]);
+}
+
+// src/commands/cli.ts
+import { createRequire as createRequire2 } from "module";
+function findOption(cmd, program2, flag) {
+  return cmd.options.find((o) => o.long === flag || o.short === flag) || program2.options.find((o) => o.long === flag || o.short === flag);
+}
+function optionTakesValue(cmd, program2, flag) {
+  const opt = findOption(cmd, program2, flag);
+  if (!opt) return false;
+  return !!(opt.required || opt.optional);
+}
+function findSubcommand(cmd, name) {
+  return cmd.commands.find(
+    (c) => c.name() === name || c.aliases().includes(name)
+  );
+}
+function generateCompletions(program2, line, point) {
+  const truncated = line.slice(0, point);
+  const tokens = truncated.trim().split(/\s+/).filter(Boolean);
+  const startingNewWord = /\s$/.test(truncated);
+  const partial = !startingNewWord && tokens.length > 1 ? tokens[tokens.length - 1] : "";
+  const walkTokens = startingNewWord ? tokens.slice(1) : tokens.slice(1, -1);
+  let currentCmd = program2;
+  let i = 0;
+  while (i < walkTokens.length) {
+    const token = walkTokens[i];
+    if (token.startsWith("-")) {
+      if (optionTakesValue(currentCmd, program2, token)) {
+        i += 2;
+      } else {
+        i += 1;
+      }
+      continue;
+    }
+    const sub = findSubcommand(currentCmd, token);
+    if (sub) {
+      currentCmd = sub;
+    }
+    i++;
+  }
+  if (currentCmd.name() === "help" && currentCmd.parent === program2) {
+    const helpIdx = walkTokens.findIndex((t) => t === "help");
+    const rawArgs = helpIdx >= 0 ? walkTokens.slice(helpIdx + 1) : [];
+    const helpArgs = [];
+    for (let j = 0; j < rawArgs.length; j++) {
+      const t = rawArgs[j];
+      if (t.startsWith("-")) {
+        if (optionTakesValue(currentCmd, program2, t)) {
+          j++;
+        }
+        continue;
+      }
+      helpArgs.push(t);
+    }
+    let target = program2;
+    for (const arg of helpArgs) {
+      const sub = findSubcommand(target, arg);
+      if (sub) target = sub;
+      else break;
+    }
+    const subs = target.commands.filter((c) => !c._hidden).map((c) => c.name());
+    return subs.filter((s) => s.startsWith(partial));
+  }
+  const predecessor = startingNewWord ? tokens[tokens.length - 1] : tokens.length >= 2 ? tokens[tokens.length - 2] : void 0;
+  if (predecessor && predecessor.startsWith("-") && optionTakesValue(currentCmd, program2, predecessor)) {
+    return getOptionValueCompletions(predecessor, partial);
+  }
+  if (partial.startsWith("-")) {
+    return getOptionCompletions(currentCmd, program2, partial);
+  }
+  const subcommands = currentCmd.commands.filter((c) => !c._hidden).map((c) => c.name());
+  if (subcommands.length > 0) {
+    return subcommands.filter((s) => s.startsWith(partial));
+  }
+  for (const arg of currentCmd.registeredArguments) {
+    if (arg.description && arg.description.includes("@file")) {
+      return ["<file>"];
+    }
+  }
+  return [];
+}
+function getOptionCompletions(cmd, program2, partial) {
+  const options = /* @__PURE__ */ new Set();
+  for (const opt of cmd.options) {
+    if (opt.hidden) continue;
+    if (opt.long) options.add(opt.long);
+  }
+  for (const opt of program2.options) {
+    if (opt.hidden) continue;
+    if (opt.long) options.add(opt.long);
+  }
+  return [...options].filter((o) => o.startsWith(partial));
+}
+function getOptionValueCompletions(optionFlag, partial) {
+  if (optionFlag === "--format" || optionFlag === "-f") {
+    return ["json", "table", "geojson"].filter(
+      (v) => v.startsWith(partial)
+    );
+  }
+  return [];
+}
+var ZSH_SCRIPT = `_geonic_completions() {
+  local completions
+  completions=(\${(f)"$(geonic cli completions --line="$BUFFER" --point="$CURSOR" 2>/dev/null)"})
+  if [[ "\${completions[1]}" == "<file>" ]]; then
+    _files
+    return
+  fi
+  compadd -a completions
+}
+compdef _geonic_completions geonic`;
+var BASH_SCRIPT = `_geonic_completions() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local completions
+  completions=$(geonic cli completions --line="\${COMP_LINE}" --point="\${COMP_POINT}" 2>/dev/null)
+  if [[ "$completions" == "<file>" ]]; then
+    COMPREPLY=()
+    return
+  fi
+  COMPREPLY=($(compgen -W "$completions" -- "$cur"))
+}
+complete -o default -F _geonic_completions geonic`;
+function registerCliCommand(program2) {
+  const cli = program2.command("cli").summary("Manage CLI internals").description("Manage CLI internals such as shell completions.");
+  const completions = cli.command("completions").summary("Generate shell completions").description("Generate shell completions for geonic CLI.").option("--line <line>", "Current command line content").option("--point <point>", "Cursor position in the command line").action((opts) => {
+    if (opts.line !== void 0 && opts.point !== void 0) {
+      const point = parseInt(opts.point, 10);
+      const results = generateCompletions(program2, opts.line, point);
+      for (const r of results) {
+        console.log(r);
+      }
+    }
+  });
+  const bash = completions.command("bash").description("Output bash completion script").action(() => {
+    console.log(BASH_SCRIPT);
+  });
+  addExamples(bash, [
+    {
+      description: "Print the bash completion script",
+      command: "geonic cli completions bash"
+    },
+    {
+      description: "Enable in current shell session",
+      command: 'eval "$(geonic cli completions bash)"'
+    },
+    {
+      description: "Persist in ~/.bashrc",
+      command: `echo 'eval "$(geonic cli completions bash)"' >> ~/.bashrc`
+    }
+  ]);
+  const zsh = completions.command("zsh").description("Output zsh completion script").action(() => {
+    console.log(ZSH_SCRIPT);
+  });
+  addExamples(zsh, [
+    {
+      description: "Print the zsh completion script",
+      command: "geonic cli completions zsh"
+    },
+    {
+      description: "Enable in current shell session",
+      command: 'eval "$(geonic cli completions zsh)"'
+    },
+    {
+      description: "Persist in ~/.zshrc",
+      command: `echo 'eval "$(geonic cli completions zsh)"' >> ~/.zshrc`
+    }
+  ]);
+  const version = cli.command("version").description("Display the CLI version").action(() => {
+    const require2 = createRequire2(import.meta.url);
+    const pkg = require2("../package.json");
+    console.log(pkg.version);
+  });
+  addExamples(version, [
+    {
+      description: "Show CLI version",
+      command: "geonic cli version"
+    }
+  ]);
+}
+
+// src/cli.ts
+function createProgram() {
+  const require2 = createRequire3(import.meta.url);
+  const pkg = require2("../package.json");
+  const program2 = new Command2();
+  program2.name("geonic").description(pkg.description).option("-u, --url <url>", "Base URL of the GeonicDB server").option("-s, --service <name>", "NGSILD-Tenant header").option("--token <token>", "Authentication token").option("-p, --profile <name>", "Use a named profile").option("--api-key <key>", "API key for authentication").option("-f, --format <fmt>", "Output format: json, table, geojson").option("--no-color", "Disable color output").option("-v, --verbose", "Verbose output");
+  registerHelpCommand(program2);
+  registerConfigCommand(program2);
+  registerAuthCommands(program2);
+  registerProfileCommands(program2);
+  registerEntitiesCommand(program2);
+  registerBatchCommand(program2);
+  registerSubscriptionsCommand(program2);
+  registerRegistrationsCommand(program2);
+  registerTypesCommand(program2);
+  registerTemporalCommand(program2);
+  registerSnapshotsCommand(program2);
+  registerAdminCommand(program2);
+  registerRulesCommand(program2);
+  registerModelsCommand(program2);
+  registerCatalogCommand(program2);
+  registerHealthCommand(program2);
+  registerVersionCommand(program2);
+  registerCliCommand(program2);
+  const hiddenAttrs = new Command2("attrs").description("Manage entity attributes");
+  addAttrsSubcommands(hiddenAttrs);
+  program2.addCommand(hiddenAttrs, { hidden: true });
+  return program2;
+}
+
+// src/index.ts
+var program = createProgram();
+program.parse();
+//# sourceMappingURL=index.js.map