aura-courier-mcp 2.1.0 → 2.2.0

package/dist/adapters/redx.d.ts

@@ -0,0 +1,14 @@
+import { CourierAdapter } from "./base.js";
+import { BalanceResponse, ParcelCreateRequest, ParcelResponse, SupportedCourier, TrackingResponse } from "../types.js";
+export declare class RedxAdapter implements CourierAdapter {
+    courierName: SupportedCourier;
+    private client;
+    private enabled;
+    private pickupStoreId;
+    constructor(apiToken: string, baseUrl: string, pickupStoreId?: string);
+    isConfigured(): boolean;
+    private resolveDeliveryArea;
+    createParcel(req: ParcelCreateRequest): Promise<ParcelResponse>;
+    trackParcel(trackingCode: string): Promise<TrackingResponse>;
+    getBalance(): Promise<BalanceResponse>;
+}

package/dist/adapters/redx.js

@@ -0,0 +1,111 @@
+import axios from "axios";
+export class RedxAdapter {
+    courierName = "redx";
+    client;
+    enabled;
+    pickupStoreId;
+    constructor(apiToken, baseUrl, pickupStoreId = "") {
+        this.enabled = Boolean(apiToken);
+        this.pickupStoreId = pickupStoreId;
+        this.client = axios.create({
+            baseURL: baseUrl,
+            headers: {
+                "API-ACCESS-TOKEN": `Bearer ${apiToken}`,
+                "Content-Type": "application/json",
+            },
+            timeout: 15000,
+        });
+    }
+    isConfigured() {
+        return this.enabled;
+    }
+    // RedX's create endpoint needs a numeric delivery_area_id. If the caller did
+    // not pass one, best-effort resolve it from the address via GET /areas.
+    async resolveDeliveryArea(req) {
+        if (req.delivery_area_id) {
+            return { id: Number(req.delivery_area_id), name: req.delivery_area || "" };
+        }
+        const res = await this.client.get("/areas");
+        const areas = res.data?.areas || [];
+        const addr = (req.recipient_address || "").toLowerCase();
+        let best = null;
+        for (const a of areas) {
+            const base = String(a.name).split("(")[0].trim().toLowerCase();
+            if (base && addr.includes(base)) {
+                const bestLen = best ? String(best.name).split("(")[0].trim().length : 0;
+                if (base.length > bestLen)
+                    best = a;
+            }
+        }
+        if (!best) {
+            throw new Error("RedX: could not match a delivery area from the address. Pass 'delivery_area_id' explicitly (look it up via RedX /areas).");
+        }
+        return { id: best.id, name: best.name };
+    }
+    async createParcel(req) {
+        if (!this.enabled) {
+            throw new Error("RedX credentials (API access token) are not configured.");
+        }
+        const area = await this.resolveDeliveryArea(req);
+        const weightGrams = Math.max(1, Math.round((req.item_weight ?? 0.5) * 1000));
+        const declaredValue = String(req.value ?? req.cod_amount ?? 0);
+        const payload = {
+            customer_name: req.recipient_name,
+            customer_phone: req.recipient_phone,
+            delivery_area: area.name || req.delivery_area || "",
+            delivery_area_id: area.id,
+            customer_address: req.recipient_address,
+            merchant_invoice_id: req.invoice,
+            cash_collection_amount: String(req.cod_amount ?? 0),
+            parcel_weight: weightGrams,
+            instruction: req.note || "Aura AI automated dispatch",
+            value: declaredValue,
+        };
+        const storeId = req.pickup_store_id || this.pickupStoreId;
+        if (storeId)
+            payload.pickup_store_id = Number(storeId);
+        if (req.item_type) {
+            payload.parcel_details_json = [
+                { name: req.item_type, category: req.item_category || "general", value: Number(req.value ?? req.cod_amount ?? 0) },
+            ];
+        }
+        const response = await this.client.post("/parcel", payload);
+        const data = response.data;
+        const trackingId = data?.tracking_id;
+        if (!trackingId) {
+            throw new Error(`RedX API error: ${JSON.stringify(data?.message || data)}`);
+        }
+        return {
+            success: true,
+            courier: "redx",
+            tracking_code: trackingId,
+            consignment_id: trackingId,
+            invoice: req.invoice,
+            status: "pickup-pending",
+            cod_amount: req.cod_amount,
+            created_at: new Date().toISOString(),
+            raw_response: data,
+        };
+    }
+    async trackParcel(trackingCode) {
+        if (!this.enabled) {
+            throw new Error("RedX credentials are not configured.");
+        }
+        const response = await this.client.get(`/parcel/track/${encodeURIComponent(trackingCode)}`);
+        const data = response.data;
+        const events = data?.tracking || [];
+        const latest = events[events.length - 1];
+        return {
+            success: true,
+            courier: "redx",
+            tracking_code: trackingCode,
+            status: latest?.message_en || "unknown",
+            updated_at: latest?.time || new Date().toISOString(),
+            timeline: events.map((e) => ({ status: e.message_en || "", time: e.time || "", note: e.message_bn })),
+            raw_response: data,
+        };
+    }
+    async getBalance() {
+        throw new Error("RedX does not expose a merchant balance endpoint via its public API — check your balance in the RedX merchant panel.");
+    }
+}

package/dist/config.d.ts

@@ -14,5 +14,17 @@ export interface CourierConfig {
         baseUrl: string;
         enabled: boolean;
     };
+    redx: {
+        apiToken: string;
+        baseUrl: string;
+        pickupStoreId: string;
+        enabled: boolean;
+    };
 }
-export declare function loadConfig(): CourierConfig;
+export type EnvSource = Record<string, string | undefined>;
+/**
+ * Build a CourierConfig from a key/value source.
+ * Defaults to process.env (used by the STDIO/npx entrypoint); the HTTP
+ * entrypoint passes a per-request map built from that client's headers/query.
+ */
+export declare function loadConfig(src?: EnvSource): CourierConfig;

package/dist/config.js

@@ -1,25 +1,36 @@
 import dotenv from "dotenv";
 dotenv.config();
-export function loadConfig() {
-    const steadfastApiKey = process.env.STEADFAST_API_KEY || "";
-    const steadfastSecretKey = process.env.STEADFAST_SECRET_KEY || "";
-    const pathaoClientId = process.env.PATHAO_CLIENT_ID || "";
-    const pathaoClientSecret = process.env.PATHAO_CLIENT_SECRET || "";
+/**
+ * Build a CourierConfig from a key/value source.
+ * Defaults to process.env (used by the STDIO/npx entrypoint); the HTTP
+ * entrypoint passes a per-request map built from that client's headers/query.
+ */
+export function loadConfig(src = process.env) {
+    const steadfastApiKey = src.STEADFAST_API_KEY || "";
+    const steadfastSecretKey = src.STEADFAST_SECRET_KEY || "";
+    const pathaoClientId = src.PATHAO_CLIENT_ID || "";
+    const pathaoClientSecret = src.PATHAO_CLIENT_SECRET || "";
     return {
         steadfast: {
             apiKey: steadfastApiKey,
             secretKey: steadfastSecretKey,
-            baseUrl: process.env.STEADFAST_BASE_URL || "https://portal.packzy.com/api/v1",
+            baseUrl: src.STEADFAST_BASE_URL || "https://portal.packzy.com/api/v1",
             enabled: Boolean(steadfastApiKey && steadfastSecretKey),
         },
         pathao: {
             clientId: pathaoClientId,
             clientSecret: pathaoClientSecret,
-            username: process.env.PATHAO_USERNAME || "",
-            password: process.env.PATHAO_PASSWORD || "",
-            storeId: process.env.PATHAO_STORE_ID || "",
-            baseUrl: process.env.PATHAO_BASE_URL || "https://api-hermes.pathao.com",
+            username: src.PATHAO_USERNAME || "",
+            password: src.PATHAO_PASSWORD || "",
+            storeId: src.PATHAO_STORE_ID || "",
+            baseUrl: src.PATHAO_BASE_URL || "https://api-hermes.pathao.com",
             enabled: Boolean(pathaoClientId && pathaoClientSecret),
         },
+        redx: {
+            apiToken: src.REDX_API_TOKEN || "",
+            baseUrl: src.REDX_BASE_URL || "https://openapi.redx.com.bd/v1.0.0-beta",
+            pickupStoreId: src.REDX_PICKUP_STORE_ID || "",
+            enabled: Boolean(src.REDX_API_TOKEN),
+        },
     };
 }

package/dist/http.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/http.js

@@ -0,0 +1,126 @@
+import express from "express";
+import { randomUUID } from "node:crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { CourierRegistry } from "./registry.js";
+import { loadConfig } from "./config.js";
+import { buildMcpServer } from "./server.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const PORT = Number(process.env.PORT || 8080);
+// Marketing landing (index.html) sits at the repo root, one level above dist/.
+const LANDING = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "index.html");
+// Pull this client's courier keys from request headers or query params.
+// Captured once per session (on the initialize request) and bound to that session's server.
+function keysFromRequest(req) {
+    const h = req.headers;
+    const q = req.query;
+    const pick = (header, query) => {
+        const hv = h[header];
+        const v = (Array.isArray(hv) ? hv[0] : hv) ?? q[query];
+        return v ? String(v) : undefined;
+    };
+    return {
+        STEADFAST_API_KEY: pick("x-steadfast-api-key", "steadfast_key"),
+        STEADFAST_SECRET_KEY: pick("x-steadfast-secret-key", "steadfast_secret"),
+        STEADFAST_BASE_URL: pick("x-steadfast-base-url", "steadfast_base_url"),
+        PATHAO_CLIENT_ID: pick("x-pathao-client-id", "pathao_client_id"),
+        PATHAO_CLIENT_SECRET: pick("x-pathao-client-secret", "pathao_client_secret"),
+        PATHAO_USERNAME: pick("x-pathao-username", "pathao_username"),
+        PATHAO_PASSWORD: pick("x-pathao-password", "pathao_password"),
+        PATHAO_STORE_ID: pick("x-pathao-store-id", "pathao_store_id"),
+        PATHAO_BASE_URL: pick("x-pathao-base-url", "pathao_base_url"),
+        REDX_API_TOKEN: pick("x-redx-api-token", "redx_token"),
+        REDX_BASE_URL: pick("x-redx-base-url", "redx_base_url"),
+        REDX_PICKUP_STORE_ID: pick("x-redx-pickup-store-id", "redx_pickup_store_id"),
+    };
+}
+const app = express();
+app.use(express.json({ limit: "1mb" }));
+// Allow browser-based and cross-origin MCP clients.
+app.use((req, res, next) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Headers", "Content-Type, Accept, Authorization, mcp-session-id, mcp-protocol-version, x-steadfast-api-key, x-steadfast-secret-key, x-steadfast-base-url, x-pathao-client-id, x-pathao-client-secret, x-pathao-username, x-pathao-password, x-pathao-store-id, x-pathao-base-url, x-redx-api-token, x-redx-base-url, x-redx-pickup-store-id");
+    res.header("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.header("Access-Control-Expose-Headers", "mcp-session-id");
+    if (req.method === "OPTIONS") {
+        res.sendStatus(204);
+        return;
+    }
+    next();
+});
+// Active sessions: sessionId -> transport (each bound to one client's keys).
+const transports = {};
+app.post("/mcp", async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    let transport;
+    if (sessionId && transports[sessionId]) {
+        // Existing session — reuse its server (already holds this client's keys).
+        transport = transports[sessionId];
+    }
+    else if (!sessionId && isInitializeRequest(req.body)) {
+        // New session — capture THIS client's courier keys now.
+        const registry = new CourierRegistry(loadConfig(keysFromRequest(req)));
+        const server = buildMcpServer(registry);
+        transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+            onsessioninitialized: (sid) => {
+                transports[sid] = transport;
+            },
+        });
+        transport.onclose = () => {
+            if (transport.sessionId)
+                delete transports[transport.sessionId];
+        };
+        await server.connect(transport);
+    }
+    else {
+        res.status(400).json({
+            jsonrpc: "2.0",
+            error: { code: -32000, message: "Bad Request: missing or invalid session. Send an initialize request first." },
+            id: null,
+        });
+        return;
+    }
+    try {
+        await transport.handleRequest(req, res, req.body);
+    }
+    catch (err) {
+        if (!res.headersSent) {
+            res.status(500).json({
+                jsonrpc: "2.0",
+                error: { code: -32603, message: `Internal error: ${err?.message || String(err)}` },
+                id: null,
+            });
+        }
+    }
+});
+// GET (server->client SSE stream) and DELETE (end session) for an existing session.
+async function handleSessionRequest(req, res) {
+    const sessionId = req.headers["mcp-session-id"];
+    if (!sessionId || !transports[sessionId]) {
+        res.status(400).send("Invalid or missing session ID");
+        return;
+    }
+    await transports[sessionId].handleRequest(req, res);
+}
+app.get("/mcp", handleSessionRequest);
+app.delete("/mcp", handleSessionRequest);
+app.get("/health", (_req, res) => res.json({ ok: true, service: "aura-courier-mcp", version: "2.1.0", sessions: Object.keys(transports).length }));
+app.get("/", (_req, res) => {
+    // Serve the marketing landing page; fall back to a minimal page if it's missing.
+    res.sendFile(LANDING, (err) => {
+        if (err && !res.headersSent) {
+            res
+                .type("html")
+                .send(`<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Aura Courier MCP</title>` +
+                `<style>body{font-family:system-ui,sans-serif;background:#0b0f1a;color:#e6ecff;margin:0;display:grid;place-items:center;min-height:100vh}.b{max-width:640px;padding:40px;text-align:center}h1{font-size:28px;margin:0 0 10px}code{background:#141c30;padding:2px 8px;border-radius:6px;color:#7dd3fc;font-size:13px}a{color:#7dd3fc}p{line-height:1.6;color:#9fb0d0}</style></head>` +
+                `<body><div class="b"><h1>🚚 Aura Courier MCP</h1><p>Live remote MCP endpoint for Bangladesh couriers — Steadfast &amp; Pathao.</p>` +
+                `<p>Connect your AI to <code>POST /mcp</code> and pass your courier keys as headers (<code>x-steadfast-api-key</code>, <code>x-steadfast-secret-key</code>) or query params (<code>?steadfast_key=…&amp;steadfast_secret=…</code>).</p>` +
+                `<p>By <a href="https://auraajenticai.cloud">Aura Ajentic AI</a> · <a href="https://courier.auraajenticai.cloud">docs &amp; setup</a></p></div></body></html>`);
+        }
+    });
+});
+app.listen(PORT, () => {
+    console.log(`Aura Courier MCP (HTTP) listening on :${PORT} — POST /mcp`);
+});

package/dist/index.js

@@ -1,159 +1,14 @@
 #!/usr/bin/env node
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { CourierRegistry } from "./registry.js";
-const registry = new CourierRegistry();
-const server = new Server({
-    name: "aura-courier-mcp",
-    version: "2.0.0",
-}, {
-    capabilities: {
-        tools: {},
-    },
-});
-// Define Tools exactly matching Glama.ai & Extended Specs
-const TOOLS = [
-    {
-        name: "list_couriers",
-        description: "Show supported Bangladeshi couriers and check which credentials are active.",
-        inputSchema: {
-            type: "object",
-            properties: {},
-            required: [],
-        },
-    },
-    {
-        name: "create_parcel",
-        description: "Book a new parcel delivery across Bangladesh (Steadfast or Pathao) with normalized response.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                courier: {
-                    type: "string",
-                    enum: ["steadfast", "pathao", "auto"],
-                    description: "Target courier or 'auto' for AI smart routing (default: auto)",
-                },
-                invoice: { type: "string", description: "Unique order invoice number (e.g. INV-1002)" },
-                recipient_name: { type: "string", description: "Customer full name" },
-                recipient_phone: { type: "string", description: "11-digit Bangladeshi mobile number (e.g. 017XXXXXXXX)" },
-                recipient_address: { type: "string", description: "Delivery address (Thana, District, Street)" },
-                cod_amount: { type: "number", description: "Cash on delivery amount in BDT (0 if prepaid)" },
-                note: { type: "string", description: "Special instructions for delivery rider" },
-                item_weight: { type: "number", description: "Parcel weight in KG (default: 0.5)" },
-            },
-            required: ["invoice", "recipient_name", "recipient_phone", "recipient_address", "cod_amount"],
-        },
-    },
-    {
-        name: "track_parcel",
-        description: "Track shipment delivery status across Steadfast or Pathao using Tracking Code / Consignment ID.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                tracking_code: { type: "string", description: "Consignment ID or tracking code" },
-                courier: {
-                    type: "string",
-                    enum: ["steadfast", "pathao"],
-                    description: "Optional courier name if known",
-                },
-            },
-            required: ["tracking_code"],
-        },
-    },
-    {
-        name: "get_balance",
-        description: "Retrieve current merchant account balance and payout details from a courier.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                courier: {
-                    type: "string",
-                    enum: ["steadfast", "pathao"],
-                    description: "Courier provider to check balance for",
-                },
-            },
-            required: ["courier"],
-        },
-    },
-    {
-        name: "check_fraud_risk",
-        description: "Analyze Bangladeshi customer phone number delivery history and return/fraud risk score before dispatching.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                phone: { type: "string", description: "11-digit Bangladeshi phone number to evaluate" },
-            },
-            required: ["phone"],
-        },
-    },
-];
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return { tools: TOOLS };
-});
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    try {
-        switch (name) {
-            case "list_couriers": {
-                const couriers = registry.listCouriers();
-                return {
-                    content: [{ type: "text", text: JSON.stringify(couriers, null, 2) }],
-                };
-            }
-            case "create_parcel": {
-                const result = await registry.createParcel({
-                    courier: args?.courier,
-                    invoice: String(args?.invoice),
-                    recipient_name: String(args?.recipient_name),
-                    recipient_phone: String(args?.recipient_phone),
-                    recipient_address: String(args?.recipient_address),
-                    cod_amount: Number(args?.cod_amount || 0),
-                    note: args?.note ? String(args?.note) : undefined,
-                    item_weight: args?.item_weight ? Number(args?.item_weight) : 0.5,
-                });
-                return {
-                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case "track_parcel": {
-                const result = await registry.trackParcel(String(args?.tracking_code), args?.courier);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case "get_balance": {
-                const result = await registry.getBalance(String(args?.courier));
-                return {
-                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case "check_fraud_risk": {
-                const result = registry.checkFraudRisk(String(args?.phone));
-                return {
-                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            default:
-                throw new Error(`Unknown tool: ${name}`);
-        }
-    }
-    catch (error) {
-        return {
-            isError: true,
-            content: [
-                {
-                    type: "text",
-                    text: `Aura Courier MCP Error: ${error.message || String(error)}`,
-                },
-            ],
-        };
-    }
-});
+import { buildMcpServer } from "./server.js";
+// STDIO / npx entrypoint (Claude Desktop, Cursor, Antigravity).
+// Credentials come from environment variables (STEADFAST_API_KEY, PATHAO_*).
 async function run() {
+    const server = buildMcpServer(new CourierRegistry());
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("Aura Courier MCP v2.0 running on STDIO");
+    console.error("Aura Courier MCP v2.1 running on STDIO");
 }
 run().catch((error) => {
     console.error("Fatal error running Aura Courier MCP:", error);

package/dist/registry.d.ts

@@ -1,8 +1,9 @@
 import { CourierAdapter } from "./adapters/base.js";
+import { CourierConfig } from "./config.js";
 import { BalanceResponse, FraudRiskScoreResponse, ParcelCreateRequest, ParcelResponse, SupportedCourier, TrackingResponse } from "./types.js";
 export declare class CourierRegistry {
     private adapters;
-    constructor();
+    constructor(config?: CourierConfig);
     listCouriers(): {
         courier: SupportedCourier;
         is_configured: boolean;

package/dist/registry.js

@@ -1,15 +1,17 @@
 import { SteadfastAdapter } from "./adapters/steadfast.js";
 import { PathaoAdapter } from "./adapters/pathao.js";
 import { FraudRiskEngine } from "./adapters/fraud_engine.js";
+import { RedxAdapter } from "./adapters/redx.js";
 import { loadConfig } from "./config.js";
 export class CourierRegistry {
     adapters = new Map();
-    constructor() {
-        const config = loadConfig();
+    constructor(config = loadConfig()) {
         const steadfast = new SteadfastAdapter(config.steadfast.apiKey, config.steadfast.secretKey, config.steadfast.baseUrl);
         this.adapters.set("steadfast", steadfast);
         const pathao = new PathaoAdapter(config.pathao.clientId, config.pathao.clientSecret, config.pathao.username, config.pathao.password, config.pathao.storeId, config.pathao.baseUrl);
         this.adapters.set("pathao", pathao);
+        const redx = new RedxAdapter(config.redx.apiToken, config.redx.baseUrl, config.redx.pickupStoreId);
+        this.adapters.set("redx", redx);
     }
     listCouriers() {
         return Array.from(this.adapters.entries()).map(([name, adapter]) => ({

package/dist/server.d.ts

@@ -0,0 +1,10 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+import { CourierRegistry } from "./registry.js";
+export declare const TOOLS: Tool[];
+/**
+ * Build a fully-wired MCP Server bound to a given CourierRegistry.
+ * The registry carries the credentials — for STDIO it comes from env,
+ * for HTTP it is built per-request from that client's keys.
+ */
+export declare function buildMcpServer(registry: CourierRegistry): Server;

package/dist/server.js

@@ -0,0 +1,118 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+// Tool definitions — shared by the STDIO (npx) and HTTP (web-URL) entrypoints.
+export const TOOLS = [
+    {
+        name: "list_couriers",
+        description: "Show supported Bangladeshi couriers and check which credentials are active.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "create_parcel",
+        description: "Book a new parcel delivery across Bangladesh (Steadfast, Pathao or RedX) with normalized response.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                courier: { type: "string", enum: ["steadfast", "pathao", "redx", "auto"], description: "Target courier or 'auto' for AI smart routing (default: auto)" },
+                invoice: { type: "string", description: "Unique order invoice number (e.g. INV-1002)" },
+                recipient_name: { type: "string", description: "Customer full name" },
+                recipient_phone: { type: "string", description: "11-digit Bangladeshi mobile number (e.g. 017XXXXXXXX)" },
+                recipient_address: { type: "string", description: "Delivery address (Thana, District, Street)" },
+                cod_amount: { type: "number", description: "Cash on delivery amount in BDT (0 if prepaid)" },
+                note: { type: "string", description: "Special instructions for delivery rider" },
+                item_weight: { type: "number", description: "Parcel weight in KG (default: 0.5)" },
+                item_type: { type: "string", description: "What's inside the parcel (used by RedX)" },
+                value: { type: "number", description: "Declared parcel value in BDT (used by RedX; defaults to the COD amount)" },
+                delivery_area_id: { type: "number", description: "RedX only: numeric delivery-area id (auto-resolved from the address if omitted)" },
+                pickup_store_id: { type: "number", description: "RedX only: your pickup store id (optional)" },
+            },
+            required: ["invoice", "recipient_name", "recipient_phone", "recipient_address", "cod_amount"],
+        },
+    },
+    {
+        name: "track_parcel",
+        description: "Track shipment delivery status across Steadfast or Pathao using Tracking Code / Consignment ID.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tracking_code: { type: "string", description: "Consignment ID or tracking code" },
+                courier: { type: "string", enum: ["steadfast", "pathao", "redx"], description: "Optional courier name if known" },
+            },
+            required: ["tracking_code"],
+        },
+    },
+    {
+        name: "get_balance",
+        description: "Retrieve current merchant account balance and payout details from a courier.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                courier: { type: "string", enum: ["steadfast", "pathao"], description: "Courier provider to check balance for" },
+            },
+            required: ["courier"],
+        },
+    },
+    {
+        name: "check_fraud_risk",
+        description: "Analyze Bangladeshi customer phone number delivery history and return/fraud risk score before dispatching.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                phone: { type: "string", description: "11-digit Bangladeshi phone number to evaluate" },
+            },
+            required: ["phone"],
+        },
+    },
+];
+/**
+ * Build a fully-wired MCP Server bound to a given CourierRegistry.
+ * The registry carries the credentials — for STDIO it comes from env,
+ * for HTTP it is built per-request from that client's keys.
+ */
+export function buildMcpServer(registry) {
+    const server = new Server({ name: "aura-courier-mcp", version: "2.1.0" }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            switch (name) {
+                case "list_couriers":
+                    return { content: [{ type: "text", text: JSON.stringify(registry.listCouriers(), null, 2) }] };
+                case "create_parcel": {
+                    const result = await registry.createParcel({
+                        courier: args?.courier,
+                        invoice: String(args?.invoice),
+                        recipient_name: String(args?.recipient_name),
+                        recipient_phone: String(args?.recipient_phone),
+                        recipient_address: String(args?.recipient_address),
+                        cod_amount: Number(args?.cod_amount || 0),
+                        note: args?.note ? String(args?.note) : undefined,
+                        item_weight: args?.item_weight ? Number(args?.item_weight) : 0.5,
+                    });
+                    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+                }
+                case "track_parcel": {
+                    const result = await registry.trackParcel(String(args?.tracking_code), args?.courier);
+                    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+                }
+                case "get_balance": {
+                    const result = await registry.getBalance(String(args?.courier));
+                    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+                }
+                case "check_fraud_risk": {
+                    const result = registry.checkFraudRisk(String(args?.phone));
+                    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+                }
+                default:
+                    throw new Error(`Unknown tool: ${name}`);
+            }
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Aura Courier MCP Error: ${error?.message || String(error)}` }],
+            };
+        }
+    });
+    return server;
+}

package/dist/types.d.ts

@@ -9,6 +9,11 @@ export interface ParcelCreateRequest {
     note?: string;
     item_type?: string;
     item_weight?: number;
+    item_category?: string;
+    value?: number | string;
+    delivery_area?: string;
+    delivery_area_id?: number | string;
+    pickup_store_id?: number | string;
 }
 export interface ParcelResponse {
     success: boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aura-courier-mcp",
-  "version": "2.1.0",
-  "description": "Universal Bangladesh courier MCP server — Steadfast & Pathao with a built-in fraud-risk engine — for Claude, Antigravity, Cursor & n8n AI agents",
+  "version": "2.2.0",
+  "description": "Universal Bangladesh courier MCP server — Steadfast, Pathao & RedX with a built-in fraud-risk engine — for Claude, Antigravity, Cursor & n8n AI agents. Runs as a local npx (STDIO) server or a remote HTTP endpoint.",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
@@ -18,6 +18,7 @@
     "build": "tsc",
     "prepublishOnly": "npm run build",
     "start": "node dist/index.js",
+    "start:http": "node dist/http.js",
     "dev": "tsx src/index.ts"
   },
   "keywords": [
@@ -26,6 +27,7 @@
     "courier",
     "steadfast",
     "pathao",
+    "redx",
     "bangladesh",
     "antigravity",
     "claude",
@@ -39,12 +41,14 @@
     "url": "git+https://github.com/auraajenticai/aura-courier-mcp.git"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.6.0",
+    "@modelcontextprotocol/sdk": "^1.12.0",
     "axios": "^1.7.9",
     "dotenv": "^16.4.7",
+    "express": "^4.21.2",
     "zod": "^3.24.2"
   },
   "devDependencies": {
+    "@types/express": "^4.17.21",
     "@types/node": "^22.13.0",
     "tsx": "^4.19.2",
     "typescript": "^5.7.3"