fortrip 1.0.0 → 2.0.0

package/dist/cli.js

@@ -2,11 +2,13 @@
 import {
   API,
   COMMANDS,
+  COMMAND_GROUPS,
   CliError,
   EXIT,
   GLOBAL_FLAGS,
   VERSION,
   authorizedRequest,
+  commandInvocation,
   login,
   logout,
   notices,
@@ -15,7 +17,7 @@ import {
   unwrap,
   usageError,
   whoami
-} from "./chunk-OBK2KTLC.js";
+} from "./chunk-53656LB2.js";
 
 // src/commands.ts
 import { readFileSync } from "fs";
@@ -39,14 +41,16 @@ function wrap(text, indent) {
   if (line) lines.push(pad + line);
   return lines;
 }
-function invocation(spec) {
-  const positionals = (spec.positionals ?? []).map(
+function positionals(spec) {
+  return (spec.positionals ?? []).map(
     (name) => OPTIONAL_POSITIONALS.has(name) ? `[${name}]` : `<${name}>`
   );
-  return ["fortrip", spec.name, ...positionals].join(" ");
+}
+function label(spec) {
+  return [spec.name, ...positionals(spec)].join(" ");
 }
 function usageLine(spec) {
-  return `${invocation(spec)} [options]`;
+  return [commandInvocation(spec), ...positionals(spec), "[options]"].join(" ");
 }
 function names(option, aligned) {
   const short = option.short ? `-${option.short}, ` : aligned ? "    " : "";
@@ -71,23 +75,45 @@ Options:
 ${optionList(options)}
 `;
 }
-function commandList() {
-  const labels = COMMANDS.map((spec) => invocation(spec).slice("fortrip ".length));
-  const column = 2 + Math.max(...labels.map((label) => label.length)) + 2;
-  return COMMANDS.map((spec, n) => {
-    const [first = "", ...rest] = wrap(spec.summary, column);
-    const label = `  ${labels[n]}`.padEnd(column);
-    return [label + first.slice(column), ...rest].join("\n");
+function commandList(rows) {
+  const column = 2 + Math.max(...rows.map(([name]) => name.length)) + 2;
+  return rows.map(([name, summary]) => {
+    const [first = "", ...rest] = wrap(summary, column);
+    return [`  ${name}`.padEnd(column) + first.slice(column), ...rest].join("\n");
   }).join("\n");
 }
+function groupHelp(group) {
+  const usage = `fortrip ${group.name} <command>`;
+  const commands = COMMANDS.filter((spec) => spec.group === group.name);
+  return `Usage: ${usage} [options]
+       ${usage} --help
+
+${wrap(group.summary, 0).join("\n")}
+
+Commands:
+${commandList(commands.map((spec) => [label(spec), spec.summary]))}
+
+Options:
+${optionList(HELP_FLAG)}
+`;
+}
+var CURRENCY_COMMANDS = COMMANDS.filter(
+  (spec) => spec.flags.some((flag) => flag.field === "currency")
+).map((spec) => commandInvocation(spec).slice("fortrip ".length)).join(" and ");
 function overallHelp() {
+  const rows = [
+    ...COMMAND_GROUPS.map((group) => [`${group.name} <command>`, group.summary]),
+    ...COMMANDS.filter((spec) => spec.group === null).map(
+      (spec) => [label(spec), spec.summary]
+    )
+  ];
   return `fortrip ${VERSION} \u2014 search, price and book Fortrip hotels
 
 Usage: fortrip <command> [options]
        fortrip <command> --help
 
 Commands:
-${commandList()}
+${commandList(rows)}
 
 Options:
 ${optionList(GLOBAL_FLAGS)}
@@ -99,7 +125,7 @@ Exit codes: 0 ok, 1 error (retry once when stderr has "retryable": true),
 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 search and rates
+  FORTRIP_CURRENCY Default --currency for ${CURRENCY_COMMANDS}
 `;
 }
 
@@ -108,9 +134,9 @@ var COMMA_LISTS = /* @__PURE__ */ new Set(["hotelIds", "childrenAges", "boardCod
 var UPPER_CASE = /* @__PURE__ */ new Set(["nationality", "boardCodes", "currency"]);
 var TURNS_OFF = /* @__PURE__ */ new Set(["bookableOnly"]);
 var POSTS = {
-  search: API.search,
-  rates: API.rates,
-  book: API.bookings
+  search_hotels: API.search,
+  get_hotel_rates: API.rates,
+  book_hotel: API.bookings
 };
 function parseOptions(spec, argv) {
   const options = {};
@@ -143,24 +169,24 @@ function parseOptions(spec, argv) {
   }
   if (!spec.positionals && parsed.positionals.length) {
     throw usageError(
-      `${spec.name} takes no arguments, got "${parsed.positionals[0]}"`
+      `${commandInvocation(spec)} takes no arguments, got "${parsed.positionals[0]}"`
     );
   }
   return { values: parsed.values, positionals: parsed.positionals };
 }
 function parseCommand(spec, argv, env) {
-  const post = POSTS[spec.name];
-  if (!post && spec.name !== "hotel") {
-    throw new Error(`${spec.name} sends no request`);
+  const post = spec.tool ? POSTS[spec.tool] : void 0;
+  if (!post && spec.tool !== "get_hotel") {
+    throw new Error(`${commandInvocation(spec)} sends no request`);
   }
-  const { values, positionals } = parseOptions(spec, argv);
+  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));
   }
-  if (spec.name === "hotel") {
-    const [hotelId, ...extra] = positionals;
+  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)}`);
@@ -177,7 +203,7 @@ function parseCommand(spec, argv, env) {
   const missing = occupancy.filter((flag) => input[flag.field] === void 0);
   if (occupancy.length === 2 && missing.length) {
     throw usageError(
-      `${spec.name} 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)`
+      `${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)`
     );
   }
   return { body: input, path: post };
@@ -277,8 +303,42 @@ function globalFlag(name) {
 }
 var HELP_FLAGS = globalFlag("help");
 var VERSION_FLAGS = globalFlag("version");
+var RENAMED = /* @__PURE__ */ new Map([
+  ["hotel", { group: "hotels", name: "get" }]
+]);
+function findCommand(argv) {
+  const [word, ...afterWord] = argv;
+  const group = COMMAND_GROUPS.find((candidate) => candidate.name === word);
+  if (group) {
+    const [name, ...rest] = afterWord;
+    if (!name || name === "help" || HELP_FLAGS.includes(name)) {
+      return { groupHelp: group };
+    }
+    const spec2 = COMMANDS.find(
+      (candidate) => candidate.group === group.name && candidate.name === name
+    );
+    if (!spec2) {
+      throw usageError(
+        `Unknown command "${group.name} ${name}". Run \`fortrip ${group.name} --help\`.`
+      );
+    }
+    return { spec: spec2, rest };
+  }
+  const spec = COMMANDS.find(
+    (candidate) => candidate.group === null && candidate.name === word
+  );
+  if (spec) return { spec, rest: afterWord };
+  const renamed = RENAMED.get(word ?? "");
+  const meant = [
+    ...COMMANDS.filter((candidate) => candidate.group !== null && candidate.name === word),
+    ...renamed ? [renamed] : []
+  ].map((candidate) => `\`${commandInvocation(candidate)}\``);
+  throw usageError(
+    meant.length ? `Unknown command "${word}". Did you mean ${meant.join(" or ")}?` : `Unknown command "${word}". Run \`fortrip --help\`.`
+  );
+}
 async function run(argv) {
-  const [command, ...rest] = argv;
+  const [command] = argv;
   if (!command || command === "help" || HELP_FLAGS.includes(command)) {
     process.stdout.write(overallHelp());
     return void 0;
@@ -288,17 +348,19 @@ async function run(argv) {
 `);
     return void 0;
   }
-  const spec = COMMANDS.find((candidate) => candidate.name === command);
-  if (!spec) {
-    throw usageError(`Unknown command "${command}". Run \`fortrip --help\`.`);
+  const found = findCommand(argv);
+  if ("groupHelp" in found) {
+    process.stdout.write(groupHelp(found.groupHelp));
+    return void 0;
   }
+  const { spec, rest } = found;
   if (wantsHelp(rest)) {
     process.stdout.write(commandHelp(spec));
     return void 0;
   }
-  if (spec.name === "guide") {
-    const { positionals } = parseOptions(spec, rest);
-    const topic = positionals.join(" ");
+  if (spec.group === null && spec.name === "guide") {
+    const { positionals: positionals2 } = parseOptions(spec, rest);
+    const topic = positionals2.join(" ");
     if (topic !== "" && topic !== "planning") {
       throw usageError("Usage: fortrip guide [planning]");
     }
@@ -308,30 +370,30 @@ async function run(argv) {
   const apiUrl = resolveApiUrl();
   const log = (line) => process.stderr.write(`${line}
 `);
-  switch (spec.name) {
-    case "login": {
-      const { values } = parseOptions(spec, rest);
-      if (process.env.FORTRIP_TOKEN) {
-        log("Note: FORTRIP_TOKEN is set and takes precedence over this login.");
+  if (spec.group === null) {
+    switch (spec.name) {
+      case "login": {
+        const { values } = parseOptions(spec, rest);
+        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 });
+      }
+      case "logout":
+        parseOptions(spec, rest);
+        return logout(apiUrl);
+      case "whoami":
+        parseOptions(spec, rest);
+        return whoami(apiUrl);
+      case "mcp": {
+        parseOptions(spec, rest);
+        const { runMcpBridge } = await import("./mcp-bridge-LPQBHWLD.js");
+        return runMcpBridge(apiUrl);
       }
-      return login({ apiUrl, openBrowser: !values["no-browser"], log });
-    }
-    case "logout":
-      parseOptions(spec, rest);
-      return logout(apiUrl);
-    case "whoami":
-      parseOptions(spec, rest);
-      return whoami(apiUrl);
-    case "mcp": {
-      parseOptions(spec, rest);
-      const { runMcpBridge } = await import("./mcp-bridge-VEJ33LYD.js");
-      return runMcpBridge(apiUrl);
-    }
-    default: {
-      const { body, path } = parseCommand(spec, rest, process.env);
-      return call(apiUrl, body ? "POST" : "GET", path, body);
     }
   }
+  const { body, path } = parseCommand(spec, rest, process.env);
+  return call(apiUrl, body ? "POST" : "GET", path, body);
 }
 async function call(apiUrl, method, path, body) {
   return unwrap(await authorizedRequest(apiUrl, path, { method, body }));

package/dist/{mcp-bridge-VEJ33LYD.js → mcp-bridge-LPQBHWLD.js}

@@ -1,11 +1,15 @@
 #!/usr/bin/env node
 import {
   API,
+  CONTRACT_VERSION,
   CliError,
   EXIT,
+  TOOLS,
+  loadSession,
   refreshSession,
+  renderGuide,
   requireToken
-} from "./chunk-OBK2KTLC.js";
+} from "./chunk-53656LB2.js";
 
 // src/mcp-bridge.ts
 import {
@@ -15,6 +19,10 @@ import {
   SdkHttpError,
   StreamableHTTPClientTransport
 } from "@modelcontextprotocol/client";
+import {
+  InMemoryTransport,
+  McpServer
+} from "@modelcontextprotocol/server";
 import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
 var SIGN_IN_REQUIRED = -32001;
 var INTERNAL_ERROR = -32603;
@@ -121,27 +129,74 @@ var CONNECTION_LOST = {
   message: "The connection to Fortrip ended before it answered.",
   data: { retryable: true }
 };
+var SWITCH_TIMEOUT_MS = 6e4;
+async function hasSignIn(apiUrl) {
+  if (process.env.FORTRIP_TOKEN?.trim()) return true;
+  return await loadSession(apiUrl).catch(() => null) !== null;
+}
+function localServer() {
+  const server = new McpServer(
+    { name: "fortrip", version: CONTRACT_VERSION },
+    { instructions: renderGuide("mcp", "main") }
+  );
+  const handler = () => {
+    throw new Error("Fortrip's tools run on the hosted server.");
+  };
+  for (const spec of TOOLS) {
+    const config = {
+      title: spec.title,
+      description: spec.description,
+      annotations: spec.annotations,
+      outputSchema: spec.output ?? void 0
+    };
+    if (spec.input === null) {
+      server.registerTool(spec.name, config, handler);
+    } else {
+      server.registerTool(
+        spec.name,
+        { ...config, inputSchema: spec.input },
+        handler
+      );
+    }
+  }
+  return server;
+}
 async function runMcpBridge(apiUrl, io = {
   stdin: process.stdin,
   stdout: process.stdout
-}) {
+}, { switchTimeoutMs = SWITCH_TIMEOUT_MS } = {}) {
   const stderr = io.stderr ?? process.stderr;
   const stdio = new StdioServerTransport(io.stdin, io.stdout);
   const http = new StreamableHTTPClientTransport(new URL(API.mcp, apiUrl), {
     fetch: authorizedFetch(apiUrl)
   });
+  const server = localServer();
+  const [local, localServerEnd] = InMemoryTransport.createLinkedPair();
+  const signInSaved = await hasSignIn(apiUrl);
   let closed = false;
+  let remote = false;
+  let clientInitialize;
+  let listChanged = false;
+  let received = 0;
+  let abandonedThrough = 0;
   const pending = /* @__PURE__ */ new Set();
   let initializeId;
+  const asked = /* @__PURE__ */ new Map();
   const log = (message) => {
     if (!closed) stderr.write(`fortrip mcp: ${message}
 `);
   };
+  const toClient = (message) => {
+    stdio.send(message).catch((cause) => log(cause.message));
+  };
   const fail = (id, error) => {
     if (closed || !pending.delete(id)) return;
-    stdio.send({ jsonrpc: "2.0", id, error }).catch((cause) => log(cause.message));
+    toClient({ jsonrpc: "2.0", id, error });
   };
-  stdio.onmessage = async (message) => {
+  const adopt = ({ result }) => {
+    if (typeof result.protocolVersion === "string") http.setProtocolVersion(result.protocolVersion);
+  };
+  const forward = async (message) => {
     if (!isJSONRPCRequest(message)) {
       await http.send(message).catch(() => {
       });
@@ -155,15 +210,107 @@ async function runMcpBridge(apiUrl, io = {
       fail(message.id, rpcErrorOf(error));
     }
   };
+  const ask = (request, signal) => {
+    let waiter;
+    return new Promise((resolve, reject) => {
+      waiter = resolve;
+      asked.set(request.id, resolve);
+      http.send(request, {
+        requestSignal: signal,
+        onRequestStreamEnd: () => resolve({ jsonrpc: "2.0", id: request.id, error: CONNECTION_LOST })
+      }).catch(reject);
+    }).finally(() => {
+      if (asked.get(request.id) === waiter) asked.delete(request.id);
+    });
+  };
+  const initialize = async (request) => {
+    clientInitialize = request;
+    if (signInSaved) {
+      try {
+        const answer = await ask(request);
+        if (isJSONRPCResultResponse(answer)) {
+          adopt(answer);
+          remote = true;
+        }
+        return toClient(answer);
+      } catch (error) {
+        if (!(error instanceof SignInRequired)) {
+          return toClient({ jsonrpc: "2.0", id: request.id, error: rpcErrorOf(error) });
+        }
+      }
+    }
+    await local.send(request);
+  };
+  const handshake = async (initialize2) => {
+    const deadline = new AbortController();
+    const timer = setTimeout(() => deadline.abort(), switchTimeoutMs);
+    const late = new Promise(
+      (resolve) => deadline.signal.addEventListener("abort", () => resolve(void 0))
+    );
+    try {
+      let answer;
+      try {
+        answer = await Promise.race([ask(initialize2, deadline.signal), late]);
+      } catch (error) {
+        return rpcErrorOf(error);
+      }
+      if (answer && !isJSONRPCResultResponse(answer)) return answer.error;
+      if (answer) {
+        adopt(answer);
+        await http.send(
+          { jsonrpc: "2.0", method: "notifications/initialized" },
+          { requestSignal: deadline.signal }
+        ).catch(() => {
+        });
+      }
+      if (!deadline.signal.aborted) return void 0;
+      abandonedThrough = received;
+      return CONNECTION_LOST;
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  const callTool = async (call) => {
+    if (clientInitialize) {
+      const error = await handshake(clientInitialize);
+      if (error) return toClient({ jsonrpc: "2.0", id: call.id, error });
+    }
+    remote = true;
+    void forward(call);
+    if (listChanged) toClient({ jsonrpc: "2.0", method: "notifications/tools/list_changed" });
+  };
+  const handle = async (message, seq) => {
+    if (closed) return;
+    if (remote) return void forward(message);
+    if (isJSONRPCRequest(message) && message.method === "initialize") return initialize(message);
+    if (isJSONRPCRequest(message) && message.method === "tools/call") {
+      if (seq <= abandonedThrough) {
+        return toClient({ jsonrpc: "2.0", id: message.id, error: CONNECTION_LOST });
+      }
+      return callTool(message);
+    }
+    await local.send(message);
+  };
+  let inbox = Promise.resolve();
+  stdio.onmessage = (message) => {
+    const seq = ++received;
+    inbox = inbox.then(() => handle(message, seq)).catch((error) => log(error.message));
+  };
+  local.onmessage = (message) => {
+    if (isJSONRPCResultResponse(message) && message.id === clientInitialize?.id) {
+      const { capabilities } = message.result;
+      listChanged = capabilities?.tools?.listChanged === true;
+    }
+    toClient(message);
+  };
   http.onmessage = (message) => {
     if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
+      const waiting = message.id === void 0 ? void 0 : asked.get(message.id);
+      if (waiting) return waiting(message);
       if (message.id !== void 0) pending.delete(message.id);
-      if (isJSONRPCResultResponse(message) && message.id === initializeId) {
-        const { protocolVersion } = message.result;
-        if (typeof protocolVersion === "string") http.setProtocolVersion(protocolVersion);
-      }
+      if (isJSONRPCResultResponse(message) && message.id === initializeId) adopt(message);
     }
-    stdio.send(message).catch((cause) => log(cause.message));
+    toClient(message);
   };
   http.onerror = (error) => log(error.message);
   stdio.onerror = (error) => log(error.message);
@@ -176,13 +323,14 @@ async function runMcpBridge(apiUrl, io = {
     closed = true;
     process.off("SIGINT", shutdown);
     process.off("SIGTERM", shutdown);
-    await Promise.allSettled([http.close(), stdio.close()]);
+    await Promise.allSettled([http.close(), stdio.close(), server.close()]);
     stopped();
   };
   stdio.onclose = shutdown;
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
   await http.start();
+  await server.connect(localServerEnd);
   await stdio.start();
   return done;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fortrip",
-  "version": "1.0.0",
-  "license": "MIT",
+  "version": "2.0.0",
+  "license": "Apache-2.0",
   "description": "Search, price and book Fortrip hotels from the terminal or an AI agent.",
   "mcpName": "io.github.FortripEngineering/fortrip",
   "type": "module",
@@ -15,7 +15,9 @@
   },
   "files": [
     "dist",
-    "README.md"
+    "README.md",
+    "NOTICE",
+    "THIRD-PARTY-NOTICES"
   ],
   "engines": {
     "node": ">=22"
@@ -30,7 +32,7 @@
     "tsx": "^4.20.0",
     "typescript": "^5.9.0",
     "zod": "4.4.3",
-    "@fortrip/agent-contract": "1.0.0"
+    "@fortrip/agent-contract": "2.0.0"
   },
   "scripts": {
     "build": "tsup",