fortrip 2.0.0 → 3.0.0

package/dist/cli.js

@@ -4,20 +4,28 @@ import {
   COMMANDS,
   COMMAND_GROUPS,
   CliError,
+  DEFAULT_API_URL,
+  DEFAULT_MCP_URL,
   EXIT,
   GLOBAL_FLAGS,
+  LIMITS,
+  TOOLS,
   VERSION,
   authorizedRequest,
   commandInvocation,
+  fieldLines,
+  formatError,
   login,
   logout,
   notices,
   renderGuide,
+  renderToolResult,
   resolveApiUrl,
+  resolveMcpUrl,
   unwrap,
   usageError,
   whoami
-} from "./chunk-53656LB2.js";
+} from "./chunk-26IHFJYT.js";
 
 // src/commands.ts
 import { readFileSync } from "fs";
@@ -25,7 +33,6 @@ import { parseArgs } from "util";
 
 // src/help.ts
 var WIDTH = 78;
-var OPTIONAL_POSITIONALS = /* @__PURE__ */ new Set(["topic"]);
 function wrap(text, indent) {
   const pad = " ".repeat(indent);
   const lines = [];
@@ -43,7 +50,7 @@ function wrap(text, indent) {
 }
 function positionals(spec) {
   return (spec.positionals ?? []).map(
-    (name) => OPTIONAL_POSITIONALS.has(name) ? `[${name}]` : `<${name}>`
+    ({ name, optional }) => optional ? `[${name}]` : `<${name}>`
   );
 }
 function label(spec) {
@@ -53,13 +60,13 @@ function usageLine(spec) {
   return [commandInvocation(spec), ...positionals(spec), "[options]"].join(" ");
 }
 function names(option, aligned) {
-  const short = option.short ? `-${option.short}, ` : aligned ? "    " : "";
+  const short = "short" in option && option.short ? `-${option.short}, ` : aligned ? "    " : "";
   const placeholder = option.placeholder ? ` ${option.placeholder}` : "";
   const repeats = "multiple" in option && option.multiple ? "..." : "";
   return `${short}--${option.flag}${placeholder}${repeats}`;
 }
 function optionList(options) {
-  const aligned = options.some((option) => option.short);
+  const aligned = options.some((option) => "short" in option && option.short);
   return options.map(
     (option) => [`  ${names(option, aligned)}`, ...wrap(option.description, 8)].join("\n")
   ).join("\n");
@@ -98,7 +105,7 @@ ${optionList(HELP_FLAG)}
 `;
 }
 var CURRENCY_COMMANDS = COMMANDS.filter(
-  (spec) => spec.flags.some((flag) => flag.field === "currency")
+  (spec) => spec.flags.some((flag) => flag.field === "displayCurrency")
 ).map((spec) => commandInvocation(spec).slice("fortrip ".length)).join(" and ");
 function overallHelp() {
   const rows = [
@@ -118,32 +125,57 @@ ${commandList(rows)}
 Options:
 ${optionList(GLOBAL_FLAGS)}
 
-Output is JSON on stdout; errors are JSON on stderr.
-Exit codes: 0 ok, 1 error (retry once when stderr has "retryable": true),
+Output is compact text on stdout; --json prints it as one line of JSON.
+Errors go to stderr, as text or, with --json, as JSON.
+Exit codes: 0 ok, 1 error (retry once when the error says it is retryable),
 2 invalid arguments, 3 not logged in, 4 rate limited.
 
 Environment:
-  FORTRIP_TOKEN    Use this token instead of the saved login (CI, sandboxes)
-  FORTRIP_API_URL  API base URL (default https://fortrip.ai)
-  FORTRIP_CURRENCY Default --currency for ${CURRENCY_COMMANDS}
+  FORTRIP_TOKEN             Use this token instead of the saved login (CI, sandboxes)
+  FORTRIP_API_URL           API base URL (default ${DEFAULT_API_URL})
+  FORTRIP_MCP_URL           MCP server URL for fortrip mcp (default ${DEFAULT_MCP_URL})
+  FORTRIP_DISPLAY_CURRENCY  Default --display-currency for ${CURRENCY_COMMANDS}
 `;
 }
 
 // src/commands.ts
-var COMMA_LISTS = /* @__PURE__ */ new Set(["hotelIds", "childrenAges", "boardCodes"]);
-var UPPER_CASE = /* @__PURE__ */ new Set(["nationality", "boardCodes", "currency"]);
-var TURNS_OFF = /* @__PURE__ */ new Set(["bookableOnly"]);
-var POSTS = {
-  search_hotels: API.search,
-  get_hotel_rates: API.rates,
-  book_hotel: API.bookings
+var UPPER_CASE = /* @__PURE__ */ new Set(["displayCurrency", "destination.countryCode"]);
+var FROM_ENV = { displayCurrency: "FORTRIP_DISPLAY_CURRENCY" };
+var ONE_ITEM_LISTS = /* @__PURE__ */ new Set(["items"]);
+var GUEST_FIELD = "items.hotel.rooms.guests";
+var ROOMS_FIELD = "items.hotel.rooms";
+var locale = (input) => input.locale;
+var ROUTES = {
+  search_hotels: { method: "POST", path: () => API.hotelSearch },
+  get_hotel: {
+    method: "GET",
+    path: (input) => API.hotel(input.hotelId, { rooms: input.include === "rooms", locale: locale(input) })
+  },
+  get_hotel_offers: { method: "POST", path: () => API.hotelOffers },
+  book_hotel: { method: "POST", path: () => API.orders },
+  get_order: {
+    method: "GET",
+    path: (input) => API.order(input.orderId, { locale: locale(input) })
+  },
+  list_orders: {
+    method: "GET",
+    path: (input) => {
+      const query = new URLSearchParams();
+      for (const name of ["cursor", "limit", "locale"]) {
+        if (input[name] !== void 0) query.set(name, String(input[name]));
+      }
+      const text = query.toString();
+      return text ? `${API.orders}?${text}` : API.orders;
+    }
+  }
 };
+var PATH_FIELDS = /* @__PURE__ */ new Set(["hotelId", "orderId"]);
 function parseOptions(spec, argv) {
   const options = {};
   for (const option of [...spec.flags, ...spec.options ?? []]) {
     options[option.flag] = {
       type: option.type === "boolean" ? "boolean" : "string",
-      ...option.short ? { short: option.short } : {},
+      ..."short" in option && option.short ? { short: option.short } : {},
       ..."multiple" in option && option.multiple ? { multiple: true } : {}
     };
   }
@@ -175,38 +207,83 @@ function parseOptions(spec, argv) {
   return { values: parsed.values, positionals: parsed.positionals };
 }
 function parseCommand(spec, argv, env) {
-  const post = spec.tool ? POSTS[spec.tool] : void 0;
-  if (!post && spec.tool !== "get_hotel") {
-    throw new Error(`${commandInvocation(spec)} sends no request`);
-  }
+  const route = spec.tool ? ROUTES[spec.tool] : void 0;
+  if (!route) throw new Error(`${commandInvocation(spec)} sends no request`);
   const { values, positionals: positionals2 } = parseOptions(spec, argv);
   const input = baseBody(values.body);
-  for (const flag of spec.flags) {
-    const raw = values[flag.flag];
-    if (raw !== void 0) setField(input, flag.field, readFlag(flag, raw));
+  const wanted = spec.positionals ?? [];
+  if (positionals2.length !== wanted.length) throw usageError(`Usage: ${usageLine(spec)}`);
+  wanted.forEach((positional, index) => {
+    if (positional.field) input[positional.field] = positionals2[index];
+  });
+  setFlags(spec, values, input);
+  const fromEnv = /* @__PURE__ */ new Map();
+  for (const [field, name] of Object.entries(FROM_ENV)) {
+    const fallback = env[name]?.trim().toUpperCase();
+    if (fallback && input[field] === void 0 && spec.flags.some((flag) => flag.field === field)) {
+      input[field] = fallback;
+      fromEnv.set(`/${field}`, name);
+    }
   }
-  if (spec.tool === "get_hotel") {
-    const [hotelId, ...extra] = positionals2;
-    const parsed = Number(hotelId);
-    if (!hotelId || extra.length || !/^\d+$/.test(hotelId) || !Number.isSafeInteger(parsed)) {
-      throw usageError(`Usage: ${usageLine(spec)}`);
+  check(spec, input, route.method === "GET", fromEnv);
+  const path = route.path(input);
+  return route.method === "POST" ? { method: "POST", path, body: input } : { method: "GET", path };
+}
+function check(spec, input, isGet, fromEnv) {
+  const schema = TOOLS.find((tool) => tool.name === spec.tool)?.input;
+  const result = schema?.safeParse(input);
+  if (!result || result.success) return;
+  const pointer = (path) => {
+    const keys = path.map((key) => String(key).replaceAll("~", "~0").replaceAll("/", "~1"));
+    const where = isGet && keys[0] !== void 0 ? [PATH_FIELDS.has(keys[0]) ? "path" : "query"] : [];
+    return [...where, ...keys].map((key) => `/${key}`).join("");
+  };
+  const issues = result.error.issues.flatMap(
+    (issue) => issue.code === "unrecognized_keys" ? issue.keys.map((key) => ({
+      pointer: pointer([...issue.path, key]),
+      message: `Unknown field: ${key}`
+    })) : [{ pointer: pointer(issue.path), message: issue.message }]
+  ).map(({ pointer: pointer2, message }) => {
+    const name = fromEnv.get(pointer2);
+    return { pointer: pointer2, message: name ? `${name}: ${message}` : message };
+  });
+  throw new CliError(
+    `Not sent: ${commandInvocation(spec)} was given an invalid request.`,
+    EXIT.usage,
+    { details: { issues } }
+  );
+}
+function setFlags(spec, values, input) {
+  const given = spec.flags.filter((flag) => values[flag.flag] !== void 0);
+  const picked = /* @__PURE__ */ new Map();
+  for (const flag of given) {
+    for (const [field, value] of Object.entries(flag.sets ?? {})) {
+      const earlier = picked.get(field);
+      if (earlier && earlier.value !== value) {
+        throw usageError(
+          `--${earlier.flag} and --${flag.flag} can't be given together: they set ${field} to "${earlier.value}" and "${value}"`
+        );
+      }
+      if (!earlier) picked.set(field, { value, flag: flag.flag });
     }
-    return { path: API.hotel(parsed, input.includeRooms === true) };
   }
-  if (spec.flags.some((flag) => flag.field === "currency") && input.currency === void 0) {
-    const fallback = env.FORTRIP_CURRENCY?.trim().toUpperCase();
-    if (fallback) input.currency = fallback;
+  for (const [field, { value }] of picked) {
+    const parent = field.split(".").slice(0, -1).join(".");
+    const key = field.split(".").at(-1);
+    const existing = parent ? getField(input, parent) : input;
+    if (isObject(existing) && existing[key] !== void 0 && existing[key] !== value) {
+      setField(input, parent, {});
+    }
+    setField(input, field, value);
   }
-  const occupancy = spec.flags.filter(
-    (flag) => flag.field === "rooms" || flag.field === "adults"
-  );
-  const missing = occupancy.filter((flag) => input[flag.field] === void 0);
-  if (occupancy.length === 2 && missing.length) {
-    throw usageError(
-      `${commandInvocation(spec)} needs ${missing.map((flag) => `--${flag.flag}`).join(" and ")}, per room and the same for every room (2 rooms for 4 adults is --rooms 2 --adults 2)`
-    );
+  for (const flag of given) {
+    const raw = values[flag.flag];
+    if (flag.field === GUEST_FIELD) {
+      setField(input, ROOMS_FIELD, withGuests(getField(input, ROOMS_FIELD), parseGuests(raw)));
+    } else {
+      setField(input, flag.field, readFlag(flag, raw));
+    }
   }
-  return { body: input, path: post };
 }
 function baseBody(raw) {
   if (typeof raw !== "string") return {};
@@ -220,76 +297,125 @@ function baseBody(raw) {
   }
   try {
     const parsed = JSON.parse(text);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return parsed;
-    }
+    if (isObject(parsed)) return parsed;
   } catch {
   }
   throw usageError("--body must be a JSON object");
 }
-function setField(body, field, value) {
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function step(node, part, create) {
+  if (ONE_ITEM_LISTS.has(part)) {
+    let list = node[part];
+    if (!Array.isArray(list)) {
+      if (!create) return void 0;
+      list = node[part] = [];
+    }
+    const items = list;
+    if (!isObject(items[0])) {
+      if (!create) return void 0;
+      items[0] = {};
+    }
+    return items[0];
+  }
+  if (!isObject(node[part])) {
+    if (!create) return void 0;
+    node[part] = {};
+  }
+  return node[part];
+}
+function getField(body, field) {
+  let node = body;
   const path = field.split(".");
   const last = path.pop();
-  let node = body;
   for (const part of path) {
-    const next = node[part];
-    node[part] = next && typeof next === "object" && !Array.isArray(next) ? next : {};
-    node = node[part];
+    node = node && step(node, part, false);
   }
+  return node?.[last];
+}
+function setField(body, field, value) {
+  const path = field.split(".");
+  const last = path.pop();
+  let node = body;
+  for (const part of path) node = step(node, part, true);
   node[last] = value;
 }
 function readFlag(flag, raw) {
-  if (flag.type === "boolean") return !TURNS_OFF.has(flag.field);
+  if (flag.type === "boolean") return flag.value ?? true;
   const given = Array.isArray(raw) ? raw : [raw];
-  if (flag.field === "near") return parseNear(given[0]);
-  if (flag.field === "guests") return given.map(parseGuest);
-  const parts = COMMA_LISTS.has(flag.field) ? given.flatMap((value) => value.split(",")).map((part) => part.trim()) : given;
-  const values = parts.map((part) => {
-    const text = UPPER_CASE.has(flag.field) ? part.trim().toUpperCase() : part;
-    if (flag.field === "currency" && text === "") {
-      throw usageError(`--${flag.flag} must not be empty`);
-    }
-    if (flag.type === "number") return num(flag.flag, text);
-    return flag.type === "id" ? id(flag.flag, text) : text;
+  switch (flag.field) {
+    case "destination.location":
+      return parsePoint(given[0]);
+    case "stay.rooms":
+      return given.map(parseRoom);
+    case "filters.price.maxPerRoomNight":
+      return { amount: given[0].trim(), currency: "USD" };
+  }
+  const parsed = given.map((value) => {
+    if (flag.type === "number") return num(flag.flag, value);
+    return UPPER_CASE.has(flag.field) ? value.trim().toUpperCase() : value;
   });
-  return flag.multiple ? values : values[0];
+  return flag.multiple ? parsed : parsed[0];
 }
 function num(flag, value) {
-  const parsed = Number(value);
-  if (value.trim() === "" || !Number.isFinite(parsed)) {
+  const text = value.trim();
+  if (!/^[+-]?\d+(\.\d+)?$/.test(text)) {
     throw usageError(`--${flag} must be a number, got "${value}"`);
   }
-  return parsed;
-}
-function id(flag, value) {
-  const parsed = Number(value.trim());
-  if (!/^\d+$/.test(value.trim()) || !Number.isSafeInteger(parsed)) {
-    throw usageError(`--${flag} must be a numeric id, got "${value}"`);
-  }
-  return parsed;
+  return Number(text);
 }
-function parseNear(value) {
+function parsePoint(value) {
   const parts = value.split(",").map((part) => part.trim());
-  if (parts.length !== 3 || parts.some((part) => !part)) {
-    throw usageError("--near must be lat,lng,radiusKm (e.g. 13.75,100.5,5)");
+  if (parts.length !== 2 || parts.some((part) => !/^[+-]?\d+(\.\d+)?$/.test(part))) {
+    throw usageError(`--point must be lat,lng (e.g. 13.75,100.5), got "${value}"`);
   }
-  const [lat, lng, radiusKm] = parts.map((part) => num("near", part));
-  return { lat, lng, radiusKm };
+  const [lat, lng] = parts.map(Number);
+  return { lat, lng };
 }
-function parseGuest(value) {
-  const match = value.trim().match(/^(.+?)(?::(\d+))?$/);
-  const words = match?.[1]?.trim().split(/\s+/) ?? [];
-  if (words.length < 2) {
+function parseRoom(value) {
+  const match = value.replace(/\s+/g, "").match(/^(\d+)(?::(\d+(?:,\d+)*))?$/);
+  if (!match) {
     throw usageError(
-      `--guest must be "First Last" or "First Last:roomNo", got "${value}"`
+      `--room must be adults or adults:age,age with each child's age (e.g. 2 or 2:6,9), got "${value}"`
     );
   }
   return {
-    firstName: words.slice(0, -1).join(" "),
-    lastName: words.at(-1),
-    roomNo: match?.[2] ? Number(match[2]) : 1
+    adults: Number(match[1]),
+    childrenAges: match[2] ? match[2].split(",").map(Number) : []
   };
 }
+function parseGuests(values) {
+  const rooms = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const parts = value.split(":").map((part) => part.trim());
+    const [room, firstName, lastName] = parts;
+    const number = Number(room);
+    if (parts.length !== 3 || !/^\d+$/.test(room ?? "")) {
+      throw usageError(`--guest must be room:first:last (e.g. 1:John:Smith), got "${value}"`);
+    }
+    if (number < 1 || number > LIMITS.rooms) {
+      throw usageError(`--guest room must be 1 to ${LIMITS.rooms}, got "${value}"`);
+    }
+    rooms.set(number, [...rooms.get(number) ?? [], { firstName, lastName }]);
+  }
+  return rooms;
+}
+function withGuests(fromBody, guests) {
+  const rooms = Array.isArray(fromBody) ? [...fromBody] : [];
+  for (const [number, list] of guests) {
+    const room = rooms[number - 1];
+    rooms[number - 1] = { ...isObject(room) ? room : {}, guests: list };
+  }
+  for (let index = 0; index < rooms.length; index++) {
+    if (rooms[index] === void 0) {
+      throw usageError(
+        `--guest rooms are numbered from 1 with none skipped: no guest for room ${index + 1}`
+      );
+    }
+  }
+  return rooms;
+}
 
 // src/guide.ts
 function readGuide(topic) {
@@ -303,8 +429,11 @@ function globalFlag(name) {
 }
 var HELP_FLAGS = globalFlag("help");
 var VERSION_FLAGS = globalFlag("version");
+var JSON_FLAG = "--json";
 var RENAMED = /* @__PURE__ */ new Map([
-  ["hotel", { group: "hotels", name: "get" }]
+  ["hotel", { group: "hotels", name: "get" }],
+  ["rates", { group: "hotels", name: "offers" }],
+  ["hotels rates", { group: "hotels", name: "offers" }]
 ]);
 function findCommand(argv) {
   const [word, ...afterWord] = argv;
@@ -318,8 +447,9 @@ function findCommand(argv) {
       (candidate) => candidate.group === group.name && candidate.name === name
     );
     if (!spec2) {
+      const renamed2 = RENAMED.get(`${group.name} ${name}`);
       throw usageError(
-        `Unknown command "${group.name} ${name}". Run \`fortrip ${group.name} --help\`.`
+        renamed2 ? `Unknown command "${group.name} ${name}". Did you mean \`${commandInvocation(renamed2)}\`?` : `Unknown command "${group.name} ${name}". Run \`fortrip ${group.name} --help\`.`
       );
     }
     return { spec: spec2, rest };
@@ -377,26 +507,39 @@ async function run(argv) {
         if (process.env.FORTRIP_TOKEN) {
           log("Note: FORTRIP_TOKEN is set and takes precedence over this login.");
         }
-        return login({ apiUrl, openBrowser: !values["no-browser"], log });
+        return account(await login({ apiUrl, openBrowser: !values["no-browser"], log }));
       }
-      case "logout":
+      case "logout": {
         parseOptions(spec, rest);
-        return logout(apiUrl);
+        const data2 = await logout(apiUrl);
+        return { data: data2, text: `Logged out of ${apiUrl}.` };
+      }
       case "whoami":
         parseOptions(spec, rest);
-        return whoami(apiUrl);
+        return account(await whoami(apiUrl));
       case "mcp": {
         parseOptions(spec, rest);
-        const { runMcpBridge } = await import("./mcp-bridge-LPQBHWLD.js");
-        return runMcpBridge(apiUrl);
+        const mcpUrl = resolveMcpUrl(apiUrl);
+        const { runMcpBridge } = await import("./mcp-bridge-3WLWV2KY.js");
+        await runMcpBridge(mcpUrl, apiUrl);
+        return void 0;
       }
     }
   }
-  const { body, path } = parseCommand(spec, rest, process.env);
-  return call(apiUrl, body ? "POST" : "GET", path, body);
+  const { method, path, body } = parseCommand(spec, rest, process.env);
+  const data = unwrap(await authorizedRequest(apiUrl, path, { method, body }));
+  return { data, text: renderToolResult(spec.tool, data) };
 }
-async function call(apiUrl, method, path, body) {
-  return unwrap(await authorizedRequest(apiUrl, path, { method, body }));
+function account(data) {
+  const { apiUrl, userId, email, name } = data;
+  const given = (value) => value ?? "not given";
+  return {
+    data,
+    text: [
+      `Signed in to ${apiUrl}.`,
+      ...fieldLines({ userId, email: given(email), name: given(name) })
+    ].join("\n")
+  };
 }
 function wantsHelp(args) {
   for (const arg of args) {
@@ -405,21 +548,33 @@ function wantsHelp(args) {
   }
   return false;
 }
+function takeJson(argv) {
+  const end = argv.indexOf("--");
+  const before = end === -1 ? argv : argv.slice(0, end);
+  const after = end === -1 ? [] : argv.slice(end);
+  const kept = before.filter((arg) => arg !== JSON_FLAG);
+  return { json: kept.length < before.length, argv: [...kept, ...after] };
+}
 async function main() {
+  const { json, argv } = takeJson(process.argv.slice(2));
   try {
-    const result = await run(process.argv.slice(2));
-    if (result !== void 0) {
-      const output = result && typeof result === "object" && !Array.isArray(result) ? { ...result, ...notices } : result;
-      process.stdout.write(`${JSON.stringify(output, null, 2)}
+    const answer = await run(argv);
+    if (answer !== void 0) {
+      const { data, text } = answer;
+      if (json) {
+        const output = data && typeof data === "object" && !Array.isArray(data) ? { ...data, ...notices } : data;
+        process.stdout.write(`${JSON.stringify(output)}
+`);
+      } else {
+        process.stdout.write(`${[text, ...fieldLines(notices)].join("\n")}
 `);
+      }
     }
     return EXIT.ok;
   } catch (error) {
     const failure = error instanceof CliError ? error : new CliError(error?.message ?? String(error), EXIT.error);
-    process.stderr.write(
-      `${JSON.stringify({ error: failure.message, exitCode: failure.exitCode, ...failure.details, ...notices }, null, 2)}
-`
-    );
+    process.stderr.write(`${formatError(failure, json)}
+`);
     return failure.exitCode;
   }
 }