fortrip 0.3.0 → 1.0.0

package/dist/mcp-bridge-VEJ33LYD.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+import {
+  API,
+  CliError,
+  EXIT,
+  refreshSession,
+  requireToken
+} from "./chunk-OBK2KTLC.js";
+
+// src/mcp-bridge.ts
+import {
+  isJSONRPCErrorResponse,
+  isJSONRPCRequest,
+  isJSONRPCResultResponse,
+  SdkHttpError,
+  StreamableHTTPClientTransport
+} from "@modelcontextprotocol/client";
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+var SIGN_IN_REQUIRED = -32001;
+var INTERNAL_ERROR = -32603;
+var LOGIN_COMMAND = "npx -y fortrip login";
+var SignInRequired = class extends Error {
+  constructor(message, data = {}) {
+    super(message);
+    this.data = data;
+  }
+  data;
+};
+var signInAdvice = (link = "") => `Run \`${LOGIN_COMMAND}\` in a terminal${link}, then try again.`;
+async function signedIn(run) {
+  try {
+    return await run();
+  } catch (error) {
+    if (error instanceof CliError && error.exitCode === EXIT.unauthenticated) {
+      if (error.details.tokenSource === "FORTRIP_TOKEN") throw new SignInRequired(error.message);
+      const { loginUrl, userCode, expiresInSeconds } = error.details;
+      throw new SignInRequired(
+        `Not signed in to Fortrip, or the saved sign-in no longer works. ${signInAdvice(
+          loginUrl ? `, or open ${loginUrl} and approve` : ""
+        )}`,
+        { loginUrl, userCode, expiresInSeconds }
+      );
+    }
+    throw error;
+  }
+}
+function authorizedFetch(apiUrl) {
+  const attempt = async (url, init) => {
+    try {
+      return await fetch(url, init);
+    } catch (error) {
+      if (error?.name === "AbortError") throw error;
+      const cause = error?.cause ?? error;
+      throw new Error(`Could not reach ${apiUrl}: ${cause?.message ?? String(error)}`);
+    }
+  };
+  let turn = Promise.resolve();
+  return async (url, init) => {
+    const withToken = (token2) => {
+      const headers = new Headers(init?.headers);
+      headers.set("authorization", `Bearer ${token2}`);
+      return attempt(url, { ...init, headers });
+    };
+    const started = turn.then(async () => {
+      const { token: token2, source: source2 } = await signedIn(() => requireToken(apiUrl));
+      return { token: token2, source: source2, response: withToken(token2) };
+    });
+    turn = started.catch(() => {
+    });
+    const { token, source, response } = await started;
+    const first = await response;
+    if (first.status !== 401) return first;
+    await first.body?.cancel().catch(() => {
+    });
+    if (source === "env") {
+      throw new SignInRequired(
+        `Fortrip didn't accept FORTRIP_TOKEN. Replace it, or unset it and run \`${LOGIN_COMMAND}\`, then try again.`
+      );
+    }
+    const second = await withToken(await signedIn(() => refreshSession(apiUrl, token)));
+    if (second.status !== 401) return second;
+    await second.body?.cancel().catch(() => {
+    });
+    throw new SignInRequired(`Fortrip didn't accept the refreshed sign-in. ${signInAdvice()}`);
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function rpcErrorOf(error) {
+  if (error instanceof SignInRequired) {
+    return { code: SIGN_IN_REQUIRED, message: error.message, data: error.data };
+  }
+  if (error instanceof SdkHttpError) {
+    const { status } = error;
+    const text = typeof error.data.text === "string" ? error.data.text : "";
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+    }
+    if (isRecord(body) && isRecord(body.error)) {
+      const { code, message } = body.error;
+      if (typeof code === "number" && typeof message === "string") return body.error;
+    }
+    const said = isRecord(body) ? body.error ?? body.message : text.slice(0, 200);
+    return {
+      code: INTERNAL_ERROR,
+      message: `Fortrip answered HTTP ${status}${typeof said === "string" && said ? `: ${said}` : ""}`,
+      data: { status, ...status >= 500 || status === 429 ? { retryable: true } : {} }
+    };
+  }
+  return {
+    code: INTERNAL_ERROR,
+    message: error instanceof Error ? error.message : String(error),
+    ...error instanceof CliError && error.details.retryable ? { data: { retryable: true } } : {}
+  };
+}
+var CONNECTION_LOST = {
+  code: INTERNAL_ERROR,
+  message: "The connection to Fortrip ended before it answered.",
+  data: { retryable: true }
+};
+async function runMcpBridge(apiUrl, io = {
+  stdin: process.stdin,
+  stdout: process.stdout
+}) {
+  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)
+  });
+  let closed = false;
+  const pending = /* @__PURE__ */ new Set();
+  let initializeId;
+  const log = (message) => {
+    if (!closed) stderr.write(`fortrip mcp: ${message}
+`);
+  };
+  const fail = (id, error) => {
+    if (closed || !pending.delete(id)) return;
+    stdio.send({ jsonrpc: "2.0", id, error }).catch((cause) => log(cause.message));
+  };
+  stdio.onmessage = async (message) => {
+    if (!isJSONRPCRequest(message)) {
+      await http.send(message).catch(() => {
+      });
+      return;
+    }
+    pending.add(message.id);
+    if (message.method === "initialize") initializeId = message.id;
+    try {
+      await http.send(message, { onRequestStreamEnd: () => fail(message.id, CONNECTION_LOST) });
+    } catch (error) {
+      fail(message.id, rpcErrorOf(error));
+    }
+  };
+  http.onmessage = (message) => {
+    if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(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);
+      }
+    }
+    stdio.send(message).catch((cause) => log(cause.message));
+  };
+  http.onerror = (error) => log(error.message);
+  stdio.onerror = (error) => log(error.message);
+  let stopped;
+  const done = new Promise((resolve) => {
+    stopped = resolve;
+  });
+  const shutdown = async () => {
+    if (closed) return;
+    closed = true;
+    process.off("SIGINT", shutdown);
+    process.off("SIGTERM", shutdown);
+    await Promise.allSettled([http.close(), stdio.close()]);
+    stopped();
+  };
+  stdio.onclose = shutdown;
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await http.start();
+  await stdio.start();
+  return done;
+}
+export {
+  runMcpBridge
+};

package/package.json

@@ -1,37 +1,41 @@
 {
   "name": "fortrip",
-  "version": "0.3.0",
+  "version": "1.0.0",
+  "license": "MIT",
   "description": "Search, price and book Fortrip hotels from the terminal or an AI agent.",
+  "mcpName": "io.github.FortripEngineering/fortrip",
   "type": "module",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/FortripEngineering/fortrip-cli.git"
+    "url": "git+https://github.com/FortripEngineering/fortrip.git",
+    "directory": "packages/cli"
   },
   "bin": {
     "fortrip": "dist/cli.js"
   },
   "files": [
     "dist",
-    "skills",
-    "guides",
-    "AGENT_GUIDE.md",
     "README.md"
   ],
   "engines": {
     "node": ">=22"
   },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsx src/cli.ts",
-    "typecheck": "tsc --noEmit",
-    "test": "node --import tsx --test test/*.test.ts",
-    "prepublishOnly": "pnpm typecheck && pnpm test && pnpm build"
+  "dependencies": {
+    "@modelcontextprotocol/client": "2.3.1",
+    "@modelcontextprotocol/server": "2.3.1"
   },
   "devDependencies": {
     "@types/node": "^22.15.0",
     "tsup": "^8.5.1",
     "tsx": "^4.20.0",
-    "typescript": "^5.9.0"
+    "typescript": "^5.9.0",
+    "zod": "4.4.3",
+    "@fortrip/agent-contract": "1.0.0"
   },
-  "packageManager": "pnpm@11.21.0"
-}
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/cli.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "node --import tsx --test test/*.test.ts"
+  }
+}

package/AGENT_GUIDE.md

@@ -1,133 +0,0 @@
-# Fortrip hotels
-
-Fortrip sells hotel rooms at supplier net prices. The
-`fortrip` CLI (npm package `fortrip`) calls the Fortrip API as the
-signed-in user and prints JSON.
-
-## When to use
-
-- The user wants hotels in a city, near a point, or by name, for given dates.
-- The user wants live rooms, meal plans, cancellation terms or prices for
-  specific hotels.
-- The user has picked a rate and wants to book it (you return a payment link;
-  the user pays in their browser).
-
-Not for flights, activities, or changing/cancelling an existing booking.
-
-For flexible dates, a budget, split stays, several destinations or "find me
-the best", also run `npx -y fortrip@latest skill planning` before searching.
-
-## Setup
-
-Run every command as `npx -y fortrip@latest <command>`, the same version that
-printed this guide. The examples below shorten that to `fortrip`.
-
-When the user first asks about hotels, run `fortrip whoami` before asking
-follow-up questions, so a login can happen while they answer.
-
-If a command exits with code **3** and stderr has `loginUrl`, show it to the
-user as a link together with `userCode`, e.g. "Sign in to Fortrip: <loginUrl>
-(code BCDF-GHJK) and tell me when you're done." When they confirm, rerun the
-same command; it finishes the login itself. Don't run `fortrip login` — it
-waits for up to 10 minutes. If the rerun gives a new `loginUrl`, the old one
-expired or was denied; show the new one.
-
-If exit 3 has no `loginUrl`, the saved token was revoked: run `fortrip logout`,
-then rerun the command to get a link.
-
-In CI, the user can set `FORTRIP_TOKEN` instead. Never ask the user to paste a
-token into the chat.
-
-## Exit codes
-
-| Code | Meaning | What to do |
-|---|---|---|
-| 0 | Success; JSON on stdout | Continue |
-| 1 | Other error (supplier error, rate no longer bookable, network) | Read `error` on stderr; re-run `rates` if a rate went stale |
-| 2 | Invalid arguments | Fix the flags; stderr `issues` lists the bad fields |
-| 3 | Not logged in | Show `loginUrl` to the user, then rerun (above) |
-| 4 | Rate limited | Wait `retryAfterSeconds`, then retry once |
-
-## Recommended order
-
-1. **Search** — find candidates and indicative prices:
-
-   ```bash
-   fortrip search --query "Bangkok" --check-in 2026-11-10 --check-out 2026-11-12 \
-     --star-min 4 --sort price-asc --page-size 10
-   ```
-
-   Use `--near lat,lng,radiusKm` for "near X", `--city-code` when known.
-   Pass `--currency` (`CNY`, the default, or `USD`) to suit the user, inferred
-   from their language or location, on both `search` and `rates`;
-   `--price-min` / `--price-max` are in that currency.
-   `--facility` names must match the catalogue exactly (e.g. `Swimming pool`,
-   `Parking`), otherwise nothing matches. Prices here (`price.nightlyFrom`,
-   `totalFrom`) are **indicative floors**, not quotes — say so.
-
-2. **Hotel detail** (optional) — description, policies, facilities, photos:
-
-   ```bash
-   fortrip hotel 266000 [--with-rooms]
-   ```
-
-3. **Rates** — live rooms and prices for up to 15 hotels:
-
-   ```bash
-   fortrip rates --hotel 266000 --hotel 266001 --check-in 2026-11-10 \
-     --check-out 2026-11-12 --rooms 1 --adults 2 [--child-age 6] \
-     [--nationality CN] [--board BB] [--free-cancellation] [--currency USD]
-   ```
-
-   This call takes about 15 seconds. Prices are in the response's `currency`,
-   converted at Stripe's exchange rate (refreshed hourly), or a fixed fallback
-   rate when Stripe is unavailable; `fx` says which, and is `null` when
-   nothing needed converting. Present each option with meal plan (`boardCode`: RO room only,
-   BB breakfast, HB half board, FB full board, AI all inclusive),
-   `freeCancelUntil` / `refundable`, `isInstantConfirm`, and any `fees`
-   (taxes paid at the hotel, in their own currency).
-
-4. **Book** — only after the user picks one rate and gives guest details:
-
-   ```bash
-   fortrip book --hotel 266000 --room-id 9191658 --rate-plan "<ratePlanCode>" \
-     --check-in 2026-11-10 --check-out 2026-11-12 --rooms 1 --adults 2 \
-     --guest "John Smith" --contact-name "John Smith" \
-     --contact-phone "+8613800000000" [--contact-email john@example.com]
-   ```
-
-   `--hotel`, `--room-id`, `--rate-plan`, dates, `--rooms`, `--adults` and
-   `--child-age` must be exactly the values used in `rates`. Guest names must
-   be in Latin letters as on the passport ("First Last"; last word is the last
-   name; `"First Last:2"` puts the guest in room 2). Each room needs at least
-   one guest. `--special-requests` must be in English and isn't guaranteed.
-
-## Before giving the payment link
-
-`book` returns `paymentUrl`, `amount`, `currency`, `terms`, `statusUrl` and
-`orderUrl`. Before you hand over `paymentUrl`:
-
-1. **Show the `terms`** and get the user's confirmation: meal plan
-   (`boardCode`, `boardCount`), cancellation (`refundable`, `freeCancelUntil`,
-   the `cancellation` ladder), confirmation (`isInstantConfirm`,
-   `confirmByMins`) and `payAtHotelFees`.
-2. **Explain the amount.** `rates` showed a converted figure, but the charge
-   is `amount` in `currency` (usually USD), and the Stripe page may display
-   the user's local currency at Stripe's rate. The `rates` figure used a
-   Stripe rate too, so it is usually close, but the amount on the payment page
-   is what will be charged; the `rates` figure was a reference.
-3. The link is for **this user only**: whoever has it can pay. Don't post it
-   in shared channels, logs or tickets. It expires after about 3 hours 45
-   minutes; call `book` again with the same details for a fresh one.
-
-After paying, the user lands on `statusUrl`, which shows confirmation progress
-without signing in. `orderUrl` is the signed-in order page.
-
-## Errors from `book`
-
-- `409` with `agentOrderId`: this exact stay is already paid or completed —
-  show `orderUrl`, don't book again.
-- `409` with `changes`: price or terms changed — re-run `rates` and confirm
-  again with the user.
-- `422`: the booking was refused (guest names, too many attempts, bookings
-  paused, or a preview deployment). Read `error`.

package/guides/planning.md

@@ -1,54 +0,0 @@
-# Planning a hotel stay
-
-Read this when the request is more than one hotel for fixed dates: flexible
-dates, a budget, split stays, several destinations, or "find me the best".
-Commands, login and the booking checklist are in `fortrip skill`; this covers
-what to ask, how to compare and how to present. As there, `fortrip` is short
-for `npx -y fortrip@latest`.
-
-## What to collect
-
-Keep track of: dates (or the flexible window), nights, destination(s), guests
-and rooms, room constraints (beds, connecting rooms, accessibility), budget,
-and what the user said matters most (cheapest, most flexible, closest to X).
-
-Ask only for what changes which hotels qualify or how they rank. If children
-come along, ask each child's age; `rates` and `book` need it. Don't ask for
-trip type or style: infer it from the conversation or leave it general.
-
-## Evidence
-
-- A `search` price is a floor. Never call a search result available or
-  bookable.
-- Use `hotel` only when a stated preference needs evidence (a pool, a
-  policy, room size).
-- A hotel is available only once `rates` returned a live option for it.
-- Anything the CLI didn't return, such as reviews, style, price trends or
-  exchange rates, is unknown. Say so instead of filling it in.
-
-## Ranking
-
-1. Drop options that break a hard constraint (dates, guests, budget cap,
-   required facility).
-2. Keep only options with a live rate.
-3. Order by the user's stated main goal. Goals they didn't state don't count.
-4. Use other preferences only to break ties.
-
-Use the cheapest comparable live room as the baseline unless the user fixed
-the room type. Show at most three plans, each with its price difference from
-the baseline and what it trades off (meal plan, cancellation, location,
-instant confirmation). Keep hotel names as returned and dates in the user's
-notation.
-
-For a split stay or several destinations, price each leg with its own
-`rates` call and add up the legs. Each leg is a separate `book` call and a
-separate payment link.
-
-## Stop and say so
-
-- `rates` covers up to 15 hotels per call and takes about 15 seconds. If the
-  request needs more hotels or date combinations than a few calls can cover,
-  narrow it with the user, or present the result as a comparison of the
-  hotels you priced, not the best overall.
-- Urgency is not consent: create a payment link only after the user picked a
-  rate and confirmed its terms.

package/skills/fortrip-hotels/SKILL.md

@@ -1,20 +0,0 @@
----
-name: fortrip-hotels
-description: Search hotels, compare live room rates and create a hotel booking with a payment link through Fortrip. Use when the user wants to find, compare, price or book a hotel stay, including flexible dates, budgets, split stays or several destinations, or asks for a hotel payment link.
----
-
-# Fortrip hotels
-
-Before anything else, run:
-
-```bash
-npx -y fortrip@latest skill
-```
-
-It prints the current instructions for the Fortrip CLI: commands, call order,
-login, and what to show the user before giving a payment link. Follow them.
-They ship with each CLI release, so this file stays short and doesn't go out
-of date.
-
-Needs Node.js 22 or newer. If the command fails, tell the user why instead of
-guessing the CLI's flags.