@spark-apps/quickpeek 1.1.3 → 1.2.1

package/dist/web.mjs

@@ -1,4 +1,6 @@
 // src/lib/utils.ts
+import { hexToAss } from "@spark-apps/video-kit";
+import { windowsDrivePathToWsl } from "@spark-apps/video-kit";
 var LANGUAGE_NAMES = {
   ar: "Arabic",
   es: "Spanish",
@@ -17,14 +19,6 @@ function getLanguageName(lang) {
   if (!lang || lang === "en") return null;
   return LANGUAGE_NAMES[lang] || lang.toUpperCase();
 }
-function hexToASS(hex, alpha = 0) {
-  const clean = hex.replace("#", "");
-  const r = clean.slice(0, 2);
-  const g = clean.slice(2, 4);
-  const b = clean.slice(4, 6);
-  const a = alpha.toString(16).padStart(2, "0").toUpperCase();
-  return `&H${a}${b}${g}${r}`.toUpperCase();
-}
 function rgbaToHex(color) {
   if (color.startsWith("#")) return color;
   const match = color.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
@@ -66,12 +60,6 @@ var LOWERCASE_WORDS = /* @__PURE__ */ new Set([
   "under",
   "than"
 ]);
-function windowsPathToWSL(path) {
-  const driveMatch = /^([A-Z]):[/\\]/i.exec(path);
-  if (!driveMatch) return null;
-  const drive = driveMatch[1].toLowerCase();
-  return `/mnt/${drive}/${path.slice(3).replace(/\\/g, "/")}`;
-}
 function parsePartial(partial) {
   if (!partial) return {};
   const parts = partial.split("-");
@@ -87,7 +75,7 @@ function getErrorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
 function toTitleCase(text) {
-  return text.replace(/\w+/g, (word, index) => {
+  return text.replace(/\w+(?:'\w+)*/g, (word, index) => {
     if (index === 0) {
       return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
     }
@@ -102,23 +90,31 @@ function toTitleCase(text) {
 var SPARK_AI_BASE = "https://sparkbrain.app";
 var SPARK_AI_CHAT = `${SPARK_AI_BASE}/api/chat`;
 var SPARK_AI_TOKEN = `${SPARK_AI_BASE}/api/models/token`;
-var API_KEY = process.env.SPARK_AI_KEY || "";
-var cachedToken = null;
-async function getOrRefreshToken() {
+var RELAY_BASE = process.env.QUICKPEEK_API_BASE || "https://quickpeek.co";
+var RELAY_TOKEN_URL = `${RELAY_BASE}/api/cli/token`;
+var RELAY_CHAT_URL = `${RELAY_BASE}/api/cli/ai`;
+function apiKey() {
+  return process.env.SPARK_AI_KEY || "";
+}
+var cachedDirectToken = null;
+async function getOrRefreshDirectToken() {
   const now = Date.now();
-  if (cachedToken && cachedToken.expiresAt > now + 3e5) {
-    return cachedToken.token;
+  if (cachedDirectToken && cachedDirectToken.expiresAt > now + 3e5) {
+    return cachedDirectToken.token;
   }
   try {
     const response = await fetch(SPARK_AI_TOKEN, {
       method: "POST",
-      headers: { "X-Api-Key": API_KEY }
+      headers: { "X-Api-Key": apiKey() }
     });
+    if (!response.ok) {
+      throw new Error(`Token exchange failed: ${response.status} ${response.statusText}`);
+    }
     const data = await response.json();
-    if (!response.ok || !data.success || !data.token) {
-      throw new Error(data.error || `Token exchange failed: ${response.status}`);
+    if (!data.success || !data.token) {
+      throw new Error(data.error || `Token exchange failed: unexpected response`);
     }
-    cachedToken = {
+    cachedDirectToken = {
       token: data.token,
       expiresAt: data.expiresAt || now + 36e5
     };
@@ -127,77 +123,84 @@ async function getOrRefreshToken() {
     throw new Error(`Failed to get Spark AI token: ${getErrorMessage(err)}`);
   }
 }
-async function callAI(systemPrompt, userPrompt, tier = "free") {
-  if (!API_KEY) {
-    return {
-      success: false,
-      error: "AI service is not configured. Please report this issue.",
-      isAuthError: true
-    };
-  }
-  try {
-    const token = await getOrRefreshToken();
-    let lastRateLimitError = null;
-    for (let attempt = 1; attempt <= 3; attempt++) {
-      try {
-        const response = await fetch(SPARK_AI_CHAT, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${token}`
-          },
-          body: JSON.stringify({
-            messages: [
-              { role: "system", content: systemPrompt },
-              { role: "user", content: userPrompt }
-            ]
-          })
-        });
-        const data = await response.json();
-        if (!response.ok) {
-          const error = data.error || `Spark AI error: ${response.status}`;
-          if (response.status === 429 && attempt < 3) {
-            const retryAfter = response.headers.get("Retry-After");
-            const delayMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : 1e3 * Math.pow(2, attempt - 1);
-            lastRateLimitError = {
-              success: false,
-              error,
-              isRateLimit: true,
-              ...retryAfter ? { retryAfterSeconds: parseInt(retryAfter, 10) } : {}
-            };
-            await new Promise((resolve) => setTimeout(resolve, Math.min(delayMs, 3e4)));
-            continue;
-          }
-          return {
+async function executeChat(chatUrl, bearerToken, systemPrompt, userPrompt, tier) {
+  let lastRateLimitError = null;
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    try {
+      const response = await fetch(chatUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${bearerToken}`
+        },
+        body: JSON.stringify({
+          messages: [
+            { role: "system", content: systemPrompt },
+            { role: "user", content: userPrompt }
+          ]
+        })
+      });
+      let data = {};
+      const contentType = response.headers.get("content-type") ?? "";
+      if (contentType.includes("application/json")) {
+        data = await response.json();
+      }
+      if (!response.ok) {
+        const error = data.error || `Spark AI error: ${response.status} ${response.statusText}`;
+        if (response.status === 429 && attempt < 3) {
+          const retryAfter = response.headers.get("Retry-After");
+          const delayMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : 1e3 * 2 ** (attempt - 1);
+          lastRateLimitError = {
             success: false,
             error,
-            isRateLimit: response.status === 429,
-            isAuthError: response.status === 401 || response.status === 403
-          };
-        }
-        if (!data.success || !data.response) {
-          return {
-            success: false,
-            error: data.error || "No response from Spark AI"
+            isRateLimit: true,
+            ...retryAfter ? { retryAfterSeconds: parseInt(retryAfter, 10) } : {}
           };
+          await new Promise((resolve) => setTimeout(resolve, Math.min(delayMs, 3e4)));
+          continue;
         }
         return {
-          success: true,
-          content: data.response,
-          limits: {
-            used: data.limits?.used ?? 0,
-            limit: data.limits?.limit ?? 100,
-            tier,
-            ...data.limits?.resetAt ? { resetAt: data.limits.resetAt } : {}
-          }
+          success: false,
+          error,
+          isRateLimit: response.status === 429,
+          isAuthError: response.status === 401 || response.status === 403
+        };
+      }
+      if (!data.success || !data.response) {
+        return {
+          success: false,
+          error: data.error || "No response from Spark AI"
         };
-      } catch (err) {
-        if (attempt === 3) throw err;
-        const delayMs = 1e3 * Math.pow(2, attempt - 1);
-        await new Promise((resolve) => setTimeout(resolve, delayMs));
       }
+      return {
+        success: true,
+        content: data.response,
+        limits: {
+          used: data.limits?.used ?? 0,
+          limit: data.limits?.limit ?? 100,
+          tier,
+          ...data.limits?.resetAt ? { resetAt: data.limits.resetAt } : {}
+        }
+      };
+    } catch (err) {
+      if (attempt === 3) throw err;
+      const delayMs = 1e3 * 2 ** (attempt - 1);
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
     }
-    return lastRateLimitError || { success: false, error: "Request failed after retries" };
+  }
+  return lastRateLimitError || { success: false, error: "Request failed after retries" };
+}
+async function callAI(systemPrompt, userPrompt, tier = "free") {
+  if (!apiKey()) {
+    return {
+      success: false,
+      error: "AI service is not configured. Please report this issue.",
+      isAuthError: true
+    };
+  }
+  try {
+    const token = await getOrRefreshDirectToken();
+    return await executeChat(SPARK_AI_CHAT, token, systemPrompt, userPrompt, tier);
   } catch (err) {
     return { success: false, error: `Spark AI error: ${getErrorMessage(err)}` };
   }
@@ -347,14 +350,32 @@ function getActionForType(type) {
 }
 var noopTask = () => ({ succeed: () => {
 } });
-async function crawlPage(url, task = noopTask) {
+var CRAWL_CACHE_TTL_MS = 5 * 60 * 1e3;
+var CRAWL_CACHE_MAX_ENTRIES = 50;
+var crawlCache = /* @__PURE__ */ new Map();
+async function crawlPage(url, task = noopTask, storageStatePath, viewport) {
+  const cacheKey = viewport ? `${url}@${viewport.width}x${viewport.height}` : url;
+  const cached = crawlCache.get(cacheKey);
+  if (cached && Date.now() - cached.timestamp < CRAWL_CACHE_TTL_MS) {
+    task("Using cached crawl").succeed(`Found ${cached.elements.length} interactive elements (cached)`);
+    return { title: cached.title, elements: [...cached.elements], scrollable: cached.scrollable };
+  }
   const browserTask = task("Launching browser");
   const browser = await chromium.launch({ headless: true });
-  const page = await browser.newPage();
-  browserTask.succeed("Browser launched");
+  const context = await browser.newContext({
+    ...storageStatePath ? { storageState: storageStatePath } : {},
+    // Crawl at the size we will record at, or the measurements below describe
+    // a page nobody will ever see.
+    ...viewport ? { viewport } : {}
+  });
+  const page = await context.newPage();
+  browserTask.succeed(storageStatePath ? "Browser launched (signed in)" : "Browser launched");
   const crawlTask = task("Crawling page");
   await page.goto(url, { waitUntil: "networkidle", timeout: 3e4 });
   const title = await page.title();
+  const scrollable = await page.evaluate(
+    "Math.max(0, document.documentElement.scrollHeight - window.innerHeight)"
+  );
   const rawElements = await page.evaluate(`
     (() => {
       const items = [];
@@ -484,7 +505,12 @@ async function crawlPage(url, task = noopTask) {
   });
   await browser.close();
   crawlTask.succeed(`Found ${elements.length} interactive elements`);
-  return { title, elements };
+  crawlCache.set(cacheKey, { timestamp: Date.now(), title, elements: [...elements], scrollable });
+  if (crawlCache.size > CRAWL_CACHE_MAX_ENTRIES) {
+    const oldest = crawlCache.keys().next().value;
+    if (oldest !== void 0) crawlCache.delete(oldest);
+  }
+  return { title, elements, scrollable };
 }
 
 // src/lib/plan-validation.ts
@@ -718,6 +744,80 @@ function restorePreservedValues(step, preserved, indices) {
   return { uploadIdx, mediaIdx };
 }
 
+// src/lib/plan-file.ts
+var MAX_HANDOFF_URL_CHARS = 32e3;
+function serializePlan(plan) {
+  return `${JSON.stringify(plan, null, 2)}
+`;
+}
+function parsePlanText(text) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (e) {
+    return { ok: false, error: `Not valid JSON: ${e instanceof Error ? e.message : String(e)}` };
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return { ok: false, error: "A plan must be a JSON object." };
+  }
+  const candidate = raw;
+  if (typeof candidate.url !== "string" || !candidate.url.trim()) {
+    return { ok: false, error: "A plan needs a `url` to record." };
+  }
+  if (!Array.isArray(candidate.steps) || candidate.steps.length === 0) {
+    return { ok: false, error: "A plan needs at least one step." };
+  }
+  const steps = [];
+  for (const [index, step] of candidate.steps.entries()) {
+    if (!step || typeof step !== "object" || Array.isArray(step)) {
+      return { ok: false, error: `Step ${index + 1} is not an object.` };
+    }
+    const typed = step;
+    if (typeof typed.action !== "string" || !typed.action.trim()) {
+      return { ok: false, error: `Step ${index + 1} has no action.` };
+    }
+    const failure = validateStep(typed);
+    if (failure) return { ok: false, error: `Step ${index + 1}: ${failure}` };
+    steps.push({ ...typed, id: typed.id ?? index + 1 });
+  }
+  return {
+    ok: true,
+    plan: {
+      url: candidate.url,
+      title: candidate.title ?? "",
+      description: candidate.description ?? "",
+      ...candidate.lang ? { lang: candidate.lang } : {},
+      steps
+    }
+  };
+}
+function toBase64Url(text) {
+  const bytes = new TextEncoder().encode(text);
+  const binary = Array.from(bytes, (b) => String.fromCharCode(b)).join("");
+  const base64 = typeof btoa === "function" ? btoa(binary) : Buffer.from(text, "utf8").toString("base64");
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromBase64Url(encoded) {
+  const base64 = encoded.replace(/-/g, "+").replace(/_/g, "/");
+  if (typeof atob !== "function") return Buffer.from(base64, "base64").toString("utf8");
+  const binary = atob(base64);
+  return new TextDecoder().decode(Uint8Array.from(binary, (c) => c.charCodeAt(0)));
+}
+function encodePlan(plan) {
+  return toBase64Url(serializePlan(plan));
+}
+function decodePlan(encoded) {
+  try {
+    return parsePlanText(fromBase64Url(encoded));
+  } catch {
+    return { ok: false, error: "That link is damaged \u2014 the plan could not be decoded." };
+  }
+}
+function planEditorUrl(baseUrl, plan) {
+  const url = `${baseUrl.replace(/\/$/, "")}/edit#plan=${encodePlan(plan)}`;
+  return url.length <= MAX_HANDOFF_URL_CHARS ? url : null;
+}
+
 // src/lib/prompts.ts
 function buildSystemPrompt(maxSteps) {
   let scope;
@@ -771,7 +871,8 @@ EXAMPLES:
 \u2022 File upload: "target": "input[type=\\"file\\"]"
 \u2022 Slider: "target": "input[type=\\"range\\"]"`;
 }
-function buildUserPrompt(url, title, elements, langName, description, maxSteps) {
+var MIN_USEFUL_SCROLL_PX = 200;
+function buildUserPrompt(url, title, elements, langName, description, maxSteps, scrollable) {
   const lang = langName ? `
 Language: Write ALL captions in ${langName}.` : "";
   const purpose = description ? `
@@ -809,8 +910,13 @@ ${selectables.map((e) => `\u2022 "${e.text}" \u2192 ${e.selector}`).join("\n")}`
 ${checkables.map((e) => `\u2022 "${e.text}" \u2192 ${e.selector}`).join("\n")}`);
   }
   const elementSummary = elementDict.length > 0 ? elementDict.join("\n\n") : "(no interactive elements found)";
+  const cannotScroll = scrollable !== void 0 && scrollable < MIN_USEFUL_SCROLL_PX;
+  const scrolling = cannotScroll ? `
+
+SCROLLING: this page has only ${scrollable}px of scroll travel at the recording size, so it does not scroll.` : "";
+  const scrollRule = cannotScroll ? "\n\u2022 NEVER use the scroll action: this page does not scroll, so the video would freeze. Use wait and click steps only" : "";
   return `URL: ${url}
-Title: ${title}${purpose}
+Title: ${title}${purpose}${scrolling}
 
 AVAILABLE ELEMENTS (grouped by action):
 ${elementSummary}
@@ -820,7 +926,7 @@ REQUIREMENTS:
 \u2022 Complete ONE user journey: input \u2192 process \u2192 output
 \u2022 For CLICK: use simplified text target like "extract frame" or "download"
 \u2022 For UPLOAD/DRAG/TYPE: use the CSS selector shown above
-\u2022 For buttons that appear after actions: use partial text like "extract" or "download"${lang}
+\u2022 For buttons that appear after actions: use partial text like "extract" or "download"${scrollRule}${lang}
 
 Return JSON:
 {
@@ -844,101 +950,36 @@ TARGET SYNTAX:
 \u2022 Text inputs: Use selector from list above`;
 }
 
-// src/lib/voices.ts
-var LANGUAGE_VOICES = {
-  en: "en-GB-SoniaNeural",
-  ar: "ar-LB-LaylaNeural",
-  es: "es-ES-ElviraNeural",
-  fr: "fr-FR-DeniseNeural",
-  de: "de-DE-KatjaNeural",
-  it: "it-IT-ElsaNeural",
-  pt: "pt-BR-FranciscaNeural",
-  ru: "ru-RU-SvetlanaNeural",
-  zh: "zh-CN-XiaoxiaoNeural",
-  ja: "ja-JP-NanamiNeural",
-  ko: "ko-KR-SunHiNeural",
-  hi: "hi-IN-SwaraNeural",
-  tr: "tr-TR-EmelNeural",
-  nl: "nl-NL-ColetteNeural",
-  pl: "pl-PL-AgnieszkaNeural",
-  sv: "sv-SE-SofieNeural",
-  he: "he-IL-HilaNeural",
-  th: "th-TH-PremwadeeNeural",
-  vi: "vi-VN-HoaiMyNeural",
-  id: "id-ID-GadisNeural",
-  ms: "ms-MY-YasminNeural",
-  fil: "fil-PH-BlessicaNeural",
-  uk: "uk-UA-PolinaNeural",
-  cs: "cs-CZ-VlastaNeural",
-  el: "el-GR-AthinaNeural",
-  ro: "ro-RO-AlinaNeural",
-  hu: "hu-HU-NoemiNeural",
-  da: "da-DK-ChristelNeural",
-  fi: "fi-FI-NooraNeural",
-  no: "nb-NO-PernilleNeural",
-  sk: "sk-SK-ViktoriaNeural",
-  bg: "bg-BG-KalinaNeural",
-  hr: "hr-HR-GabrijelaNeural",
-  sl: "sl-SI-PetraNeural",
-  et: "et-EE-AnuNeural",
-  lv: "lv-LV-EveritaNeural",
-  lt: "lt-LT-OnaNeural",
-  bn: "bn-IN-TanishaaNeural",
-  ta: "ta-IN-PallaviNeural",
-  te: "te-IN-ShrutiNeural",
-  mr: "mr-IN-AarohiNeural",
-  gu: "gu-IN-DhwaniNeural",
-  kn: "kn-IN-SapnaNeural",
-  ml: "ml-IN-SobhanaNeural",
-  ur: "ur-PK-UzmaNeural",
-  fa: "fa-IR-DilaraNeural",
-  sw: "sw-KE-ZuriNeural",
-  af: "af-ZA-AdriNeural",
-  ca: "ca-ES-JoanaNeural",
-  cy: "cy-GB-NiaNeural",
-  ga: "ga-IE-OrlaNeural",
-  mt: "mt-MT-GraceNeural",
-  is: "is-IS-GudrunNeural",
-  mk: "mk-MK-MarijaNeural",
-  sr: "sr-RS-SophieNeural",
-  bs: "bs-BA-VesnaNeural",
-  sq: "sq-AL-AnilaNeural",
-  am: "am-ET-MekdesNeural",
-  az: "az-AZ-BabekNeural",
-  ka: "ka-GE-EkaNeural",
-  kk: "kk-KZ-AigulNeural",
-  mn: "mn-MN-YesUINeural",
-  ne: "ne-NP-HemkalaNeural",
-  ps: "ps-AF-LatifaNeural",
-  si: "si-LK-ThiliniNeural",
-  so: "so-SO-UbaxNeural",
-  zu: "zu-ZA-ThandoNeural"
-};
-
 // src/lib/SparkStripe-feature-gating.ts
 var APP_ID = process.env.SPARK_APP_ID ?? "quickpeek";
 var BASE = "https://sparkstripe.com";
 var TIERS = {
-  "price_1TADnPEf9opkuWid9NtqOYON": "pro",
-  "price_1TADnPEf9opkuWidgbvvX9ma": "pro",
-  "price_1TADm7Ef9opkuWid3I9tquIB": "pro",
-  "price_1TADm8Ef9opkuWid1RSA2wCa": "pro",
-  "price_1TCREmEf9opkuWidvhuqzqDM": "pro",
-  "price_1TCREmEf9opkuWidacf1tiC7": "pro"
+  price_1TADnPEf9opkuWid9NtqOYON: "pro",
+  price_1TADnPEf9opkuWidgbvvX9ma: "pro",
+  price_1TADm7Ef9opkuWid3I9tquIB: "pro",
+  price_1TADm8Ef9opkuWid1RSA2wCa: "pro",
+  price_1TCREmEf9opkuWidvhuqzqDM: "pro",
+  price_1TCREmEf9opkuWidacf1tiC7: "pro"
 };
 var RANK = {
-  "free": 0,
-  "pro": 1
+  free: 0,
+  pro: 1
+};
+var FEATURES = {
+  free: [],
+  pro: [
+    "Everything in Free",
+    "No watermark",
+    "Full video composition (voiceover + captions + music + transitions)",
+    "Unlimited videos",
+    "Priority support"
+  ]
 };
-var FEATURES = { "free": [], "pro": [
-  "Everything in Free",
-  "No watermark",
-  "Full video composition (voiceover + captions + music + transitions)",
-  "Unlimited videos",
-  "Priority support"
-] };
 async function _fetch(email, init) {
-  const r = await fetch(`${BASE}/api/public/subscription/status-public?email=${encodeURIComponent(email)}&app_id=${APP_ID}`, init);
+  const r = await fetch(
+    `${BASE}/api/public/subscription/status-public?email=${encodeURIComponent(email)}&app_id=${APP_ID}`,
+    init
+  );
   if (!r.ok) throw new Error(`spark-stripe: ${r.status}`);
   return r.json();
 }
@@ -981,6 +1022,9 @@ function pricingUrl(opts) {
   if (opts?.returnUrl) u.searchParams.set("return_url", opts.returnUrl);
   return u.toString();
 }
+
+// src/lib/voices.ts
+import { WIDE_VOICES } from "@spark-apps/video-kit";
 export {
   ACTIONS_REQUIRING_TARGET,
   EXCLUDED_LINK_PATTERNS,
@@ -988,13 +1032,16 @@ export {
   FIX_PLAN_SYSTEM_PROMPT,
   INTERACTIVE_SELECTORS,
   INVALID_TARGETS,
-  LANGUAGE_VOICES,
+  WIDE_VOICES as LANGUAGE_VOICES,
+  MAX_HANDOFF_URL_CHARS,
   REFINE_PLAN_SYSTEM_PROMPT,
   buildSystemPrompt,
   buildUserPrompt,
   callAI,
   collectPreservedValues,
   crawlPage,
+  decodePlan,
+  encodePlan,
   filterValidSteps,
   getErrorMessage,
   getLanguageName,
@@ -1004,7 +1051,7 @@ export {
   getTierByEmail,
   hasAccess,
   hasTrialRemaining,
-  hexToASS,
+  hexToAss as hexToASS,
   isCanceling,
   isExcludedLink,
   isInvalidTarget,
@@ -1014,12 +1061,15 @@ export {
   normalizeUrl,
   parseAIPlanResponse,
   parsePartial,
+  parsePlanText,
+  planEditorUrl,
   pricingUrl,
   restorePreservedValues,
   rgbaToHex,
+  serializePlan,
   shouldSkipLink,
   showPaywall,
   toTitleCase,
   validateStep,
-  windowsPathToWSL
+  windowsDrivePathToWsl as windowsPathToWSL
 };

package/mcp.mjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+// QuickPeek MCP server — demo-video generation over stdio.
+//
+// .mjs, not .js: this package is CommonJS (the CLI bundle is CJS), so a
+// plain .js here would be parsed as CommonJS and its imports would fail.
+//
+// A thin bootstrap: transport wiring, the protocol-stdout proxy, and
+// dispatch. Tool schemas and handlers live in src/mcp/ (bundled by tsup
+// into dist/mcp-tools.mjs), calling the command functions directly rather
+// than shelling out to the `qp` CLI.
+//
+// Deliberately NO delete tools: outputs are new files and the server never
+// removes anything a user recorded.
+
+import { readFileSync } from 'node:fs';
+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 { setElicit, TOOL_HANDLERS, TOOLS } from './dist/mcp-tools.mjs';
+
+const pkg = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8'));
+
+// Captured once, before anything ever patches process.stdout.write
+// (withSilencedStdout in dist/mcp-tools.mjs mutates it during tool calls).
+const REAL_STDOUT_WRITE = process.stdout.write.bind(process.stdout);
+
+// The transport resolves `.write` dynamically off whatever stdout object it
+// is handed — the SAME property withSilencedStdout mutates. Recording a
+// demo takes minutes and prints throughout, so a silenced call would
+// otherwise swallow or misdirect unrelated protocol responses. This proxy
+// always uses the pristine write captured above.
+const protocolStdout = new Proxy(process.stdout, {
+  get(target, prop, receiver) {
+    if (prop === 'write') return REAL_STDOUT_WRITE;
+    const value = Reflect.get(target, prop, receiver);
+    return typeof value === 'function' ? value.bind(target) : value;
+  },
+});
+
+const server = new Server(
+  { name: 'quickpeek', version: pkg.version },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+function toErrorResult(e) {
+  return {
+    content: [{ type: 'text', text: e?.message ?? String(e) }],
+    isError: true,
+  };
+}
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  const handler = TOOL_HANDLERS[name];
+  if (!handler) return toErrorResult(new Error(`Unknown tool: ${name}`));
+  try {
+    return await handler(args ?? {});
+  } catch (e) {
+    // Never crash the server on a tool failure — surface it as a tool error.
+    return toErrorResult(e);
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport(process.stdin, protocolStdout);
+  await server.connect(transport);
+
+  // Elicitation is optional in MCP. The capability is checked per call, not
+  // here: the client only declares it in `initialize`, which arrives after
+  // connect() resolves. null means "cannot prompt" and start_auth then falls
+  // back to a follow-up finish_auth call.
+  setElicit(async (message) => {
+    if (!server.getClientCapabilities()?.elicitation) return null;
+    const result = await server.elicitInput({
+      message,
+      requestedSchema: {
+        type: 'object',
+        properties: {
+          signedIn: {
+            type: 'boolean',
+            title: 'Signed in?',
+            description: 'Confirm once you have finished signing in, so the session can be saved.',
+          },
+        },
+        required: ['signedIn'],
+      },
+    });
+    return result.action === 'accept' && result.content?.signedIn === true;
+  });
+}
+
+main().catch((e) => {
+  console.error(`quickpeek-mcp failed to start: ${e?.message ?? e}`);
+  process.exit(1);
+});