Code

    Xyppy Print This Index source

    Imported TypeScript file from server/index.ts.

    Xyppy Print ThisUpdated Aug 16, 2026TS

    Source file

    server/index.ts

    TypeScript205 lines
    1. import { registerAppResource, registerAppTool, RESOURCE_MIME_TYPE } from "@modelcontextprotocol/ext-apps/server";
    2. import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
    3. import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
    4. import cors from "cors";
    5. import express from "express";
    6. import fs from "node:fs";
    7. import path from "node:path";
    8. import { fileURLToPath } from "node:url";
    9. import { z } from "zod";
    10. import { readCheckoutRuntimeStatus } from "./commerce/runtime";
    11. import { DEFAULT_CONFIGURATION } from "../shared/catalog";
    12. import { buildCheckoutPreview } from "../shared/checkout";
    13. import type { PrintConfiguration } from "../shared/types";
    15. const SERVER_VERSION = "0.1.0";
    16. const TEMPLATE_URI = "ui://widget/xyppy-print-configurator-v1.html";
    17. const __dirname = path.dirname(fileURLToPath(import.meta.url));
    18. const DIST_HTML = path.resolve(__dirname, "..", "dist", "index.html");
    20. const fileSchema = z.object({
    21. download_url: z.string(),
    22. file_id: z.string(),
    23. mime_type: z.string().optional(),
    24. file_name: z.string().optional(),
    25. });
    27. const configurationInputSchema = {
    28. image: fileSchema.optional().describe("The image the user wants to print, when ChatGPT can resolve one from the conversation."),
    29. size: z.enum(["8x10", "11x14", "16x20", "18x24", "24x36"]).optional(),
    30. paper: z.enum(["archival-matte", "fine-art-matte"]).optional(),
    31. frame: z.enum(["unframed", "black", "white", "natural"]).optional(),
    32. mat: z.enum(["none", "white-2"]).optional(),
    33. layout: z.enum(["fill", "fit", "white-border"]).optional(),
    34. quantity: z.number().int().min(1).max(5).optional(),
    35. };
    37. function resolveConfiguration(input: Partial<PrintConfiguration>): PrintConfiguration {
    38. const configuration = {
    39. ...DEFAULT_CONFIGURATION,
    40. ...(input.size ? { size: input.size } : {}),
    41. ...(input.paper ? { paper: input.paper } : {}),
    42. ...(input.frame ? { frame: input.frame } : {}),
    43. ...(input.mat ? { mat: input.mat } : {}),
    44. ...(input.layout ? { layout: input.layout } : {}),
    45. ...(input.quantity ? { quantity: input.quantity } : {}),
    46. };
    48. if (configuration.frame === "unframed") configuration.mat = "none";
    49. return configuration;
    50. }
    52. function readWidgetHtml(): string {
    53. if (!fs.existsSync(DIST_HTML)) {
    54. throw new Error(`Widget bundle not found at ${DIST_HTML}. Run \"pnpm build\" first.`);
    55. }
    56. return fs.readFileSync(DIST_HTML, "utf8");
    57. }
    59. export function createServer(): McpServer {
    60. const server = new McpServer(
    61. { name: "xyppy-print-this", version: SERVER_VERSION },
    62. { instructions: "Help the user configure a prototype physical print. Never claim that a checkout, order, payment, print-ready file, or fulfillment action occurred." },
    63. );
    65. registerAppTool(
    66. server,
    67. "configure_print",
    68. {
    69. title: "Configure a Xyppy print",
    70. description: "Use this when the user wants to print an image, check suitable print sizes, or configure paper, frame, mat, crop, and quantity. This prototype estimates pricing and does not place an order.",
    71. inputSchema: configurationInputSchema,
    72. annotations: {
    73. readOnlyHint: true,
    74. destructiveHint: false,
    75. openWorldHint: false,
    76. idempotentHint: true,
    77. },
    78. _meta: {
    79. ui: { resourceUri: TEMPLATE_URI },
    80. "openai/outputTemplate": TEMPLATE_URI,
    81. "openai/fileParams": ["image"],
    82. "openai/toolInvocation/invoking": "Preparing your print options…",
    83. "openai/toolInvocation/invoked": "Print options ready",
    84. },
    85. },
    86. async ({ image, size, paper, frame, mat, layout, quantity }) => {
    87. const configuration = resolveConfiguration({ size, paper, frame, mat, layout, quantity });
    89. return {
    90. content: [{
    91. type: "text" as const,
    92. text: image
    93. ? "I opened the Xyppy prototype with the supplied image and estimated print options. No order has been placed."
    94. : "I opened the Xyppy prototype. Choose an image from ChatGPT or upload one to see print recommendations. No order has been placed.",
    95. }],
    96. structuredContent: {
    97. configuration,
    98. ...(image ? { initialImage: { fileId: image.file_id, fileName: image.file_name, mimeType: image.mime_type } } : {}),
    99. prototypeNotice: "Prototype estimate only — no order or payment will be created.",
    100. },
    101. };
    102. },
    103. );
    105. registerAppTool(
    106. server,
    107. "preview_checkout",
    108. {
    109. title: "Preview Xyppy checkout handoff",
    110. description: "Use this when the user has configured a print and wants to review the purchase handoff. This creates a checkout preview only and never creates a cart, checkout session, order, payment, production file, or fulfillment task.",
    111. inputSchema: {
    112. ...configurationInputSchema,
    113. provider: z.enum(["shopify", "stripe", "hybrid"]).optional().describe("The possible commerce backend to preview. Shopify is the default recommended path."),
    114. },
    115. annotations: {
    116. readOnlyHint: true,
    117. destructiveHint: false,
    118. openWorldHint: false,
    119. idempotentHint: true,
    120. },
    121. _meta: {
    122. ui: { resourceUri: TEMPLATE_URI },
    123. "openai/outputTemplate": TEMPLATE_URI,
    124. "openai/fileParams": ["image"],
    125. "openai/toolInvocation/invoking": "Preparing checkout preview...",
    126. "openai/toolInvocation/invoked": "Checkout preview ready",
    127. },
    128. },
    129. async ({ image, size, paper, frame, mat, layout, quantity, provider }) => {
    130. const configuration = resolveConfiguration({ size, paper, frame, mat, layout, quantity });
    131. const checkoutPreview = buildCheckoutPreview(configuration, { provider, imageAttached: Boolean(image) });
    132. const checkoutRuntime = readCheckoutRuntimeStatus();
    134. return {
    135. content: [{
    136. type: "text" as const,
    137. text: "I prepared a checkout preview for this Xyppy print. No cart, checkout session, order, payment, production file, or fulfillment task was created.",
    138. }],
    139. structuredContent: {
    140. configuration,
    141. ...(image ? { initialImage: { fileId: image.file_id, fileName: image.file_name, mimeType: image.mime_type } } : {}),
    142. checkoutPreview,
    143. checkoutRuntime,
    144. prototypeNotice: checkoutPreview.disclaimer,
    145. },
    146. };
    147. },
    148. );
    150. registerAppResource(
    151. server,
    152. "Xyppy Print Configurator",
    153. TEMPLATE_URI,
    154. {
    155. mimeType: RESOURCE_MIME_TYPE,
    156. description: "Interactive Xyppy print configuration widget",
    157. _meta: {
    158. ui: {
    159. prefersBorder: false,
    160. csp: { connectDomains: [], resourceDomains: [] },
    161. },
    162. "openai/widgetDescription": "An interactive print configurator for choosing an image, size, paper, frame, mat, crop treatment, and quantity, with prototype pricing.",
    163. },
    164. },
    165. async () => ({
    166. contents: [{ uri: TEMPLATE_URI, mimeType: RESOURCE_MIME_TYPE, text: readWidgetHtml() }],
    167. }),
    168. );
    170. return server;
    171. }
    173. export function createHttpApp() {
    174. const app = express();
    175. app.disable("x-powered-by");
    176. app.use(cors());
    177. app.use(express.json({ limit: "2mb" }));
    178. app.get("/health", (_req, res) => res.json({ ok: true, service: "xyppy-print-this", version: SERVER_VERSION, checkout: readCheckoutRuntimeStatus() }));
    180. app.all("/mcp", async (req, res) => {
    181. const server = createServer();
    182. const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
    183. res.on("close", () => {
    184. void transport.close();
    185. void server.close();
    186. });
    187. try {
    188. await server.connect(transport);
    189. await transport.handleRequest(req, res, req.body);
    190. } catch (error) {
    191. console.error("MCP error:", error);
    192. if (!res.headersSent) {
    193. res.status(500).json({ jsonrpc: "2.0", error: { code: -32603, message: "Internal server error" }, id: null });
    194. }
    195. }
    196. });
    197. return app;
    198. }
    200. if (process.env.NODE_ENV !== "test") {
    201. const port = Number.parseInt(process.env.PORT ?? "8000", 10);
    202. createHttpApp().listen(port, "0.0.0.0", () => {
    203. console.log(`Xyppy MCP server listening on http://localhost:${port}/mcp`);
    204. });
    205. }