@seldonframe/mcp 1.10.0 → 1.10.1

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@seldonframe/mcp",
-  "version": "1.10.0",
+  "version": "1.10.1",
+  "description": "MCP server for SeldonFrame — AI-native Business OS platform. v1.10.1: HOTFIX — upload_workspace_image now accepts image_url + local_file_path, eliminating the agent-side base64 round-trip that v1.10.0 forced. WHY: v1.10.0's image_data_b64-only design made the agent base64-encode bytes into the JSON tool argument; the encoded string had to fit in the agent's tool-input token budget (~16 KB base64 ≈ ~12 KB raw). A 100 KB logo forced the agent into manual resize loops (verified 2026-05-05 smoke test: 7m 31s for one Cloudinary URL upload — 4 resize iterations before bytes fit). WHAT SHIPS: (1) image_url body field — SF backend fetches the URL directly via fetch + streamed read with running byte counter (5 MB cap, 5s timeout). SSRF guards: HTTPS-only, loopback / RFC1918 private / link-local IPv4 (incl. 169.254.169.254 cloud metadata) / IPv6 ::1 rejected. file_name + content_type auto-derived from URL path extension; falls back to response Content-Type header for extensionless URLs. (2) local_file_path MCP-client branch — reads the file in the npm-package process (which runs on the operator's machine, no agent token budget involved), base64-encodes for transport to the SF backend. file_name + content_type auto-derived from path extension. (3) image_data_b64 unchanged — kept as a backward-compatible fallback for callers that already have bytes in hand. (4) Tool descriptor explicitly ranks the three sources (image_url > local_file_path > image_data_b64) so the agent picks correctly. (5) 18 new unit tests covering URL validation (HTTPS-only enforcement, loopback / RFC1918 / link-local rejection, public IPv4 acceptance, malformed URL rejection), content-type derivation from URL extension (handles query strings), and file-name basename extraction. Test count: 2385 (was 2367). Time-to-upload-a-logo: ~7 min → ~3 sec (>99% reduction). NO migrations, NO new env vars, NO new dependencies. Backward compatible.",
   "description": "MCP server for SeldonFrame — AI-native Business OS platform. v1.10.0: TIER 2 CUSTOMIZE TOOLS — three new operator-driven block-customization tools that respect the thin-harness/fat-skill principle (server only assembles + persists; the IDE agent's LLM does all creative work, so quality compounds as models improve with zero MCP changes). (1) regenerate_block({ workspace_id, block_name, new_instructions? }) — bundles current_props + workspace_summary (business name, industry, services, voice from organizations.soul) + brain_patterns (cross-workspace patterns for this vertical) + customization_history + the operator's new_instructions, returns next_step prose telling the agent: fetch SKILL.md, generate new props, call persist_block with customization: { prompt: <new_instructions> }. Handles first_generation (block never persisted) AND regenerate (iterate from current_props) cases with the same flow. New endpoint GET /api/v1/workspace/v2/blocks/[name]/regenerate. (2) reorder_landing_sections({ workspace_id, new_order: string[] }) — purely mechanical reorder of Blueprint.landing.sections; new_order is the full ordered array of section types ([\"hero\", \"services-grid\", \"about\", \"mid-cta\", \"faq\"]); validates the multiset matches current sections (no add/remove); rejects empty new_order, duplicates, missing types, unknown types. New endpoint POST /api/v1/workspace/v2/landing/reorder. Operator says \"move FAQ to bottom\" → agent computes new_order → server reorders + re-renders. (3) upload_workspace_image({ workspace_id, slot, file_name, content_type, image_data_b64 }) — uploads a base64-encoded image to Vercel Blob and applies the URL to one of two slots: 'logo' (organizations.theme.logoUrl, surfaces in header/footer/og-image) or 'hero_background' (Blueprint.landing.sections[hero].imageUrl + landing re-render). 5 MB max, allowed types image/png|jpeg|webp|svg+xml|gif. Sanitized blob path with random uuid suffix so re-uploads don't overwrite previous URLs. New endpoint POST /api/v1/workspace/v2/images. WHAT SHIPS BESIDES THE TOOLS: 22 new unit tests (6 regenerate context assembly, 6 reorder validation, 11 upload validation + path sanitization). Pure-function-first design — DB integration left for the v1.10+ harness; what's tested here is the security-relevant + correctness-relevant logic that lives outside any DB. Test count: 2366 (was 2344; +22). NO migrations, NO env vars, NO new dependencies (Vercel Blob already used for portal documents). Backend redeploy auto-triggers via main-branch push. v1.11+ candidates: customize_theme advanced presets (palette generation from logo / industry-aware mood), additional image slots (og_image, gallery), section delete/insert (currently reorder is the only structural change supported).",
   "description": "MCP server for SeldonFrame — AI-native Business OS platform. v1.9.0: BEHAVIORAL CONTRACT TESTS — kills the handler-execution-state-drift bug class structurally. Three bugs in 7 days hit the same shape: a server-side function `throw new Error()`s for an edge user/workspace state (no users row, no Stripe customer, free tier, empty form_fields), and the throw cascades through the SSR boundary as 'This page couldn't load.' WHAT SHIPS: (1) static analysis test (tests/unit/contract-no-uncaught-throws.spec.ts) that scans designated directories — lib/billing/**, lib/auth/**, lib/page-blocks/persist.ts, app/(dashboard)/** — for `throw new Error()` patterns. Every throw must EITHER be wrapped in try/catch OR carry a `// contract:throw-ok: <reason>` annotation. CI fails if any throw is unannotated. (2) 34 existing throws audited and annotated with semantic reasons (Stripe API errors, programmer-error sentinels, deployment config, form-submit error UX, etc.). Going forward, every NEW throw added to scoped directories must be annotated explicitly. (3) Behavioral runtime test (tests/unit/contract-booking-form-fields.spec.ts) for the v1.4.2 bug: 5 tests asserting mergeBookingFormFields always prepends standard fullName + email regardless of LLM input — preserves order, dedupes redundant LLM-supplied standards, sets required=true. mergeBookingFormFields exported from lib/page-blocks/persist.ts for testability. (4) docs/CONTRACTS.md documenting the rule, annotation pattern, scoped directories, when NOT to throw, how to add a new contract test. The MCP package itself didn't change in v1.9.0 — version bumps coupled with backend so they redeploy together. Test count: 2344 (was 2338; +1 static check + 5 booking contract tests). v1.10 candidate: integration test harness so we can write contract tests for the v1.7.3 + v1.8.1 fixes (currently documented in CONTRACTS.md but not yet runtime-asserted).",
   "description": "MCP server for SeldonFrame — AI-native Business OS platform. v1.8.1: HOTFIX for /settings/billing crashing when free-tier users click 'Manage subscription'. createBillingPortalSessionAction threw 'No Stripe customer is associated with this account' when the user had never completed a Stripe checkout — the throw cascaded through the SSR boundary and produced 'This page couldn't load — A server error occurred'. Two-layer fix: (1) UI conditionally hides 'Manage subscription' button for free tier, shows 'Upgrade' link instead. Free-tier operators see the right CTA. (2) The action gracefully redirects to /settings/billing?upgrade=needed instead of throwing — defense in depth in case a stale page state, direct form POST, or admin-token edge case still hits the action with no customer. New banner on /settings/billing surfaces the redirect reason ('No active subscription to manage yet — upgrade to manage'). No code changes to the MCP package itself; version bump is coupled with the backend redeploy.",

package/src/tools.js

@@ -20,6 +20,13 @@ import {
 // drafts assumed VERSION leaked in via client.js's transitive import;
 // it doesn't. Direct import = no runtime "VERSION is not defined".
 import { FIRST_CALL_BANNER, VERSION } from "./welcome.js";
+// v1.10.1 — upload_workspace_image local_file_path branch reads the file
+// directly in the MCP-client process (which runs on the operator's
+// machine via the npm package). Reading + base64-encoding here means
+// the agent's tool-call body stays small (just a path string), bypassing
+// the agent token budget that v1.10.0's image_data_b64 path was bound by.
+import { readFileSync } from "node:fs";
+import path from "node:path";
 
 const str = (description, extra = {}) => ({ type: "string", description, ...extra });
 const obj = (properties, required = []) => ({
@@ -2749,9 +2756,12 @@ export const TOOLS = [
     description:
       "Upload an image to a workspace and apply it to one of two slots: 'logo' (replaces organizations.theme.logoUrl, surfaces in header / footer / og-image / favicon) or 'hero_background' (replaces the hero section's background image and re-renders the landing page). " +
       "Use when the operator says 'use this as my logo', 'replace the hero image with this photo', 'change the header logo'. " +
-      "Pass the image bytes as base64 in `image_data_b64`. The MCP server forwards them to Vercel Blob; SSL + CDN are auto-provisioned. Max 5 MB; allowed types: image/png, image/jpeg, image/webp, image/svg+xml, image/gif. " +
+      "PICK ONE source — the others are mutually exclusive: " +
+      "(a) `image_url` (PREFERRED, v1.10.1+) — public HTTPS URL to the image. The SF backend fetches it directly. Best path for Cloudinary, Unsplash, S3, or any image already on the web. file_name + content_type are auto-derived from the URL — you don't need to pass them. " +
+      "(b) `local_file_path` (v1.10.1+) — absolute path on the operator's machine. The MCP server (running locally) reads the file and forwards bytes to the backend. Best path for files on the operator's desktop. file_name + content_type derived from the path. " +
+      "(c) `image_data_b64` (legacy v1.10.0) — image bytes base64-encoded. Use only when you've generated bytes yourself (e.g. dynamic image gen) and there's no URL or path. Be aware: the encoded string consumes your tool-call token budget; for files >~12 KB raw, prefer (a) or (b). " +
+      "Max 5 MB across all paths. Allowed types: image/png, image/jpeg, image/webp, image/svg+xml, image/gif. " +
       "Returns the public Blob URL on success; that URL is now live on the workspace's public surface within seconds. " +
-      "If the operator gave you a local file path, read it as bytes and base64-encode it before calling this tool. If they gave you a URL, fetch it first then re-upload (we re-host so the asset is on our CDN, not theirs). " +
       "Antifragile design: server only validates file shape + applies URL to the right column. Your LLM picks which slot ('they said logo, that maps to slot=logo'). As you get better at intent-mapping, the harness doesn't change.",
     inputSchema: obj(
       {
@@ -2759,28 +2769,108 @@ export const TOOLS = [
         slot: str(
           "Image slot: 'logo' (workspace logo, used in header/footer/og-image) or 'hero_background' (hero section background image). Other slots may be added in future versions.",
         ),
-        file_name: str(
-          "Original filename (for the blob path). Sanitized server-side — special chars stripped, path traversal blocked.",
+        image_url: str(
+          "Public HTTPS URL to the image. PREFERRED source. SF backend fetches directly (no base64 round-trip). file_name + content_type auto-derived. https:// only; loopback / private / link-local IPs rejected.",
         ),
-        content_type: str(
-          "MIME type. Must be one of: image/png, image/jpeg, image/webp, image/svg+xml, image/gif.",
+        local_file_path: str(
+          "Absolute path to a file on the operator's machine (the MCP server runs there). MCP reads the file and forwards bytes to the backend. file_name + content_type auto-derived from the path. Use when the operator gives you a local file rather than a URL.",
         ),
         image_data_b64: str(
-          "Image bytes, base64-encoded. Max 5 MB after decoding.",
+          "Image bytes, base64-encoded. LEGACY path — prefer image_url or local_file_path because base64 consumes your tool-call token budget. Max 5 MB after decoding.",
+        ),
+        file_name: str(
+          "Optional filename (auto-derived from image_url or local_file_path). REQUIRED with image_data_b64.",
+        ),
+        content_type: str(
+          "Optional MIME type (auto-derived from image_url or local_file_path extension). REQUIRED with image_data_b64. Must be one of: image/png, image/jpeg, image/webp, image/svg+xml, image/gif.",
         ),
       },
-      ["workspace_id", "slot", "file_name", "content_type", "image_data_b64"],
+      ["workspace_id", "slot"],
     ),
     handler: async (args) => {
       const ws = args.workspace_id;
+
+      // Resolve to ONE source. Reject ambiguous + missing input early so
+      // the agent gets a clean error rather than a server-side 400.
+      const sourceCount =
+        (args.image_url ? 1 : 0) +
+        (args.local_file_path ? 1 : 0) +
+        (args.image_data_b64 ? 1 : 0);
+      if (sourceCount === 0) {
+        throw new Error(
+          "upload_workspace_image: provide ONE of image_url, local_file_path, or image_data_b64.",
+        );
+      }
+      if (sourceCount > 1) {
+        throw new Error(
+          "upload_workspace_image: provide ONE of image_url, local_file_path, or image_data_b64 — not multiple.",
+        );
+      }
+
+      const body = {
+        workspace_id: ws,
+        slot: args.slot,
+      };
+
+      if (args.image_url) {
+        body.image_url = args.image_url;
+        if (args.file_name) body.file_name = args.file_name;
+        if (args.content_type) body.content_type = args.content_type;
+      } else if (args.local_file_path) {
+        // Read the file in the MCP-client process. Path is absolute (per
+        // the schema). Reject obvious dir-traversal — readFileSync would
+        // succeed on any readable file but operators expect file paths,
+        // not directories.
+        const filePath = args.local_file_path;
+        if (!path.isAbsolute(filePath)) {
+          throw new Error(
+            `upload_workspace_image: local_file_path must be absolute. Got: ${filePath}`,
+          );
+        }
+        let buf;
+        try {
+          buf = readFileSync(filePath);
+        } catch (err) {
+          throw new Error(
+            `upload_workspace_image: failed to read local_file_path "${filePath}" — ${err?.message ?? err}`,
+          );
+        }
+        // Derive file_name + content_type from the path extension, mirroring
+        // the server-side image_url logic so the two paths feel identical
+        // to the operator.
+        const baseName = path.basename(filePath);
+        const ext = path.extname(filePath).toLowerCase().replace(/^\./, "");
+        const extToContentType = {
+          png: "image/png",
+          jpg: "image/jpeg",
+          jpeg: "image/jpeg",
+          gif: "image/gif",
+          webp: "image/webp",
+          svg: "image/svg+xml",
+        };
+        const derivedContentType = extToContentType[ext] ?? null;
+        body.image_data_b64 = buf.toString("base64");
+        body.file_name = args.file_name || baseName;
+        body.content_type = args.content_type || derivedContentType || "";
+        if (!body.content_type) {
+          throw new Error(
+            `upload_workspace_image: could not infer content_type from extension "${ext}" — pass content_type explicitly. Allowed: image/png, image/jpeg, image/webp, image/svg+xml, image/gif.`,
+          );
+        }
+      } else {
+        // image_data_b64 — caller supplied bytes directly.
+        body.image_data_b64 = args.image_data_b64;
+        if (!args.file_name || !args.content_type) {
+          throw new Error(
+            "upload_workspace_image: file_name and content_type are required with image_data_b64. (image_url and local_file_path auto-derive them.)",
+          );
+        }
+        body.file_name = args.file_name;
+        body.content_type = args.content_type;
+      }
+
       const result = await api("POST", "/workspace/v2/images", {
-        body: {
-          workspace_id: ws,
-          slot: args.slot,
-          file_name: args.file_name,
-          content_type: args.content_type,
-          image_data_b64: args.image_data_b64,
-        },
+        body,
         workspace_id: ws,
       });
       return result;

package/src/welcome.js

@@ -8,7 +8,7 @@
 // stripped. `create_full_workspace` is the only workspace-creation
 // path mentioned anywhere in this briefing.
 
-export const VERSION = "1.10.0";
+export const VERSION = "1.10.1";
 
 export const WELCOME_MARKDOWN = `# SeldonFrame — create a real Business OS in one conversation
 
@@ -194,10 +194,15 @@ further natural-language requests ("change the headline to …",
   sections without changing content. Pass the full ordered array of
   section types; multiset must equal current. For content edits use
   update_landing_section; for regeneration use regenerate_block.
-- **\`upload_workspace_image\`** (v1.10+) — upload a base64-encoded
-  image to slot=logo (organizations.theme.logoUrl) or
-  slot=hero_background (Blueprint.landing hero imageUrl + landing
-  re-render). 5 MB max, image/* MIME types. Vercel Blob auto-CDN.
+- **\`upload_workspace_image\`** (v1.10+, fast path in v1.10.1+) — set
+  the workspace logo (slot=logo → organizations.theme.logoUrl) or hero
+  background (slot=hero_background → Blueprint.landing hero imageUrl
+  + landing re-render). PREFERRED: pass \`image_url\` (HTTPS — server
+  fetches directly, no base64) or \`local_file_path\` (absolute path —
+  MCP reads the file). Auto-derives file_name + content_type. Legacy:
+  \`image_data_b64\` for caller-generated bytes, but base64 consumes
+  your tool-call token budget — avoid for files >~12 KB raw. 5 MB max,
+  image/png|jpeg|webp|svg+xml|gif. Vercel Blob auto-CDN.
 - **\`read_brain_path\`** / **\`list_brain_dir\`** — read the workspace's
   layer-1 brain (notes about THIS workspace's customers, voice, pipeline
   patterns). Use BEFORE generating blocks; reads tick the note's \`uses\`
@@ -257,4 +262,4 @@ admin dashboard. Pre-fills their email automatically.
 <https://seldonframe.com> · **Discord:** <https://discord.gg/sbVUu976NW>
 `;
 
-export const FIRST_CALL_BANNER = `🚀 SeldonFrame v1.10.0 is connected. PREFERRED workspace creation: create_workspace_v2 → IN PARALLEL for all 7 recommended_blocks (hero, services, about, faq, cta, booking, intake): get_block_skill + persist_block → complete_workspace_v2 → finalize_workspace({ workspace_id, email }). The v2 flow puts YOUR LLM in charge of every operator-facing surface using one SKILL.md per block. Each block's prop schema is server-validated. Run blocks in PARALLEL (Promise.all) — sequential takes 60+ seconds. v1.10+ TIER 2 CUSTOMIZE TOOLS: regenerate_block (re-do one block with operator instructions; thin-harness — server bundles context, your LLM generates), reorder_landing_sections (purely mechanical reorder by section type), upload_workspace_image (base64 image → Vercel Blob → applied to slot=logo or slot=hero_background). Every URL is real. NEVER create local files. Skipping finalize_workspace leaves the operator with no admin login.`;
+export const FIRST_CALL_BANNER = `🚀 SeldonFrame v1.10.1 is connected. PREFERRED workspace creation: create_workspace_v2 → IN PARALLEL for all 7 recommended_blocks (hero, services, about, faq, cta, booking, intake): get_block_skill + persist_block → complete_workspace_v2 → finalize_workspace({ workspace_id, email }). The v2 flow puts YOUR LLM in charge of every operator-facing surface using one SKILL.md per block. Each block's prop schema is server-validated. Run blocks in PARALLEL (Promise.all) — sequential takes 60+ seconds. v1.10+ TIER 2 CUSTOMIZE TOOLS: regenerate_block (re-do one block with operator instructions; thin-harness — server bundles context, your LLM generates), reorder_landing_sections (purely mechanical reorder by section type), upload_workspace_image (set logo/hero_background; v1.10.1+ accepts image_url or local_file_path — DON'T base64 unless you have to, the encoded string eats your tool-call token budget). Every URL is real. NEVER create local files. Skipping finalize_workspace leaves the operator with no admin login.`;