@maptec/cli 1.0.0

package/dist/cli.js

@@ -0,0 +1,899 @@
+#!/usr/bin/env node
+import {
+  API_VERSION,
+  getConfigPath,
+  loadConfig,
+  maskApiKey,
+  normalizeBaseUrl,
+  resolveApiKey,
+  resolveBaseUrl,
+  saveConfig,
+  setApiKey,
+  setBaseUrl,
+  setConfigValue
+} from "./chunk-K574OFFK.js";
+
+// src/cli.ts
+import { Command } from "commander";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+// src/errors.ts
+var ExitCode = {
+  USER_ERROR: 1,
+  CONFIG_MISSING: 2,
+  API_ERROR: 3,
+  NETWORK_ERROR: 4,
+  INTERNAL_ERROR: 5
+};
+var CliError = class extends Error {
+  constructor(message, exitCode, hint) {
+    super(message);
+    this.exitCode = exitCode;
+    this.hint = hint;
+    this.name = "CliError";
+  }
+  exitCode;
+  hint;
+};
+function printError(err) {
+  if (err instanceof CliError) {
+    console.error(`error: ${err.message}`);
+    if (err.hint) {
+      console.error(`hint: ${err.hint}`);
+    }
+    return;
+  }
+  if (err instanceof Error) {
+    console.error(`error: ${err.message}`);
+    return;
+  }
+  console.error("error: \u672A\u77E5\u9519\u8BEF");
+}
+function exitWithError(err) {
+  printError(err);
+  const code = err instanceof CliError ? err.exitCode : ExitCode.INTERNAL_ERROR;
+  process.exit(code);
+}
+
+// src/commands/init.ts
+import * as readline from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+
+// src/output/json.ts
+import { writeFile } from "fs/promises";
+
+// src/output/fields.ts
+function pickFields(data, fields) {
+  if (data === null || data === void 0) return data;
+  if (Array.isArray(data)) {
+    return data.map((item) => pickFields(item, fields));
+  }
+  if (typeof data !== "object") return data;
+  const fieldSet = new Set(fields.map((f) => f.trim()).filter(Boolean));
+  if (fieldSet.size === 0) return data;
+  const out = {};
+  for (const key of fieldSet) {
+    if (key in data) {
+      out[key] = data[key];
+    }
+  }
+  return out;
+}
+
+// src/output/json.ts
+async function emitSuccess(payload, options) {
+  let data = payload.data;
+  if (options.fields?.length) {
+    data = pickFields(data, options.fields);
+  }
+  const envelope = {
+    ok: true,
+    command: payload.command,
+    data
+  };
+  if (options.format === "table") {
+    const text = formatTable(data);
+    await writeOutput(text, options);
+    return;
+  }
+  const json = `${JSON.stringify(envelope, null, 2)}
+`;
+  await writeOutput(json, options);
+}
+async function writeOutput(text, options) {
+  if (options.out) {
+    await writeFile(options.out, text, "utf8");
+    if (!options.quiet) {
+      console.error(`\u5DF2\u5199\u5165 ${options.out}`);
+    }
+    return;
+  }
+  process.stdout.write(text.endsWith("\n") ? text : `${text}
+`);
+}
+function formatTable(data) {
+  if (data === null || data === void 0) {
+    return "(empty)";
+  }
+  if (typeof data !== "object") {
+    return String(data);
+  }
+  if (Array.isArray(data)) {
+    if (data.length === 0) return "(no results)";
+    return data.map((item, i) => `[${i}] ${JSON.stringify(item)}`).join("\n");
+  }
+  return Object.entries(data).map(([k, v]) => `${k}: ${typeof v === "object" ? JSON.stringify(v) : String(v)}`).join("\n");
+}
+function handleApiBusinessStatus(result, command) {
+  if (result.status === "ERROR" && result.error) {
+    const err = result.error;
+    throw new CliError(
+      `${err.code} \u2014 ${err.message}`,
+      ExitCode.API_ERROR,
+      `\u68C0\u67E5\u547D\u4EE4\u53C2\u6570\uFF0C\u5F53\u524D\u547D\u4EE4\uFF1A${command}`
+    );
+  }
+  return result;
+}
+
+// src/commands/init.ts
+async function runInit(outputOpts) {
+  const rl = readline.createInterface({ input, output });
+  try {
+    const existing = await loadConfig();
+    const apiKeyPrompt = existing.apiKey ? `API Key [\u5F53\u524D ${maskApiKey(existing.apiKey)}\uFF0C\u56DE\u8F66\u4FDD\u7559]: ` : "API Key: ";
+    const apiKeyInput = (await rl.question(apiKeyPrompt)).trim();
+    const baseUrlPrompt = existing.baseUrl ? `Base URL [\u5F53\u524D ${existing.baseUrl}\uFF0C\u56DE\u8F66\u4FDD\u7559]: ` : "Base URL (https://api.example.com): ";
+    const baseUrlInput = (await rl.question(baseUrlPrompt)).trim();
+    const config = await loadConfig();
+    if (apiKeyInput) {
+      config.apiKey = apiKeyInput;
+    }
+    if (!config.apiKey) {
+      throw new CliError(
+        "\u5FC5\u987B\u63D0\u4F9B API Key",
+        ExitCode.USER_ERROR,
+        "\u4ECE Maptec \u5F00\u653E\u5E73\u53F0\u63A7\u5236\u53F0\u83B7\u53D6\uFF0C\u6216\u8BBE\u7F6E MAPTEC_API_KEY"
+      );
+    }
+    if (baseUrlInput) {
+      try {
+        config.baseUrl = normalizeBaseUrl(baseUrlInput);
+      } catch (err) {
+        throw new CliError(
+          err instanceof Error ? err.message : "\u65E0\u6548 Base URL",
+          ExitCode.USER_ERROR
+        );
+      }
+    }
+    if (!config.baseUrl) {
+      throw new CliError(
+        "\u5FC5\u987B\u63D0\u4F9B Base URL",
+        ExitCode.USER_ERROR,
+        "\u793A\u4F8B\uFF1Ahttps://api.maptec.com \uFF0C\u6216\u8BBE\u7F6E MAPTEC_BASE_URL"
+      );
+    }
+    delete config.env;
+    await saveConfig(config);
+    await emitSuccess(
+      {
+        command: "init",
+        data: {
+          apiKey: maskApiKey(config.apiKey),
+          baseUrl: config.baseUrl,
+          configPath: "~/.maptec/config.json"
+        }
+      },
+      outputOpts
+    );
+  } finally {
+    rl.close();
+  }
+}
+
+// src/commands/config.ts
+async function runConfigGet(outputOpts) {
+  const config = await loadConfig();
+  const apiKey = resolveApiKey(config);
+  await emitSuccess(
+    {
+      command: "config.get",
+      data: {
+        apiKey: apiKey ? maskApiKey(apiKey) : null,
+        baseUrl: resolveBaseUrl(config) ?? null,
+        defaultFormat: config.defaultFormat,
+        timeoutMs: config.timeoutMs,
+        configPath: getConfigPath()
+      }
+    },
+    outputOpts
+  );
+}
+async function runConfigSet(key, value, outputOpts) {
+  let config;
+  switch (key) {
+    case "api-key":
+    case "apiKey":
+      config = await setApiKey(value);
+      break;
+    case "base-url":
+    case "baseUrl":
+      try {
+        config = await setBaseUrl(value);
+      } catch (err) {
+        throw new CliError(
+          err instanceof Error ? err.message : "\u65E0\u6548 baseUrl",
+          ExitCode.USER_ERROR
+        );
+      }
+      break;
+    case "default-format":
+    case "defaultFormat":
+      config = await setConfigValue("defaultFormat", value);
+      break;
+    case "timeout":
+    case "timeoutMs":
+      config = await setConfigValue("timeoutMs", Number(value));
+      break;
+    default:
+      throw new CliError(
+        `\u672A\u77E5\u914D\u7F6E\u9879 "${key}"`,
+        ExitCode.USER_ERROR,
+        "\u53EF\u9009\uFF1Aapi-key | base-url | default-format | timeout"
+      );
+  }
+  await emitSuccess(
+    {
+      command: "config.set",
+      data: {
+        key,
+        baseUrl: config.baseUrl ?? null,
+        apiKey: config.apiKey ? maskApiKey(config.apiKey) : null
+      }
+    },
+    outputOpts
+  );
+}
+
+// src/api/client.ts
+function buildQueryString(query) {
+  const parts = Object.entries(query).filter(([, v]) => v !== void 0 && v !== "").map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`);
+  return parts.length ? `?${parts.join("&")}` : "";
+}
+function getAuthorizationValue(apiKey) {
+  return apiKey.trim();
+}
+async function apiRequest(config, options) {
+  const apiKey = resolveApiKey(config);
+  if (!apiKey) {
+    throw new CliError(
+      "\u672A\u914D\u7F6E API Key",
+      ExitCode.CONFIG_MISSING,
+      "\u8FD0\u884C maptec init \u6216\u8BBE\u7F6E MAPTEC_API_KEY \u73AF\u5883\u53D8\u91CF"
+    );
+  }
+  const baseUrl = resolveBaseUrl(config);
+  if (!baseUrl) {
+    throw new CliError(
+      "\u672A\u914D\u7F6E Base URL",
+      ExitCode.CONFIG_MISSING,
+      "\u8FD0\u884C maptec init \u6216\u8BBE\u7F6E MAPTEC_BASE_URL \u73AF\u5883\u53D8\u91CF"
+    );
+  }
+  const timeoutMs = options.timeoutMs ?? config.timeoutMs;
+  const queryString = options.query ? buildQueryString(options.query) : "";
+  const url = `${baseUrl}${options.path}${queryString}`;
+  const headers = {
+    Authorization: getAuthorizationValue(apiKey)
+  };
+  const method = options.method ?? "GET";
+  const init = {
+    method,
+    headers,
+    signal: AbortSignal.timeout(timeoutMs)
+  };
+  if (options.body !== void 0) {
+    headers["Content-Type"] = "application/json";
+    init.body = JSON.stringify(options.body);
+  }
+  let response;
+  try {
+    response = await fetch(url, init);
+  } catch (err) {
+    const message = err instanceof Error && err.name === "TimeoutError" ? `\u8BF7\u6C42\u8D85\u65F6\uFF08${timeoutMs}ms\uFF09` : err instanceof Error ? err.message : "\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25";
+    throw new CliError(message, ExitCode.NETWORK_ERROR);
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch {
+    throw new CliError(
+      `\u65E0\u6CD5\u89E3\u6790 API \u54CD\u5E94\uFF08HTTP ${response.status}\uFF09`,
+      response.ok ? ExitCode.INTERNAL_ERROR : ExitCode.API_ERROR
+    );
+  }
+  if (!response.ok) {
+    const code = data.error?.code ?? data.code ?? `HTTP_${response.status}`;
+    const message = data.error?.message ?? data.message ?? `HTTP ${response.status}`;
+    throw new CliError(message, ExitCode.API_ERROR, code);
+  }
+  return data;
+}
+function searchPath(segment) {
+  return `/search/${API_VERSION}/${segment}`;
+}
+function routesPath(segment) {
+  return `/routes/${API_VERSION}/${segment}`;
+}
+
+// src/api/geocode.ts
+async function forwardGeocode(config, params) {
+  const query = {
+    address: params.address,
+    language: params.language,
+    region: params.region,
+    components: params.components,
+    locationBias: params.locationBias
+  };
+  const data = await apiRequest(config, {
+    path: searchPath("geocode"),
+    query
+  });
+  if (!Array.isArray(data.results)) {
+    data.results = [];
+  }
+  if (data.status === "ERROR" && data.error) {
+    return data;
+  }
+  return data;
+}
+async function reverseGeocode(config, params) {
+  const query = {
+    location: `${params.lat},${params.lng}`,
+    language: params.language,
+    region: params.region,
+    resultType: params.resultType,
+    locationType: params.locationType
+  };
+  const data = await apiRequest(config, {
+    path: searchPath("reverse"),
+    query
+  });
+  if (!Array.isArray(data.results)) {
+    data.results = [];
+  }
+  return data;
+}
+
+// src/commands/geocode.ts
+async function runGeocode(opts, outputOpts) {
+  if (!opts.address?.trim()) {
+    throw new CliError(
+      "\u7F3A\u5C11 --address \u53C2\u6570",
+      ExitCode.USER_ERROR,
+      '\u793A\u4F8B\uFF1Amaptec geocode --address "\u5317\u4EAC\u5E02\u671D\u9633\u533A\u56FD\u8D38"'
+    );
+  }
+  const config = await loadConfig();
+  const result = await forwardGeocode(config, {
+    address: opts.address.trim(),
+    language: opts.language,
+    region: opts.region
+  });
+  if (result.status === "ZERO_RESULTS") {
+    throw new CliError(
+      "ZERO_RESULTS \u2014 \u672A\u627E\u5230\u5339\u914D\u5730\u5740",
+      ExitCode.API_ERROR,
+      "\u68C0\u67E5 --address \u6216\u6539\u7528 maptec search text"
+    );
+  }
+  handleApiBusinessStatus(result, "geocode");
+  await emitSuccess(
+    { command: "geocode", data: result },
+    outputOpts
+  );
+}
+
+// src/commands/reverse-geocode.ts
+async function runReverseGeocode(opts, outputOpts) {
+  if (!Number.isFinite(opts.lat) || !Number.isFinite(opts.lng)) {
+    throw new CliError(
+      "\u7F3A\u5C11\u6709\u6548\u7684 --lat \u4E0E --lng",
+      ExitCode.USER_ERROR,
+      "\u793A\u4F8B\uFF1Amaptec reverse-geocode --lat 39.908 --lng 116.397"
+    );
+  }
+  const config = await loadConfig();
+  const result = await reverseGeocode(config, opts);
+  if (result.status === "ZERO_RESULTS") {
+    throw new CliError(
+      "ZERO_RESULTS \u2014 \u8BE5\u5750\u6807\u65E0\u5730\u5740\u7ED3\u679C",
+      ExitCode.API_ERROR,
+      "\u68C0\u67E5\u5750\u6807\u662F\u5426\u5728\u670D\u52A1\u8303\u56F4\u5185"
+    );
+  }
+  handleApiBusinessStatus(result, "reverse-geocode");
+  await emitSuccess(
+    { command: "reverse-geocode", data: result },
+    outputOpts
+  );
+}
+
+// src/api/location.ts
+function parseLngLatPair(value, defaultRadius) {
+  const parts = value.split(",").map((s) => s.trim());
+  if (parts.length < 2) {
+    throw new Error(`\u65E0\u6548\u5750\u6807 "${value}"\uFF0C\u683C\u5F0F\uFF1Alng,lat \u6216 lng,lat,radius`);
+  }
+  const lng = Number(parts[0]);
+  const lat = Number(parts[1]);
+  if (!Number.isFinite(lng) || !Number.isFinite(lat)) {
+    throw new Error(`\u65E0\u6548\u5750\u6807 "${value}"`);
+  }
+  const radius = parts[2] !== void 0 ? Number(parts[2]) : defaultRadius;
+  return {
+    center: { longitude: lng, latitude: lat },
+    radius: radius !== void 0 && Number.isFinite(radius) ? radius : void 0
+  };
+}
+function toLocationAreaCircle(lng, lat, radius) {
+  return {
+    center: { longitude: lng, latitude: lat },
+    radius
+  };
+}
+function buildRouteEndpoint(point) {
+  if (point.kind === "coord") {
+    return {
+      location: {
+        latitude: point.lat,
+        longitude: point.lng
+      }
+    };
+  }
+  const text = point.value.trim();
+  if (/^[\d.+-]+,[\d.+-]+$/.test(text)) {
+    const { center } = parseLngLatPair(text);
+    return { location: center };
+  }
+  return { placeId: text };
+}
+
+// src/api/place-search.ts
+async function searchText(config, params) {
+  const body = {
+    query: params.query,
+    pageSize: params.pageSize ?? 20,
+    language: params.language ?? "en"
+  };
+  if (params.region) body.region = params.region;
+  if (params.type) body.type = params.type;
+  if (params.rank) body.rank = params.rank;
+  if (params.location) {
+    const { center, radius } = parseLngLatPair(params.location, 5e3);
+    body.locationBias = toLocationAreaCircle(
+      center.longitude,
+      center.latitude,
+      radius ?? 5e3
+    );
+  }
+  return apiRequest(config, {
+    method: "POST",
+    path: searchPath("text"),
+    body
+  });
+}
+async function searchNearby(config, params) {
+  const body = {
+    locationLimit: toLocationAreaCircle(
+      params.lng,
+      params.lat,
+      params.radius ?? 500
+    ),
+    types: params.types ?? "",
+    resultLimit: params.resultLimit ?? 20,
+    rank: params.rank ?? "DISTANCE",
+    language: params.language ?? "en"
+  };
+  if (params.region) body.region = params.region;
+  return apiRequest(config, {
+    method: "POST",
+    path: searchPath("nearby"),
+    body
+  });
+}
+async function searchSuggest(config, params) {
+  const body = {
+    query: params.query,
+    resultLimit: params.resultLimit ?? 20,
+    language: params.language ?? "en",
+    region: params.region ?? "",
+    types: ""
+  };
+  if (params.location) {
+    const { center, radius } = parseLngLatPair(params.location, 5e3);
+    body.locationBias = toLocationAreaCircle(
+      center.longitude,
+      center.latitude,
+      radius ?? 5e3
+    );
+  }
+  return apiRequest(config, {
+    method: "POST",
+    path: searchPath("suggest"),
+    body
+  });
+}
+async function getPlaceDetails(config, params) {
+  const query = {
+    language: params.language ?? "en",
+    region: params.region,
+    sessionToken: params.sessionToken
+  };
+  return apiRequest(config, {
+    path: searchPath(`places/${encodeURIComponent(params.placeId)}`),
+    query
+  });
+}
+
+// src/commands/search.ts
+function assertOkStatus(result, command) {
+  if (result.status === "ZERO_RESULTS") {
+    throw new CliError(
+      "ZERO_RESULTS \u2014 \u672A\u627E\u5230\u5339\u914D\u7ED3\u679C",
+      ExitCode.API_ERROR,
+      `\u68C0\u67E5\u641C\u7D22\u53C2\u6570\uFF0C\u547D\u4EE4\uFF1A${command}`
+    );
+  }
+  handleApiBusinessStatus(result, command);
+}
+async function runSearchText(opts, outputOpts) {
+  if (!opts.query?.trim()) {
+    throw new CliError("\u7F3A\u5C11 --query", ExitCode.USER_ERROR);
+  }
+  const config = await loadConfig();
+  const result = await searchText(config, opts);
+  assertOkStatus(result, "search.text");
+  await emitSuccess({ command: "search.text", data: result }, outputOpts);
+}
+async function runSearchNearby(opts, outputOpts) {
+  const config = await loadConfig();
+  const result = await searchNearby(config, {
+    lat: opts.lat,
+    lng: opts.lng,
+    radius: opts.radius,
+    types: opts.types,
+    resultLimit: opts.limit,
+    language: opts.language,
+    region: opts.region,
+    rank: opts.rank
+  });
+  assertOkStatus(result, "search.nearby");
+  await emitSuccess({ command: "search.nearby", data: result }, outputOpts);
+}
+async function runSearchSuggest(opts, outputOpts) {
+  const config = await loadConfig();
+  const result = await searchSuggest(config, {
+    query: opts.query,
+    location: opts.location,
+    language: opts.language,
+    region: opts.region,
+    resultLimit: opts.limit
+  });
+  assertOkStatus(result, "search.suggest");
+  await emitSuccess({ command: "search.suggest", data: result }, outputOpts);
+}
+async function runSearchPlace(opts, outputOpts) {
+  const config = await loadConfig();
+  const result = await getPlaceDetails(config, {
+    placeId: opts.id,
+    language: opts.language,
+    region: opts.region,
+    sessionToken: opts.sessionToken
+  });
+  assertOkStatus(result, "search.place");
+  await emitSuccess({ command: "search.place", data: result }, outputOpts);
+}
+
+// src/api/directions.ts
+async function getDirectionsWithEndpoints(config, params) {
+  const body = {
+    origin: params.origin,
+    destination: params.destination,
+    mode: params.mode
+  };
+  if (params.strategy) body.strategy = params.strategy;
+  if (params.language) body.language = params.language;
+  if (params.vehicleSpec) body.vehicleSpec = params.vehicleSpec;
+  return apiRequest(config, {
+    method: "POST",
+    path: routesPath("directions"),
+    body
+  });
+}
+
+// src/api/route-resolve.ts
+async function resolveRouteEndpoint(config, point) {
+  if (point.kind === "coord") {
+    return buildRouteEndpoint(point);
+  }
+  const text = point.value.trim();
+  if (/^[\d.+-]+,[\d.+-]+$/.test(text)) {
+    return buildRouteEndpoint(point);
+  }
+  if (text.startsWith("places/") || text.includes("_v0.") || /^[\d]+$/.test(text)) {
+    return buildRouteEndpoint(point);
+  }
+  const geocoded = await forwardGeocode(config, { address: text });
+  const first = geocoded.results?.[0];
+  if (geocoded.status !== "OK" || !first?.geometry?.location) {
+    throw new Error(
+      `\u65E0\u6CD5 geocode \u5730\u5740 "${text}"\uFF08${geocoded.status}\uFF09`
+    );
+  }
+  const { latitude, longitude } = first.geometry.location;
+  return buildRouteEndpoint({ kind: "coord", lat: latitude, lng: longitude });
+}
+
+// src/output/route-fields.ts
+var DEFAULT_ROUTE_FIELDS = ["distance", "duration", "summary"];
+function shapeRouteOutput(data, fields) {
+  if (!data.routes?.length) return data;
+  const wanted = fields?.length ? fields : DEFAULT_ROUTE_FIELDS;
+  const includePolyline = wanted.includes("polyline");
+  const routes = data.routes.map(
+    (route) => projectRoute(route, wanted, includePolyline)
+  );
+  return { ...data, routes };
+}
+function projectRoute(route, fields, includePolyline) {
+  const out = {};
+  if (fields.includes("summary") || fields.includes("distance") || fields.includes("duration")) {
+    const summary = {};
+    if (fields.includes("distance")) {
+      summary.distanceMeters = route.summary.distanceMeters;
+    }
+    if (fields.includes("duration")) {
+      summary.durationSeconds = route.summary.durationSeconds;
+    }
+    if (fields.includes("summary")) {
+      summary.trafficDurationSeconds = route.summary.trafficDurationSeconds;
+    }
+    out.summary = summary;
+  }
+  if (fields.includes("warnings") && route.warnings) {
+    out.warnings = route.warnings;
+  }
+  if (includePolyline) {
+    const polyline = route.overviewPolyline;
+    if (polyline) out.polyline = polyline;
+    if (route.path) out.path = route.path;
+  }
+  if (fields.includes("legs") && route.legs) {
+    out.legs = route.legs;
+  }
+  return out;
+}
+
+// src/commands/route.ts
+function resolveEndpoint(text, lat, lng, label) {
+  if (lat !== void 0 && lng !== void 0 && Number.isFinite(lat) && Number.isFinite(lng)) {
+    return { kind: "coord", lat, lng };
+  }
+  if (text?.trim()) {
+    return { kind: "text", value: text.trim() };
+  }
+  throw new CliError(
+    `\u7F3A\u5C11\u8D77\u70B9/\u7EC8\u70B9 ${label}`,
+    ExitCode.USER_ERROR,
+    `\u4F7F\u7528 --${label} \u6216 --${label}-lat + --${label}-lng`
+  );
+}
+async function runRoute(opts, outputOpts) {
+  const origin = resolveEndpoint(opts.from, opts.fromLat, opts.fromLng, "from");
+  const destination = resolveEndpoint(opts.to, opts.toLat, opts.toLng, "to");
+  const config = await loadConfig();
+  const [originParam, destinationParam] = await Promise.all([
+    resolveRouteEndpoint(config, origin),
+    resolveRouteEndpoint(config, destination)
+  ]);
+  const result = await getDirectionsWithEndpoints(config, {
+    mode: opts.mode,
+    origin: originParam,
+    destination: destinationParam,
+    strategy: opts.strategy,
+    language: opts.language,
+    vehicleSpec: opts.mode === "truck" ? {
+      heightMeters: opts.height,
+      weightTons: opts.weight,
+      lengthMeters: opts.length
+    } : void 0
+  });
+  if (result.status === "NO_ROUTE_FOUND") {
+    throw new CliError(
+      "NO_ROUTE_FOUND \u2014 \u65E0\u6CD5\u89C4\u5212\u8DEF\u7EBF",
+      ExitCode.API_ERROR,
+      "\u68C0\u67E5\u8D77\u7EC8\u70B9\u6216\u6539\u7528 maptec geocode \u786E\u8BA4\u5750\u6807"
+    );
+  }
+  handleApiBusinessStatus(result, `route.${opts.mode}`);
+  const fields = outputOpts.fields ?? opts.fields;
+  const shaped = shapeRouteOutput(result, fields);
+  await emitSuccess(
+    { command: `route.${opts.mode}`, data: shaped },
+    { ...outputOpts, fields: void 0 }
+  );
+}
+
+// src/cli.ts
+function getVersion() {
+  try {
+    const dir = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = join(dir, "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+function parseFields(value) {
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function buildOutputOptions(globalOpts) {
+  const format = globalOpts.format ?? "json";
+  if (format !== "json" && format !== "table") {
+    throw new CliError(`\u65E0\u6548 --format "${globalOpts.format}"`, ExitCode.USER_ERROR);
+  }
+  return {
+    format,
+    out: globalOpts.out,
+    quiet: globalOpts.quiet,
+    fields: globalOpts.fields ? parseFields(globalOpts.fields) : void 0
+  };
+}
+async function main() {
+  const program = new Command();
+  program.name("maptec").description("Maptec \u5730\u56FE CLI \u2014 \u7ED3\u6784\u5316 JSON \u8F93\u51FA\uFF0C\u4F9B\u5F00\u53D1\u8005\u4E0E AI Agent \u8C03\u7528").version(getVersion(), "-V, --version", "\u663E\u793A\u7248\u672C\u53F7");
+  program.option("--format <json|table>", "\u8F93\u51FA\u683C\u5F0F", "json").option("--out <file>", "\u5199\u5165\u6587\u4EF6\u800C\u975E stdout").option("--quiet", "\u51CF\u5C11 stderr \u8FDB\u5EA6\u4FE1\u606F").option("--timeout <ms>", "\u8986\u76D6\u9ED8\u8BA4\u8BF7\u6C42\u8D85\u65F6\uFF08\u6BEB\u79D2\uFF09").option("--fields <list>", "\u88C1\u526A\u8F93\u51FA\u5B57\u6BB5\uFF0C\u9017\u53F7\u5206\u9694");
+  program.command("init").description("\u4EA4\u4E92\u5F0F\u914D\u7F6E apiKey \u4E0E baseUrl").action(async () => {
+    const globalOpts = program.opts();
+    if (globalOpts.timeout) {
+      const config = await loadConfig();
+      config.timeoutMs = Number(globalOpts.timeout);
+    }
+    await runInit(buildOutputOptions(globalOpts));
+  });
+  const configCmd = program.command("config").description("\u8BFB\u5199 ~/.maptec/config.json");
+  configCmd.command("get").description("\u6253\u5370\u5F53\u524D\u914D\u7F6E\uFF08apiKey \u8131\u654F\uFF09").action(async () => {
+    const globalOpts = program.opts();
+    await runConfigGet(buildOutputOptions(globalOpts));
+  });
+  configCmd.command("set <key> <value>").description("\u8BBE\u7F6E\u914D\u7F6E\u9879\uFF1Aapi-key | base-url | default-format | timeout").action(async (key, value) => {
+    const globalOpts = program.opts();
+    await runConfigSet(key, value, buildOutputOptions(globalOpts));
+  });
+  program.command("geocode").description("\u6B63\u5411\u5730\u7406\u7F16\u7801\uFF1A\u5730\u5740 \u2192 \u5750\u6807").requiredOption("--address <text>", "\u5730\u5740\u5B57\u7B26\u4E32").option("--language <code>", "\u8FD4\u56DE\u8BED\u8A00\uFF0C\u5982 zh-CN").option("--region <code>", "\u5730\u533A\u504F\u5411\uFF0C\u5982 CN").action(async (opts) => {
+    const globalOpts = program.opts();
+    await applyTimeoutOverride(globalOpts.timeout);
+    await runGeocode(opts, buildOutputOptions(globalOpts));
+  });
+  program.command("reverse-geocode").description("\u53CD\u5411\u5730\u7406\u7F16\u7801\uFF1A\u5750\u6807 \u2192 \u5730\u5740").requiredOption("--lat <number>", "\u7EAC\u5EA6", parseFloat).requiredOption("--lng <number>", "\u7ECF\u5EA6", parseFloat).option("--language <code>", "\u8FD4\u56DE\u8BED\u8A00").option("--region <code>", "\u5730\u533A\u504F\u5411").option("--result-type <types>", "\u7ED3\u679C\u7C7B\u578B\u8FC7\u6EE4\uFF0C\u7AD6\u7EBF\u5206\u9694").option("--location-type <types>", "\u7CBE\u5EA6\u7C7B\u578B\u8FC7\u6EE4").action(async (opts) => {
+    const globalOpts = program.opts();
+    await applyTimeoutOverride(globalOpts.timeout);
+    await runReverseGeocode(
+      {
+        lat: opts.lat,
+        lng: opts.lng,
+        language: opts.language,
+        region: opts.region,
+        resultType: opts.resultType,
+        locationType: opts.locationType
+      },
+      buildOutputOptions(globalOpts)
+    );
+  });
+  const searchCmd = program.command("search").description("\u5730\u70B9\u641C\u7D22");
+  searchCmd.command("text").description("\u5173\u952E\u8BCD\u6587\u672C\u641C\u7D22").requiredOption("--query <text>", "\u641C\u7D22\u5173\u952E\u8BCD").option("--location <lng,lat>", "\u4F4D\u7F6E\u504F\u5411\uFF08\u5706\u5FC3\uFF09").option("--language <code>", "\u8BED\u8A00").option("--region <code>", "\u5730\u533A").option("--page-size <n>", "\u6BCF\u9875\u6761\u6570", parseInt).option("--type <category>", "POI \u7C7B\u522B").option("--rank <mode>", "RELEVANCE|DISTANCE|POPULARITY").action(async (opts) => {
+    const globalOpts = program.opts();
+    await applyTimeoutOverride(globalOpts.timeout);
+    await runSearchText(opts, buildOutputOptions(globalOpts));
+  });
+  searchCmd.command("nearby").description("\u9644\u8FD1\u641C\u7D22").requiredOption("--lat <number>", "\u7EAC\u5EA6", parseFloat).requiredOption("--lng <number>", "\u7ECF\u5EA6", parseFloat).option("--radius <meters>", "\u534A\u5F84\uFF08\u7C73\uFF09", parseInt).option("--types <list>", "\u7C7B\u578B\uFF0C\u9017\u53F7\u5206\u9694").option("--limit <n>", "\u7ED3\u679C\u4E0A\u9650", parseInt).option("--language <code>", "\u8BED\u8A00").option("--region <code>", "\u5730\u533A").option("--rank <mode>", "\u6392\u5E8F").action(async (opts) => {
+    const globalOpts = program.opts();
+    await applyTimeoutOverride(globalOpts.timeout);
+    await runSearchNearby(
+      {
+        lat: opts.lat,
+        lng: opts.lng,
+        radius: opts.radius,
+        types: opts.types,
+        limit: opts.limit,
+        language: opts.language,
+        region: opts.region,
+        rank: opts.rank
+      },
+      buildOutputOptions(globalOpts)
+    );
+  });
+  searchCmd.command("suggest").description("\u8F93\u5165\u63D0\u793A / \u81EA\u52A8\u8865\u5168").requiredOption("--query <text>", "\u8F93\u5165\u5B57\u7B26\u4E32").option("--location <lng,lat>", "\u4F4D\u7F6E\u504F\u5411").option("--language <code>", "\u8BED\u8A00").option("--region <code>", "\u5730\u533A").option("--limit <n>", "\u7ED3\u679C\u4E0A\u9650", parseInt).action(async (opts) => {
+    const globalOpts = program.opts();
+    await applyTimeoutOverride(globalOpts.timeout);
+    await runSearchSuggest(opts, buildOutputOptions(globalOpts));
+  });
+  searchCmd.command("place").description("\u5730\u70B9\u8BE6\u60C5").requiredOption("--id <placeId>", "\u5730\u70B9 ID").option("--language <code>", "\u8BED\u8A00").option("--region <code>", "\u5730\u533A").option("--session-token <token>", "\u4F1A\u8BDD\u4EE4\u724C").action(async (opts) => {
+    const globalOpts = program.opts();
+    await applyTimeoutOverride(globalOpts.timeout);
+    await runSearchPlace(
+      {
+        id: opts.id,
+        language: opts.language,
+        region: opts.region,
+        sessionToken: opts.sessionToken
+      },
+      buildOutputOptions(globalOpts)
+    );
+  });
+  const routeCmd = program.command("route").description("\u8DEF\u7EBF\u89C4\u5212");
+  const addRouteOptions = (cmd) => {
+    cmd.option("--from <text>", "\u8D77\u70B9\u5730\u5740\u6216 lng,lat").option("--to <text>", "\u7EC8\u70B9\u5730\u5740\u6216 lng,lat").option("--from-lat <number>", "\u8D77\u70B9\u7EAC\u5EA6", parseFloat).option("--from-lng <number>", "\u8D77\u70B9\u7ECF\u5EA6", parseFloat).option("--to-lat <number>", "\u7EC8\u70B9\u7EAC\u5EA6", parseFloat).option("--to-lng <number>", "\u7EC8\u70B9\u7ECF\u5EA6", parseFloat).option("--strategy <name>", "fastest|shortest|eco|balanced").option("--language <code>", "\u5BFC\u822A\u8BED\u8A00");
+  };
+  addRouteOptions(
+    routeCmd.command("driving").description("\u9A7E\u8F66\u8DEF\u7EBF").action(async (opts) => {
+      const globalOpts = program.opts();
+      await applyTimeoutOverride(globalOpts.timeout);
+      await runRoute(
+        {
+          mode: "driving",
+          from: opts.from,
+          to: opts.to,
+          fromLat: opts.fromLat,
+          fromLng: opts.fromLng,
+          toLat: opts.toLat,
+          toLng: opts.toLng,
+          strategy: opts.strategy,
+          language: opts.language
+        },
+        buildOutputOptions(globalOpts)
+      );
+    })
+  );
+  addRouteOptions(
+    routeCmd.command("truck").description("\u8D27\u8F66\u8DEF\u7EBF").option("--height <meters>", "\u8F66\u9AD8\uFF08\u7C73\uFF09", parseFloat).option("--weight <tons>", "\u603B\u91CD\uFF08\u5428\uFF09", parseFloat).option("--length <meters>", "\u8F66\u957F\uFF08\u7C73\uFF09", parseFloat).action(async (opts) => {
+      const globalOpts = program.opts();
+      await applyTimeoutOverride(globalOpts.timeout);
+      await runRoute(
+        {
+          mode: "truck",
+          from: opts.from,
+          to: opts.to,
+          fromLat: opts.fromLat,
+          fromLng: opts.fromLng,
+          toLat: opts.toLat,
+          toLng: opts.toLng,
+          strategy: opts.strategy,
+          language: opts.language,
+          height: opts.height,
+          weight: opts.weight,
+          length: opts.length
+        },
+        buildOutputOptions(globalOpts)
+      );
+    })
+  );
+  await program.parseAsync(process.argv);
+}
+async function applyTimeoutOverride(timeout) {
+  if (!timeout) return;
+  const ms = Number(timeout);
+  if (!Number.isFinite(ms) || ms <= 0) {
+    throw new CliError("\u65E0\u6548 --timeout \u503C", ExitCode.USER_ERROR);
+  }
+  const config = await loadConfig();
+  const { saveConfig: saveConfig2 } = await import("./store-ZU7HLXCV.js");
+  config.timeoutMs = ms;
+  await saveConfig2(config);
+}
+main().catch(exitWithError);
+//# sourceMappingURL=cli.js.map