mcp-inflight 0.2.0

package/dist/index.js

@@ -0,0 +1,1711 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/deploy.ts
+import * as path4 from "path";
+import * as fs4 from "fs";
+
+// src/utils/detect-project.ts
+import * as fs from "fs";
+import * as path from "path";
+function hasDependency(pkg, name) {
+  return !!(pkg.dependencies?.[name] || pkg.devDependencies?.[name]);
+}
+function detectPackageManager(projectPath, pkg) {
+  if (pkg.packageManager) {
+    if (pkg.packageManager.startsWith("pnpm")) return "pnpm";
+    if (pkg.packageManager.startsWith("yarn")) return "yarn";
+    if (pkg.packageManager.startsWith("bun")) return "bun";
+    if (pkg.packageManager.startsWith("npm")) return "npm";
+  }
+  if (fs.existsSync(path.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs.existsSync(path.join(projectPath, "yarn.lock"))) return "yarn";
+  if (fs.existsSync(path.join(projectPath, "bun.lockb"))) return "bun";
+  if (fs.existsSync(path.join(projectPath, "package-lock.json"))) return "npm";
+  return "npm";
+}
+function isMonorepo(projectPath, pkg) {
+  if (pkg.workspaces) return true;
+  const monorepoConfigs = [
+    "turbo.json",
+    "lerna.json",
+    "nx.json",
+    "pnpm-workspace.yaml",
+    "rush.json"
+  ];
+  return monorepoConfigs.some(
+    (config) => fs.existsSync(path.join(projectPath, config))
+  );
+}
+function extractPortFromScript(script) {
+  const portPatterns = [
+    /--port[=\s]+(\d+)/,
+    /-p[=\s]+(\d+)/,
+    /PORT[=:]\s*(\d+)/,
+    /:(\d{4,5})/
+    // Match port in URLs like localhost:3000
+  ];
+  for (const pattern of portPatterns) {
+    const match = script.match(pattern);
+    if (match) {
+      return parseInt(match[1], 10);
+    }
+  }
+  return null;
+}
+function findBestDevScript(scripts, packageManager) {
+  const runCmd = packageManager === "npm" ? "npm run" : packageManager;
+  const devScriptPriority = [
+    // Monorepo workspace scripts (common patterns)
+    "web:dev",
+    "app:dev",
+    "frontend:dev",
+    "client:dev",
+    "dev:web",
+    "dev:app",
+    // Standard dev scripts
+    "dev",
+    "start:dev",
+    "serve",
+    // Start scripts
+    "start"
+  ];
+  for (const scriptName of devScriptPriority) {
+    if (scripts[scriptName]) {
+      const scriptContent = scripts[scriptName];
+      const port = extractPortFromScript(scriptContent);
+      return {
+        scriptName,
+        command: `${runCmd} ${scriptName}`,
+        port: port ?? inferPortFromScript(scriptContent)
+      };
+    }
+  }
+  const devScript = Object.keys(scripts).find(
+    (name) => name.includes("dev") && !name.includes("devDependencies")
+  );
+  if (devScript) {
+    const scriptContent = scripts[devScript];
+    return {
+      scriptName: devScript,
+      command: `${runCmd} ${devScript}`,
+      port: extractPortFromScript(scriptContent) ?? inferPortFromScript(scriptContent)
+    };
+  }
+  return null;
+}
+function inferPortFromScript(script) {
+  if (script.includes("next")) return 3e3;
+  if (script.includes("vite")) return 5173;
+  if (script.includes("webpack-dev-server")) return 8080;
+  if (script.includes("react-scripts")) return 3e3;
+  if (script.includes("serve")) return 3e3;
+  if (script.includes("turbo")) return 3e3;
+  return 3e3;
+}
+function analyzeCompatibility(projectPath, pkg, isRepo) {
+  const issues = [];
+  const warnings = [];
+  const incompatibleDeps = [
+    { name: "electron", reason: "Electron apps require native desktop environment" },
+    { name: "tauri", reason: "Tauri apps require native desktop environment" },
+    { name: "@napi-rs", reason: "Native Node.js addons are not supported" }
+  ];
+  for (const dep of incompatibleDeps) {
+    if (hasDependency(pkg, dep.name)) {
+      issues.push(`${dep.name}: ${dep.reason}`);
+    }
+  }
+  const problematicDeps = [
+    { name: "sharp", reason: "May require native binaries - ensure libvips is available" },
+    { name: "canvas", reason: "Requires Cairo graphics library" },
+    { name: "sqlite3", reason: "Native SQLite bindings may need recompilation" },
+    { name: "bcrypt", reason: "Native bindings - consider using bcryptjs instead" },
+    { name: "puppeteer", reason: "Requires Chromium - use puppeteer-core with external browser" }
+  ];
+  for (const dep of problematicDeps) {
+    if (hasDependency(pkg, dep.name)) {
+      warnings.push(`${dep.name}: ${dep.reason}`);
+    }
+  }
+  if (fs.existsSync(path.join(projectPath, "Dockerfile")) || fs.existsSync(path.join(projectPath, "docker-compose.yml"))) {
+    warnings.push("Project uses Docker - CodeSandbox runs containers natively, Docker-in-Docker not supported");
+  }
+  if (isRepo) {
+    warnings.push("Monorepo detected - consider deploying only the specific app/package needed");
+  }
+  const serviceIndicators = [
+    { file: "redis.conf", service: "Redis" },
+    { file: "elasticsearch.yml", service: "Elasticsearch" },
+    { file: "mongod.conf", service: "MongoDB" }
+  ];
+  for (const indicator of serviceIndicators) {
+    if (fs.existsSync(path.join(projectPath, indicator.file))) {
+      warnings.push(`${indicator.service} config found - ensure service is available or use cloud-hosted version`);
+    }
+  }
+  return {
+    canDeploy: issues.length === 0,
+    issues,
+    warnings
+  };
+}
+function analyzeSizing(projectPath) {
+  const reasons = [];
+  const largeFiles = [];
+  let totalSize = 0;
+  let fileCount = 0;
+  const skipDirs = /* @__PURE__ */ new Set([
+    "node_modules",
+    ".git",
+    ".next",
+    "dist",
+    "build",
+    ".cache",
+    ".turbo",
+    ".vercel",
+    "coverage",
+    ".nyc_output"
+  ]);
+  const LARGE_FILE_THRESHOLD = 1024 * 1024;
+  function walkDir(dir, relativePath = "") {
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (skipDirs.has(entry.name)) continue;
+        const fullPath = path.join(dir, entry.name);
+        const relPath = path.join(relativePath, entry.name);
+        if (entry.isDirectory()) {
+          walkDir(fullPath, relPath);
+        } else if (entry.isFile()) {
+          try {
+            const stats = fs.statSync(fullPath);
+            totalSize += stats.size;
+            fileCount++;
+            if (stats.size > LARGE_FILE_THRESHOLD) {
+              largeFiles.push(`${relPath} (${(stats.size / 1024 / 1024).toFixed(1)}MB)`);
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  walkDir(projectPath);
+  const estimatedSizeMB = totalSize / 1024 / 1024;
+  let recommendedTier = "Micro";
+  const packageJsonPath = path.join(projectPath, "package.json");
+  let depCount = 0;
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+      depCount = Object.keys(pkg.dependencies ?? {}).length + Object.keys(pkg.devDependencies ?? {}).length;
+    } catch {
+    }
+  }
+  if (estimatedSizeMB < 5 && fileCount < 50 && depCount < 20) {
+    recommendedTier = "Nano";
+    reasons.push("Small project with few files and dependencies");
+  } else if (estimatedSizeMB < 50 && fileCount < 500 && depCount < 50) {
+    recommendedTier = "Micro";
+    reasons.push("Standard project size");
+  } else if (estimatedSizeMB < 200 && fileCount < 2e3 && depCount < 100) {
+    recommendedTier = "Small";
+    reasons.push("Medium-sized project");
+  } else if (estimatedSizeMB < 500 && fileCount < 5e3) {
+    recommendedTier = "Medium";
+    reasons.push("Large project with many files");
+  } else {
+    recommendedTier = "Large";
+    reasons.push("Very large project");
+  }
+  if (fs.existsSync(path.join(projectPath, "turbo.json"))) {
+    if (recommendedTier === "Nano") recommendedTier = "Micro";
+    if (recommendedTier === "Micro") recommendedTier = "Small";
+    reasons.push("Turborepo monorepo - builds may need more resources");
+  }
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+      if (hasDependency(pkg, "next") && (hasDependency(pkg, "prisma") || hasDependency(pkg, "@prisma/client"))) {
+        if (recommendedTier === "Nano") recommendedTier = "Micro";
+        if (recommendedTier === "Micro") recommendedTier = "Small";
+        reasons.push("Next.js + Prisma requires more memory for generation");
+      }
+      if (hasDependency(pkg, "typescript") && depCount > 80) {
+        reasons.push("Large TypeScript project - compilation may be slow on smaller tiers");
+      }
+    } catch {
+    }
+  }
+  if (largeFiles.length > 0) {
+    reasons.push(`${largeFiles.length} large file(s) detected`);
+  }
+  return {
+    recommendedTier,
+    fileCount,
+    estimatedSizeMB: Math.round(estimatedSizeMB * 10) / 10,
+    largeFiles: largeFiles.slice(0, 5),
+    // Limit to top 5
+    reasons
+  };
+}
+function getSuggestedScripts(scripts) {
+  const devRelated = [
+    "dev",
+    "start",
+    "serve",
+    "web:dev",
+    "app:dev",
+    "build",
+    "test"
+  ];
+  const suggestions = [];
+  for (const name of devRelated) {
+    if (scripts[name]) {
+      suggestions.push(name);
+    }
+  }
+  for (const name of Object.keys(scripts)) {
+    if ((name.includes("dev") || name.includes("start")) && !suggestions.includes(name)) {
+      suggestions.push(name);
+    }
+  }
+  return suggestions.slice(0, 10);
+}
+function detectProjectType(projectPath) {
+  const packageJsonPath = path.join(projectPath, "package.json");
+  const indexHtmlPath = path.join(projectPath, "index.html");
+  const sizing = analyzeSizing(projectPath);
+  const defaultCompatibility = {
+    canDeploy: true,
+    issues: [],
+    warnings: []
+  };
+  const defaultResult = {
+    type: "static",
+    port: 3e3,
+    installCommand: null,
+    startCommand: "npx serve .",
+    detectedPackageManager: "npm",
+    isMonorepo: false,
+    availableScripts: [],
+    suggestedScripts: [],
+    compatibility: defaultCompatibility,
+    sizing
+  };
+  if (!fs.existsSync(packageJsonPath)) {
+    if (fs.existsSync(indexHtmlPath)) {
+      return defaultResult;
+    }
+    return defaultResult;
+  }
+  const packageJson = JSON.parse(
+    fs.readFileSync(packageJsonPath, "utf-8")
+  );
+  const packageManager = detectPackageManager(projectPath, packageJson);
+  const isRepo = isMonorepo(projectPath, packageJson);
+  const scripts = packageJson.scripts ?? {};
+  const availableScripts = Object.keys(scripts);
+  const suggestedScripts = getSuggestedScripts(scripts);
+  const compatibility = analyzeCompatibility(projectPath, packageJson, isRepo);
+  const installCommand = `${packageManager} install`;
+  const runCmd = packageManager === "npm" ? "npm run" : packageManager;
+  const bestScript = findBestDevScript(scripts, packageManager);
+  let type = "node";
+  let defaultPort = 3e3;
+  if (isRepo) {
+    type = "monorepo";
+  } else if (hasDependency(packageJson, "next")) {
+    type = "nextjs";
+    defaultPort = 3e3;
+  } else if (hasDependency(packageJson, "vite")) {
+    type = "vite";
+    defaultPort = 5173;
+  } else if (hasDependency(packageJson, "react-scripts")) {
+    type = "cra";
+    defaultPort = 3e3;
+  } else if (hasDependency(packageJson, "express") || hasDependency(packageJson, "fastify") || hasDependency(packageJson, "koa") || hasDependency(packageJson, "hono")) {
+    type = "node";
+    defaultPort = 3e3;
+  }
+  if (bestScript) {
+    return {
+      type,
+      port: bestScript.port,
+      installCommand,
+      startCommand: bestScript.command,
+      detectedPackageManager: packageManager,
+      isMonorepo: isRepo,
+      availableScripts,
+      suggestedScripts,
+      compatibility,
+      sizing
+    };
+  }
+  const startCommand = scripts.dev ? `${runCmd} dev` : scripts.start ? `${runCmd} start` : "node index.js";
+  return {
+    type,
+    port: defaultPort,
+    installCommand,
+    startCommand,
+    detectedPackageManager: packageManager,
+    isMonorepo: isRepo,
+    availableScripts,
+    suggestedScripts,
+    compatibility,
+    sizing
+  };
+}
+
+// src/utils/file-utils.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var ALWAYS_IGNORE = [
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  ".cache",
+  ".turbo",
+  ".vercel",
+  ".DS_Store",
+  "*.log"
+];
+var ENV_FILES = [".env", ".env.local", ".env.development", ".env.production"];
+function shouldIgnore(name, includeEnvFiles) {
+  const alwaysIgnored = ALWAYS_IGNORE.some((pattern) => {
+    if (pattern.startsWith("*")) {
+      return name.endsWith(pattern.slice(1));
+    }
+    return name === pattern;
+  });
+  if (alwaysIgnored) return true;
+  if (!includeEnvFiles && ENV_FILES.some((env) => name === env || name.startsWith(".env"))) {
+    return true;
+  }
+  return false;
+}
+function readProjectFiles(projectPath, relativePath = "", includeEnvFiles = false) {
+  const files = {};
+  const fullPath = path2.join(projectPath, relativePath);
+  const entries = fs2.readdirSync(fullPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (shouldIgnore(entry.name, includeEnvFiles)) {
+      continue;
+    }
+    const entryRelativePath = path2.join(relativePath, entry.name);
+    if (entry.isDirectory()) {
+      Object.assign(files, readProjectFiles(projectPath, entryRelativePath, includeEnvFiles));
+    } else if (entry.isFile()) {
+      const filePath = path2.join(projectPath, entryRelativePath);
+      try {
+        const content = fs2.readFileSync(filePath, "utf-8");
+        files[entryRelativePath] = content;
+      } catch {
+      }
+    }
+  }
+  return files;
+}
+var MAX_CHUNK_SIZE = 500 * 1024;
+var CHUNK_THRESHOLD = 800 * 1024;
+function calculateTotalSize(files) {
+  return Object.values(files).reduce((sum, content) => sum + content.length, 0);
+}
+function needsChunkedUpload(files) {
+  return calculateTotalSize(files) > CHUNK_THRESHOLD;
+}
+function chunkFiles(files, maxChunkSize = MAX_CHUNK_SIZE) {
+  const chunks = [];
+  let currentChunk = {};
+  let currentSize = 0;
+  const entries = Object.entries(files).sort((a, b) => a[1].length - b[1].length);
+  for (const [filePath, content] of entries) {
+    const fileSize = content.length;
+    if (fileSize > maxChunkSize) {
+      if (Object.keys(currentChunk).length > 0) {
+        chunks.push(currentChunk);
+        currentChunk = {};
+        currentSize = 0;
+      }
+      chunks.push({ [filePath]: content });
+      continue;
+    }
+    if (currentSize + fileSize > maxChunkSize && Object.keys(currentChunk).length > 0) {
+      chunks.push(currentChunk);
+      currentChunk = {};
+      currentSize = 0;
+    }
+    currentChunk[filePath] = content;
+    currentSize += fileSize;
+  }
+  if (Object.keys(currentChunk).length > 0) {
+    chunks.push(currentChunk);
+  }
+  return chunks;
+}
+
+// src/utils/auth.ts
+import * as http from "http";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+var AUTH_FILE = path3.join(
+  process.env.HOME || process.env.USERPROFILE || "",
+  ".claude",
+  "mcp-inflight-auth.json"
+);
+var LEGACY_AUTH_FILE = path3.join(
+  process.env.HOME || process.env.USERPROFILE || "",
+  ".claude",
+  "mcp-sandbox-auth.json"
+);
+var INFLIGHT_BASE = process.env.INFLIGHT_URL || "https://www.inflight.co";
+function getAuthData() {
+  try {
+    const content = fs3.readFileSync(AUTH_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    try {
+      const legacyContent = fs3.readFileSync(LEGACY_AUTH_FILE, "utf-8");
+      const legacyData = JSON.parse(legacyContent);
+      saveAuthData(legacyData);
+      try {
+        fs3.unlinkSync(LEGACY_AUTH_FILE);
+      } catch {
+      }
+      return legacyData;
+    } catch {
+      return null;
+    }
+  }
+}
+function saveAuthData(data) {
+  const dir = path3.dirname(AUTH_FILE);
+  fs3.mkdirSync(dir, { recursive: true });
+  fs3.writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2), { mode: 384 });
+}
+function clearAuthData() {
+  try {
+    fs3.unlinkSync(AUTH_FILE);
+  } catch {
+  }
+  try {
+    fs3.unlinkSync(LEGACY_AUTH_FILE);
+  } catch {
+  }
+}
+function isAuthenticated() {
+  return getAuthData() !== null;
+}
+async function openBrowser(url) {
+  const platform = process.platform;
+  try {
+    if (platform === "darwin") {
+      await execAsync(`open "${url}"`);
+    } else if (platform === "win32") {
+      await execAsync(`start "" "${url}"`);
+    } else {
+      await execAsync(`xdg-open "${url}"`);
+    }
+  } catch (error) {
+    throw new Error(
+      `Failed to open browser. Please manually visit: ${url}`
+    );
+  }
+}
+async function authenticate(log) {
+  return new Promise((resolve3, reject) => {
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url || "", `http://localhost`);
+      if (url.pathname === "/callback") {
+        const apiKey = url.searchParams.get("api_key");
+        const userId = url.searchParams.get("user_id");
+        const email = url.searchParams.get("email");
+        const name = url.searchParams.get("name");
+        if (!apiKey || !userId) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(`
+            <html>
+              <body style="font-family: system-ui; padding: 2rem; text-align: center;">
+                <h1 style="color: #e53e3e;">Authentication Failed</h1>
+                <p>Missing API key or user ID. Please try again.</p>
+              </body>
+            </html>
+          `);
+          server.close();
+          reject(new Error("Missing API key or user ID in callback"));
+          return;
+        }
+        const displayName = name || email || "there";
+        const safeDisplayName = escapeHtml(displayName);
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <meta charset="utf-8">
+              <meta name="viewport" content="width=device-width, initial-scale=1">
+              <title>Authenticated - InFlight</title>
+              <style>
+                * { margin: 0; padding: 0; box-sizing: border-box; }
+                body {
+                  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+                  background-color: #15161C;
+                  color: #F9FAFB;
+                  min-height: 100vh;
+                  display: flex;
+                  align-items: center;
+                  justify-content: center;
+                }
+                .container {
+                  background-color: #0F1012;
+                  border: 1px solid #1F2025;
+                  border-radius: 16px;
+                  padding: 48px;
+                  text-align: center;
+                  max-width: 400px;
+                  width: 90%;
+                  box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.3), 0 2px 4px -1px rgba(0, 0, 0, 0.2);
+                }
+                .logo {
+                  margin-bottom: 32px;
+                }
+                .success-icon {
+                  width: 64px;
+                  height: 64px;
+                  background: linear-gradient(135deg, #1C8AF8 0%, #60ADFA 100%);
+                  border-radius: 50%;
+                  display: flex;
+                  align-items: center;
+                  justify-content: center;
+                  margin: 0 auto 24px;
+                }
+                .success-icon svg {
+                  width: 32px;
+                  height: 32px;
+                }
+                h1 {
+                  font-size: 24px;
+                  font-weight: 600;
+                  margin-bottom: 8px;
+                  color: #F9FAFB;
+                }
+                .greeting {
+                  font-size: 16px;
+                  color: #98A1AE;
+                  margin-bottom: 24px;
+                }
+                .message {
+                  font-size: 14px;
+                  color: #697282;
+                  line-height: 1.5;
+                }
+                .close-hint {
+                  margin-top: 24px;
+                  padding-top: 24px;
+                  border-top: 1px solid #1F2025;
+                  font-size: 13px;
+                  color: #697282;
+                }
+              </style>
+            </head>
+            <body>
+              <div class="container">
+                <div class="logo">
+                  <svg xmlns="http://www.w3.org/2000/svg" width="41" height="25" viewBox="0 0 41 25" fill="none">
+                    <path d="M23.1244 23.6849C22.6097 24.7058 21.0702 24.3421 21.0668 23.1988L21.0015 1.1163C20.9987 0.188062 22.0857 -0.316302 22.7927 0.285127L39.6536 14.6273C40.526 15.3694 39.8055 16.782 38.6925 16.5114L28.8843 14.127C28.3931 14.0076 27.8845 14.2426 27.6569 14.6939L23.1244 23.6849Z" fill="white"/>
+                    <path d="M16.9597 23.6651C17.4771 24.6846 19.0157 24.3168 19.016 23.1735L19.0223 1.09085C19.0225 0.162606 17.9342 -0.338848 17.2288 0.26447L0.406372 14.6517C-0.464095 15.3961 0.260202 16.8068 1.37245 16.5333L11.1743 14.1226C11.6651 14.0019 12.1744 14.2355 12.4032 14.6862L16.9597 23.6651Z" fill="white"/>
+                  </svg>
+                </div>
+                <div class="success-icon">
+                  <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="white" stroke-width="3">
+                    <path stroke-linecap="round" stroke-linejoin="round" d="M5 13l4 4L19 7"/>
+                  </svg>
+                </div>
+                <h1>You're connected!</h1>
+                <p class="greeting">Welcome, ${safeDisplayName}</p>
+                <p class="message">InFlight is now connected to Claude Code. You can share prototypes and get feedback directly from your terminal.</p>
+                <p class="close-hint">This window will close automatically...</p>
+              </div>
+              <script>setTimeout(() => window.close(), 3000);</script>
+            </body>
+          </html>
+        `);
+        const authData = {
+          apiKey,
+          userId,
+          email: email || void 0,
+          name: name || void 0,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        saveAuthData(authData);
+        server.close();
+        resolve3(authData);
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+    });
+    server.on("error", (err) => {
+      reject(new Error(`Failed to start auth server: ${err.message}`));
+    });
+    server.listen(0, "127.0.0.1", async () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        server.close();
+        reject(new Error("Failed to get server address"));
+        return;
+      }
+      const port = address.port;
+      const authUrl = `${INFLIGHT_BASE}/api/mcp/auth?callback_port=${port}`;
+      await log("Opening browser for InFlight authentication...");
+      await log(`If browser doesn't open, visit: ${authUrl}`);
+      try {
+        await openBrowser(authUrl);
+      } catch (error) {
+        await log(
+          `Could not open browser automatically. Please visit: ${authUrl}`,
+          "warning"
+        );
+      }
+    });
+    const timeout = setTimeout(() => {
+      server.close();
+      reject(new Error("Authentication timed out after 5 minutes"));
+    }, 3e5);
+    server.on("close", () => {
+      clearTimeout(timeout);
+    });
+  });
+}
+
+// src/utils/inflight.ts
+import { spawn } from "child_process";
+var spawnAsync = (command, args) => new Promise((resolve3, reject) => {
+  const child = spawn(command, args, { stdio: "ignore" });
+  child.on("error", (err) => {
+    reject(err);
+  });
+  child.on("close", () => {
+    resolve3();
+  });
+});
+var INFLIGHT_API = process.env.INFLIGHT_URL || "https://www.inflight.co";
+var NotAuthenticatedError = class extends Error {
+  constructor() {
+    super("Not authenticated with InFlight. Please run authentication first.");
+    this.name = "NotAuthenticatedError";
+  }
+};
+var APIError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "APIError";
+    this.status = status;
+  }
+};
+function getAuthHeaders(auth) {
+  return {
+    Authorization: `Bearer ${auth.apiKey}`,
+    "Content-Type": "application/json"
+  };
+}
+async function consumeSSEStream(response, onStatus, onComplete, onError) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("No response body");
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    let currentEvent = "";
+    let currentData = "";
+    for (const line of lines) {
+      if (line.startsWith("event: ")) {
+        currentEvent = line.slice(7).trim();
+      } else if (line.startsWith("data: ")) {
+        currentData = line.slice(6);
+      } else if (line === "" && currentEvent && currentData) {
+        try {
+          const data = JSON.parse(currentData);
+          switch (currentEvent) {
+            case "status":
+              onStatus(data.message);
+              break;
+            case "complete":
+              onComplete(data);
+              break;
+            case "error":
+              onError(data.message);
+              break;
+          }
+        } catch {
+        }
+        currentEvent = "";
+        currentData = "";
+      }
+    }
+  }
+}
+async function deployProject(files, options, log) {
+  const auth = getAuthData();
+  if (!auth) {
+    throw new NotAuthenticatedError();
+  }
+  const response = await fetch(`${INFLIGHT_API}/api/mcp/sandbox/deploy`, {
+    method: "POST",
+    headers: getAuthHeaders(auth),
+    body: JSON.stringify({
+      files,
+      projectType: options.projectType,
+      installCommand: options.installCommand,
+      startCommand: options.startCommand,
+      port: options.port,
+      vmTier: options.vmTier || "Micro",
+      projectName: options.projectName,
+      workspaceId: options.workspaceId || auth.defaultWorkspaceId,
+      gitInfo: options.gitInfo
+    })
+  });
+  if (!response.ok && !response.headers.get("content-type")?.includes("text/event-stream")) {
+    const text = await response.text();
+    throw new APIError(`Failed to deploy: ${text}`, response.status);
+  }
+  let result = null;
+  let errorMessage = null;
+  await consumeSSEStream(
+    response,
+    (message) => log(message),
+    (data) => {
+      result = data;
+      if (result.workspaceId && result.workspaceId !== auth.defaultWorkspaceId) {
+        saveAuthData({
+          ...auth,
+          defaultWorkspaceId: result.workspaceId
+        });
+      }
+    },
+    (message) => {
+      errorMessage = message;
+    }
+  );
+  if (errorMessage) {
+    throw new APIError(errorMessage, 500);
+  }
+  if (!result) {
+    throw new APIError("No response from deploy endpoint", 500);
+  }
+  return result;
+}
+async function syncProject(sandboxId, files, options, log) {
+  const auth = getAuthData();
+  if (!auth) {
+    throw new NotAuthenticatedError();
+  }
+  const response = await fetch(`${INFLIGHT_API}/api/mcp/sandbox/sync`, {
+    method: "POST",
+    headers: getAuthHeaders(auth),
+    body: JSON.stringify({
+      sandboxId,
+      files,
+      restartServer: options.restartServer ?? true,
+      startCommand: options.startCommand,
+      port: options.port,
+      gitInfo: options.gitInfo
+    })
+  });
+  if (!response.ok && !response.headers.get("content-type")?.includes("text/event-stream")) {
+    const text = await response.text();
+    throw new APIError(`Failed to sync: ${text}`, response.status);
+  }
+  let result = null;
+  let errorMessage = null;
+  await consumeSSEStream(
+    response,
+    (message) => log(message),
+    (data) => {
+      result = data;
+    },
+    (message) => {
+      errorMessage = message;
+    }
+  );
+  if (errorMessage) {
+    throw new APIError(errorMessage, 500);
+  }
+  if (!result) {
+    throw new APIError("No response from sync endpoint", 500);
+  }
+  return result;
+}
+async function listSandboxes(sync = true) {
+  const auth = getAuthData();
+  if (!auth) {
+    throw new NotAuthenticatedError();
+  }
+  const url = new URL(`${INFLIGHT_API}/api/mcp/sandbox/list`);
+  if (sync) {
+    url.searchParams.set("sync", "true");
+  }
+  const response = await fetch(url.toString(), {
+    method: "GET",
+    headers: getAuthHeaders(auth)
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new APIError(`Failed to list sandboxes: ${text}`, response.status);
+  }
+  const data = await response.json();
+  return data.sandboxes || [];
+}
+async function deleteSandbox(sandboxId) {
+  const auth = getAuthData();
+  if (!auth) {
+    throw new NotAuthenticatedError();
+  }
+  const response = await fetch(`${INFLIGHT_API}/api/mcp/sandbox/${sandboxId}`, {
+    method: "DELETE",
+    headers: getAuthHeaders(auth)
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new APIError(`Failed to delete sandbox: ${text}`, response.status);
+  }
+}
+var TRUSTED_DOMAINS = [
+  "inflight.co",
+  "www.inflight.co",
+  "csb.app"
+  // CodeSandbox preview URLs
+];
+function isTrustedHost(hostname) {
+  const lowerHost = hostname.toLowerCase();
+  return TRUSTED_DOMAINS.some((domain) => {
+    return lowerHost === domain || lowerHost.endsWith(`.${domain}`);
+  });
+}
+async function openInBrowser(url) {
+  if (typeof url !== "string") {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return;
+  }
+  if (!isTrustedHost(parsed.hostname)) {
+    return;
+  }
+  const safeUrl = parsed.href;
+  const platform = process.platform;
+  try {
+    if (platform === "darwin") {
+      await spawnAsync("open", [safeUrl]);
+    } else if (platform === "win32") {
+      await spawnAsync("cmd", ["/c", "start", "", safeUrl]);
+    } else {
+      await spawnAsync("xdg-open", [safeUrl]);
+    }
+  } catch {
+  }
+}
+async function createSandbox(options, log) {
+  const auth = getAuthData();
+  if (!auth) {
+    throw new NotAuthenticatedError();
+  }
+  await log("Creating sandbox...");
+  const response = await fetch(`${INFLIGHT_API}/api/mcp/sandbox/create`, {
+    method: "POST",
+    headers: getAuthHeaders(auth),
+    body: JSON.stringify({
+      vmTier: options.vmTier || "Micro",
+      workspaceId: options.workspaceId || auth.defaultWorkspaceId,
+      projectName: options.projectName
+    })
+  });
+  if (!response.ok) {
+    const data2 = await response.json().catch(() => ({ error: "Unknown error" }));
+    throw new APIError(data2.error || "Failed to create sandbox", response.status);
+  }
+  const data = await response.json();
+  if (!data.success) {
+    throw new APIError(data.error || "Failed to create sandbox", 500);
+  }
+  return {
+    sandboxId: data.sandboxId,
+    workspaceId: data.workspaceId
+  };
+}
+async function uploadChunk(sandboxId, files, chunkIndex, totalChunks, log) {
+  const auth = getAuthData();
+  if (!auth) {
+    throw new NotAuthenticatedError();
+  }
+  const fileCount = Object.keys(files).length;
+  const chunkSize = Object.values(files).reduce((sum, content) => sum + content.length, 0);
+  await log(`Uploading chunk ${chunkIndex + 1}/${totalChunks} (${fileCount} files, ${(chunkSize / 1024).toFixed(1)} KB)...`);
+  const response = await fetch(`${INFLIGHT_API}/api/mcp/sandbox/${sandboxId}/upload`, {
+    method: "POST",
+    headers: getAuthHeaders(auth),
+    body: JSON.stringify({
+      files,
+      chunkIndex,
+      totalChunks
+    })
+  });
+  if (!response.ok) {
+    const data2 = await response.json().catch(() => ({ error: "Unknown error" }));
+    throw new APIError(data2.error || `Failed to upload chunk ${chunkIndex}`, response.status);
+  }
+  const data = await response.json();
+  if (!data.success) {
+    throw new APIError(data.error || `Failed to upload chunk ${chunkIndex}`, 500);
+  }
+  return {
+    chunkIndex: data.chunkIndex,
+    fileCount: data.fileCount
+  };
+}
+async function finalizeSandbox(sandboxId, options, log) {
+  const auth = getAuthData();
+  if (!auth) {
+    throw new NotAuthenticatedError();
+  }
+  await log("Finalizing deployment...");
+  const response = await fetch(`${INFLIGHT_API}/api/mcp/sandbox/${sandboxId}/finalize`, {
+    method: "POST",
+    headers: getAuthHeaders(auth),
+    body: JSON.stringify({
+      projectType: options.projectType,
+      installCommand: options.installCommand,
+      startCommand: options.startCommand,
+      port: options.port,
+      projectName: options.projectName,
+      workspaceId: options.workspaceId,
+      gitInfo: options.gitInfo
+    })
+  });
+  if (!response.ok && !response.headers.get("content-type")?.includes("text/event-stream")) {
+    const text = await response.text();
+    throw new APIError(`Failed to finalize: ${text}`, response.status);
+  }
+  let result = null;
+  let errorMessage = null;
+  await consumeSSEStream(
+    response,
+    (message) => log(message),
+    (data) => {
+      result = data;
+      if (result.workspaceId && result.workspaceId !== auth.defaultWorkspaceId) {
+        saveAuthData({
+          ...auth,
+          defaultWorkspaceId: result.workspaceId
+        });
+      }
+    },
+    (message) => {
+      errorMessage = message;
+    }
+  );
+  if (errorMessage) {
+    throw new APIError(errorMessage, 500);
+  }
+  if (!result) {
+    throw new APIError("No response from finalize endpoint", 500);
+  }
+  return result;
+}
+async function deployProjectChunked(fileChunks, options, log) {
+  const { sandboxId, workspaceId } = await createSandbox(
+    {
+      vmTier: options.vmTier,
+      workspaceId: options.workspaceId,
+      projectName: options.projectName
+    },
+    log
+  );
+  await log(`Sandbox created: ${sandboxId}`);
+  const totalChunks = fileChunks.length;
+  for (let i = 0; i < totalChunks; i++) {
+    await uploadChunk(sandboxId, fileChunks[i], i, totalChunks, log);
+  }
+  await log("All files uploaded");
+  const result = await finalizeSandbox(
+    sandboxId,
+    {
+      projectType: options.projectType,
+      installCommand: options.installCommand,
+      startCommand: options.startCommand,
+      port: options.port,
+      projectName: options.projectName,
+      workspaceId,
+      gitInfo: options.gitInfo
+    },
+    log
+  );
+  return result;
+}
+
+// src/utils/git-utils.ts
+import { execSync, execFileSync } from "child_process";
+function gitExec(command, cwd) {
+  try {
+    return execSync(command, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function isGitRepo(projectPath) {
+  const result = gitExec("git rev-parse --is-inside-work-tree", projectPath);
+  return result === "true";
+}
+function hasUncommittedChanges(projectPath) {
+  const status = gitExec("git status --porcelain", projectPath);
+  return status !== null && status.length > 0;
+}
+function sanitizeRemoteUrl(url) {
+  if (!url) return null;
+  let cleaned = url.replace(/\.git$/, "");
+  if (cleaned.startsWith("git@")) {
+    cleaned = cleaned.replace(/^git@/, "").replace(":", "/");
+    return cleaned;
+  }
+  try {
+    const parsed = new URL(cleaned);
+    return `${parsed.host}${parsed.pathname}`;
+  } catch {
+    return cleaned.replace(/^https?:\/\/[^@]+@/, "").replace(/^https?:\/\//, "");
+  }
+}
+function getGitInfo(projectPath) {
+  if (!isGitRepo(projectPath)) {
+    return null;
+  }
+  const branch = gitExec("git rev-parse --abbrev-ref HEAD", projectPath);
+  const commitShort = gitExec("git rev-parse --short HEAD", projectPath);
+  const commitFull = gitExec("git rev-parse HEAD", projectPath);
+  const commitMessage = gitExec("git log -1 --format=%s", projectPath);
+  const rawRemoteUrl = gitExec("git remote get-url origin", projectPath);
+  const timestamp = gitExec("git log -1 --format=%cI", projectPath);
+  const isDirty = hasUncommittedChanges(projectPath);
+  return {
+    branch,
+    commitShort,
+    commitFull,
+    commitMessage,
+    remoteUrl: sanitizeRemoteUrl(rawRemoteUrl),
+    isDirty,
+    timestamp
+  };
+}
+function autoCommitForShare(projectPath, inflightVersionId) {
+  if (!isGitRepo(projectPath)) {
+    return null;
+  }
+  if (!hasUncommittedChanges(projectPath)) {
+    return null;
+  }
+  try {
+    execSync("git add -A", {
+      cwd: projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const commitMessage = `InFlight share: ${inflightVersionId}`;
+    execFileSync(
+      "git",
+      ["commit", "-m", commitMessage],
+      {
+        cwd: projectPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }
+    );
+    return gitExec("git rev-parse --short HEAD", projectPath);
+  } catch {
+    return null;
+  }
+}
+
+// src/tools/deploy.ts
+async function deployPrototype(args, log) {
+  const startTime = Date.now();
+  await log(`Starting share for: ${args.path}`);
+  const projectPath = path4.resolve(args.path);
+  if (!fs4.existsSync(projectPath)) {
+    throw new Error(`Project path does not exist: ${projectPath}`);
+  }
+  if (!fs4.statSync(projectPath).isDirectory()) {
+    throw new Error(`Path is not a directory: ${projectPath}`);
+  }
+  if (!isAuthenticated()) {
+    await log("Authenticating with InFlight...");
+    try {
+      await authenticate(log);
+      await log("Authenticated with InFlight");
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`InFlight authentication failed: ${errorMessage}`);
+    }
+  } else {
+    await log("Using saved InFlight credentials");
+  }
+  await log("Analyzing project...");
+  const projectInfo = detectProjectType(projectPath);
+  let gitInfo = getGitInfo(projectPath);
+  const hadUncommittedChanges = gitInfo?.isDirty ?? false;
+  if (gitInfo) {
+    const dirtyMarker = gitInfo.isDirty ? " (modified)" : "";
+    await log(`Git: ${gitInfo.branch}@${gitInfo.commitShort}${dirtyMarker}`);
+  }
+  if (!projectInfo.compatibility.canDeploy) {
+    throw new Error(
+      `Project cannot be deployed: ${projectInfo.compatibility.issues.join(", ")}`
+    );
+  }
+  if (projectInfo.compatibility.warnings.length > 0) {
+    await log(`Warnings: ${projectInfo.compatibility.warnings.join(", ")}`, "warning");
+  }
+  if (args.port) {
+    projectInfo.port = args.port;
+  }
+  if (args.command) {
+    projectInfo.startCommand = args.command;
+  }
+  const isMonorepo2 = projectInfo.isMonorepo ? " (monorepo)" : "";
+  await log(`Detected: ${projectInfo.type}${isMonorepo2}`);
+  await log(`Package manager: ${projectInfo.detectedPackageManager}`);
+  await log(`Install command: ${projectInfo.installCommand || "none"}`);
+  await log(`Start command: ${projectInfo.startCommand}`);
+  await log(`Port: ${projectInfo.port}`);
+  await log(`VM tier: ${projectInfo.sizing.recommendedTier}`);
+  await log("Reading project files...");
+  const includeEnv = args.includeEnvFiles ?? false;
+  if (includeEnv) {
+    await log("Including .env files as requested");
+  }
+  const files = readProjectFiles(projectPath, "", includeEnv);
+  const fileCount = Object.keys(files).length;
+  const totalSize = Object.values(files).reduce((sum, content) => sum + content.length, 0);
+  await log(`Found ${fileCount} files (${(totalSize / 1024).toFixed(1)} KB)`);
+  if (fileCount === 0) {
+    throw new Error("No files found in project directory");
+  }
+  let existingSandbox;
+  try {
+    const sandboxes = await listSandboxes();
+    const projectName = path4.basename(projectPath);
+    existingSandbox = sandboxes.find(
+      (s) => s.projectName === projectName && s.status === "running"
+    );
+  } catch {
+  }
+  let result;
+  if (existingSandbox) {
+    await log(`Found existing sandbox: ${existingSandbox.sandboxId}`);
+    await log("Syncing files...");
+    try {
+      const syncResult = await syncProject(
+        existingSandbox.sandboxId,
+        files,
+        {
+          restartServer: true,
+          startCommand: projectInfo.startCommand,
+          port: projectInfo.port,
+          gitInfo: gitInfo || void 0
+        },
+        log
+      );
+      const inflightUrl = existingSandbox.inflightUrl || "";
+      const inflightVersionId = existingSandbox.inflightVersionId || "";
+      result = {
+        url: syncResult.sandboxUrl,
+        sandboxId: existingSandbox.sandboxId,
+        projectType: projectInfo.type,
+        synced: true,
+        inflightUrl,
+        inflightVersionId
+      };
+      const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+      await log(`Sync complete in ${elapsed}s`);
+    } catch (syncError) {
+      const errorMsg = syncError instanceof Error ? syncError.message : String(syncError);
+      await log(`Sync failed, creating new sandbox: ${errorMsg}`, "warning");
+      existingSandbox = void 0;
+    }
+  }
+  if (!existingSandbox) {
+    const useChunkedUpload = needsChunkedUpload(files);
+    if (useChunkedUpload) {
+      const totalSize2 = calculateTotalSize(files);
+      await log(`Large project detected (${(totalSize2 / 1024 / 1024).toFixed(1)} MB), using chunked upload...`);
+      const fileChunks = chunkFiles(files);
+      await log(`Split into ${fileChunks.length} chunks`);
+      const deployResult = await deployProjectChunked(
+        fileChunks,
+        {
+          projectType: projectInfo.type,
+          installCommand: projectInfo.installCommand || void 0,
+          startCommand: projectInfo.startCommand,
+          port: projectInfo.port,
+          vmTier: projectInfo.sizing.recommendedTier,
+          projectName: path4.basename(projectPath),
+          workspaceId: args.workspaceId,
+          gitInfo: gitInfo || void 0
+        },
+        log
+      );
+      result = {
+        url: deployResult.sandboxUrl,
+        sandboxId: deployResult.sandboxId,
+        projectType: projectInfo.type,
+        synced: false,
+        inflightUrl: deployResult.inflightUrl,
+        inflightVersionId: deployResult.versionId
+      };
+    } else {
+      await log("Deploying via InFlight API...");
+      const deployResult = await deployProject(
+        files,
+        {
+          projectType: projectInfo.type,
+          installCommand: projectInfo.installCommand || void 0,
+          startCommand: projectInfo.startCommand,
+          port: projectInfo.port,
+          vmTier: projectInfo.sizing.recommendedTier,
+          projectName: path4.basename(projectPath),
+          workspaceId: args.workspaceId,
+          gitInfo: gitInfo || void 0
+        },
+        log
+      );
+      result = {
+        url: deployResult.sandboxUrl,
+        sandboxId: deployResult.sandboxId,
+        projectType: projectInfo.type,
+        synced: false,
+        inflightUrl: deployResult.inflightUrl,
+        inflightVersionId: deployResult.versionId
+      };
+    }
+    const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+    await log(`Deploy complete in ${elapsed}s`);
+  }
+  if (hadUncommittedChanges && result.inflightVersionId) {
+    const newCommit = autoCommitForShare(projectPath, result.inflightVersionId);
+    if (newCommit) {
+      await log(`Auto-committed changes: ${newCommit}`);
+      gitInfo = getGitInfo(projectPath);
+    }
+  }
+  await log(`InFlight: ${result.inflightUrl}`);
+  if (args.openBrowser !== false && result.inflightUrl) {
+    await openInBrowser(result.inflightUrl);
+    await log("Opened InFlight in browser");
+  }
+  return result;
+}
+
+// src/server.ts
+import * as path5 from "path";
+import * as fs5 from "fs";
+function createServer2() {
+  const server = new Server(
+    {
+      name: "mcp-inflight",
+      version: "0.2.0"
+    },
+    {
+      capabilities: {
+        tools: {},
+        logging: {}
+      }
+    }
+  );
+  const log = async (message, level = "info") => {
+    try {
+      await server.sendLoggingMessage({
+        level,
+        data: message,
+        logger: "mcp-inflight"
+      });
+    } catch {
+    }
+  };
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: [
+        {
+          name: "share",
+          description: "Share a local project by deploying it to a public URL and creating an InFlight version for feedback. Supports React, Next.js, Vite, Node.js, and static HTML projects. Returns the InFlight URL. Requires InFlight authentication (will prompt if not authenticated).",
+          inputSchema: {
+            type: "object",
+            properties: {
+              path: {
+                type: "string",
+                description: "Absolute path to the project directory to share"
+              },
+              port: {
+                type: "number",
+                description: "Port the dev server runs on (optional, auto-detected based on project type)"
+              },
+              command: {
+                type: "string",
+                description: "Custom start command (optional, overrides auto-detection). Example: 'npm run dev' or 'node server.js'"
+              },
+              includeEnvFiles: {
+                type: "boolean",
+                description: "Whether to include .env files in the deployment. Default is false for security. Only set to true if the user explicitly confirms they want to include environment variables."
+              },
+              openBrowser: {
+                type: "boolean",
+                description: "Open the InFlight URL in the browser after deployment. Default is true."
+              },
+              workspaceId: {
+                type: "string",
+                description: "InFlight workspace ID to create the version in. If not provided, uses the last-used workspace or the user's first workspace."
+              }
+            },
+            required: ["path"]
+          }
+        },
+        {
+          name: "prototype_sync",
+          description: "Sync/update files in an existing prototype without recreating it. Restarts the server for changes to take effect. Use this when you've made changes to an already-shared project.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              prototypeId: {
+                type: "string",
+                description: "The prototype ID to sync files to (from a previous share)"
+              },
+              path: {
+                type: "string",
+                description: "Absolute path to the project directory"
+              },
+              includeEnvFiles: {
+                type: "boolean",
+                description: "Whether to include .env files. Default is false."
+              }
+            },
+            required: ["prototypeId", "path"]
+          }
+        },
+        {
+          name: "prototype_list",
+          description: "List all prototypes that have been shared by the current user. Shows project info and associated InFlight URLs.",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
+        },
+        {
+          name: "prototype_delete",
+          description: "Delete a shared prototype. This will stop the prototype and make it unavailable.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              prototypeId: {
+                type: "string",
+                description: "The prototype ID to delete"
+              }
+            },
+            required: ["prototypeId"]
+          }
+        },
+        {
+          name: "login",
+          description: "Log in to InFlight. If already logged in, shows current user info. Opens browser for authentication if not logged in.",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
+        },
+        {
+          name: "logout",
+          description: "Log out of InFlight. Clears stored authentication credentials.",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
+        }
+      ]
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      if (name === "share") {
+        const deployArgs = args;
+        const result = await deployPrototype(deployArgs, log);
+        const message = result.synced ? `Files synced. InFlight: ${result.inflightUrl}` : `Project shared successfully. InFlight: ${result.inflightUrl}`;
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  projectType: result.projectType,
+                  synced: result.synced ?? false,
+                  inflightUrl: result.inflightUrl,
+                  inflightVersionId: result.inflightVersionId,
+                  message
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      if (name === "prototype_sync") {
+        const { prototypeId, path: projectPath, includeEnvFiles } = args;
+        if (!isAuthenticated()) {
+          await log("Authenticating with InFlight...");
+          await authenticate(log);
+        }
+        const resolvedPath = path5.resolve(projectPath);
+        if (!fs5.existsSync(resolvedPath)) {
+          throw new Error(`Project path does not exist: ${resolvedPath}`);
+        }
+        const files = readProjectFiles(resolvedPath, "", includeEnvFiles ?? false);
+        const projectInfo = detectProjectType(resolvedPath);
+        await log(`Syncing ${Object.keys(files).length} files to prototype ${prototypeId}...`);
+        const syncResult = await syncProject(
+          prototypeId,
+          files,
+          {
+            restartServer: true,
+            startCommand: projectInfo.startCommand,
+            port: projectInfo.port
+          },
+          log
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  prototypeId,
+                  fileCount: syncResult.fileCount,
+                  message: `Synced ${syncResult.fileCount} files and restarted server.`
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      if (name === "prototype_list") {
+        if (!isAuthenticated()) {
+          await log("Authenticating with InFlight...");
+          await authenticate(log);
+        }
+        await log("Fetching prototypes...");
+        const prototypes = await listSandboxes();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  prototypes: prototypes.map((p) => ({
+                    prototypeId: p.sandboxId,
+                    projectName: p.projectName,
+                    projectType: p.projectType,
+                    status: p.status,
+                    inflightUrl: p.inflightUrl,
+                    createdAt: p.createdAt,
+                    updatedAt: p.updatedAt
+                  })),
+                  message: `Found ${prototypes.length} prototypes.`
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      if (name === "prototype_delete") {
+        const { prototypeId } = args;
+        if (!isAuthenticated()) {
+          await log("Authenticating with InFlight...");
+          await authenticate(log);
+        }
+        await log(`Deleting prototype ${prototypeId}...`);
+        await deleteSandbox(prototypeId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  prototypeId,
+                  message: `Prototype ${prototypeId} has been deleted.`
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      if (name === "login") {
+        const authData = getAuthData();
+        if (authData) {
+          const displayName2 = authData.name || authData.email || authData.userId;
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(
+                  {
+                    success: true,
+                    loggedIn: true,
+                    name: authData.name || void 0,
+                    email: authData.email || void 0,
+                    userId: authData.userId,
+                    authenticatedAt: authData.createdAt,
+                    message: `Logged in as ${displayName2}`
+                  },
+                  null,
+                  2
+                )
+              }
+            ]
+          };
+        }
+        await log("Opening browser for InFlight authentication...");
+        const newAuthData = await authenticate(log);
+        const displayName = newAuthData.name || newAuthData.email || newAuthData.userId;
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  loggedIn: true,
+                  name: newAuthData.name || void 0,
+                  email: newAuthData.email || void 0,
+                  userId: newAuthData.userId,
+                  authenticatedAt: newAuthData.createdAt,
+                  message: `Successfully logged in as ${displayName}`
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      if (name === "logout") {
+        const wasAuthenticated = isAuthenticated();
+        clearAuthData();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  message: wasAuthenticated ? "Logged out of InFlight successfully." : "Already logged out."
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Unknown tool: ${name}`
+          }
+        ],
+        isError: true
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      await log(`Error: ${errorMessage}`, "error");
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: errorMessage
+              },
+              null,
+              2
+            )
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  return server;
+}
+
+// src/index.ts
+async function main() {
+  const server = createServer2();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.on("SIGINT", async () => {
+    await server.close();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await server.close();
+    process.exit(0);
+  });
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});