@nooticr/mcp 1.26.75 → 1.26.77

package/dist/auth.js

@@ -225,17 +225,35 @@ export function createManagementTokenProvider(auth) {
 /**
  * Builds a TokenProvider for one caller's own API key — the headless path
  * through HTTP mode, where the bearer the client presented *is* the nooticr
- * credential. Deliberately not `createHttpTokenProvider`: that one falls back
- * to the operator's environment and credentials file, which would answer one
- * tenant's call with another's account.
+ * credential. Never the operator's environment or credentials file, which would
+ * answer one tenant's call with another's account.
  */
 export function createApiKeyTokenProvider(apiKey) {
     return { getAccessToken: async () => apiKey };
 }
-/** Builds a TokenProvider for HTTP mode: env > api key > file > per-session tokens. */
-export function createHttpTokenProvider(auth, session) {
+/**
+ * Builds a TokenProvider for one OAuth session in HTTP mode: that session's
+ * nooticr tokens and nothing else. The environment and the credentials file
+ * belong to whoever runs the server; resolving them here answered every
+ * signed-in user as the operator. A refresh updates the session in place, so
+ * the next request from the same login carries the new token, and nothing is
+ * written to the operator's credentials file.
+ */
+export function createSessionTokenProvider(baseUrl, session) {
     return {
-        getAccessToken: async () => auth.getAccessToken(session),
-        onUnauthorized: async () => auth.onUnauthorized(session),
+        getAccessToken: async () => session.nooticrAccessToken || undefined,
+        onUnauthorized: async () => {
+            if (!session.nooticrRefreshToken)
+                return false;
+            try {
+                const next = await NooticrClient.refreshSession(baseUrl, session.nooticrRefreshToken);
+                session.nooticrAccessToken = next.accessToken;
+                session.nooticrRefreshToken = next.refreshToken ?? session.nooticrRefreshToken;
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
     };
 }

package/dist/index.js

@@ -14,7 +14,7 @@ import { randomUUID } from "node:crypto";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { getBaseUrl, getPublicUrl, getPort, getCredentialsFile, getTransportMode, DEFAULT_PORT, } from "./config.js";
-import { AuthManager, NooticrAuthError, createApiKeyTokenProvider, createHttpTokenProvider, createManagementTokenProvider, createStdioTokenProvider, } from "./auth.js";
+import { AuthManager, NooticrAuthError, createApiKeyTokenProvider, createSessionTokenProvider, createManagementTokenProvider, createStdioTokenProvider, } from "./auth.js";
 import { forwardedHeaders, forwardedSession, looksLikeApiKey } from "./shared/api-key.js";
 import { NooticrClient, NooticrError } from "./nooticr.js";
 import { OAuthManager, SCOPES } from "./oauth.js";
@@ -227,9 +227,6 @@ export async function runHttp(port, publicUrl) {
         client: new NooticrClient(baseUrl, {
             getAccessToken: async () => undefined,
         }),
-        onSession: async (session) => {
-            await auth.persistSession(session);
-        },
     });
     const state = {
         oauth,
@@ -239,9 +236,9 @@ export async function runHttp(port, publicUrl) {
         serverFactory: () => createMcpServer((extra) => {
             const bearer = extra.authInfo?.token;
             // A caller who presented their own API key is answered as themselves.
-            // Falling through to `createHttpTokenProvider` here would resolve the
-            // *operator's* environment or credentials file instead — one tenant's
-            // request served from another's account.
+            // No branch below falls back to the *operator's* environment or
+            // credentials file: that would serve one tenant's request from
+            // another's account.
             if (looksLikeApiKey(bearer)) {
                 return new NooticrClient(baseUrl, createApiKeyTokenProvider(bearer));
             }
@@ -250,15 +247,13 @@ export async function runHttp(port, publicUrl) {
             if (forwarded) {
                 return new NooticrClient(baseUrl, createApiKeyTokenProvider(forwarded.token), undefined, forwardedHeaders(forwarded));
             }
+            // An OAuth login of this server: only that session's own tokens.
             const session = bearer
                 ? oauth.verifyToken(bearer)
                 : undefined;
-            return new NooticrClient(baseUrl, createHttpTokenProvider(auth, session
-                ? {
-                    accessToken: session.nooticrAccessToken,
-                    refreshToken: session.nooticrRefreshToken,
-                }
-                : undefined));
+            return new NooticrClient(baseUrl, session
+                ? createSessionTokenProvider(baseUrl, session)
+                : { getAccessToken: async () => undefined });
         }),
     };
     const server = http.createServer((req, res) => {

package/dist/shared/tools.js

@@ -36,7 +36,7 @@ import { registerAmazonTools } from "./amazon.js";
 import { registerMarketplaceTools } from "./marketplace.js";
 import { DEFAULT_NOOTICR_SETTINGS, DEFAULT_SOCIAL_PLATFORMS, MemorySettingsStore, SETTINGS_READ_TOOL, SETTINGS_UPDATE_TOOL, settingsOwnerFromAuth, } from "./settings.js";
 /** Current MCP server version — bumped on every deploy for traceability. */
-export const MCP_SERVER_VERSION = "1.26.75";
+export const MCP_SERVER_VERSION = "1.26.77";
 /** MCP Apps extension identifier */
 const UI_EXTENSION = "io.modelcontextprotocol/ui";
 /** MIME type for MCP Apps HTML resources */
@@ -179,91 +179,21 @@ export function argumentsDigest(value) {
     return hash.toString(16);
 }
 /**
- * Fields that must reach the client exactly as the server wrote them.
+ * Why nothing here rewrites a URL (#242).
  *
- * The blanket rewrite below is deliberately indiscriminate about *images*,
- * but these are not images:
- *  - `externalUrl` is the permalink on the social network. It is handed to
- *    `ui/open-link` and opened in a real browser tab, so proxying it turns
- *    "View on bilibili" into a fetch of the page through our image proxy.
- *  - `embedUrl` is an <iframe> src on the platform's own player origin.
- *  - the `*FallbackUrl` fields are already our own signed `/media/resolve`
- *    capability links; wrapping one in `/media/proxy` proxies our own
- *    resolver and invalidates nothing but the caller's playback.
- */
-const RAW_URL_KEYS = new Set([
-    "externalUrl",
-    "embedUrl",
-    "videoFallbackUrl",
-    "thumbnailFallbackUrl",
-    "musicFallbackUrl",
-]);
-/**
- * Whether a URL already points at one of our own media endpoints.
+ * This worker used to wrap every external URL in a result as
+ * `${server}/media/proxy?url=...`, so a card's images would load inside
+ * ChatGPT's and Claude's sandboxed frames. Those links were unsigned, and
+ * `/media/proxy` fetches from the internet for whoever calls it, so the server
+ * could not start refusing unsigned links without blanking every card.
  *
- * Checked by host-agnostic path, not by prefix: the server may mint these
- * against a different base than this process knows about, and a prefix test
- * silently misses that and double-wraps.
- */
-function isOwnMediaUrl(url) {
-    // `/media/files` is nooticr's own re-hosted media — Weibo video arrives that
-    // way. It was missing here, so whether it got wrapped a second time depended
-    // on the host string matching NOOTICR_BASE_URL exactly: "localhost:8080" and
-    // "127.0.0.1:8080" are the same server and different strings, and the proxy
-    // then refused its own URL as an SSRF attempt. Recognising the path shape is
-    // sturdier than trusting two spellings of a host to agree.
-    return (url.includes("/media/proxy") ||
-        url.includes("/media/resolve") ||
-        url.includes("/media/files"));
-}
-/**
- * Rewrite external image URLs to go through the nooticr proxy so they
- * work inside ChatGPT's sandboxed iframe (CORS + CSP restrictions).
+ * nooticr-server#893 moved the rewrite to where the signing key is: the HTTP
+ * `tools/call` route now hands back every external URL as a signed proxy link
+ * (`&sig=`), with this worker's old rule ported word for word (permalinks,
+ * embeds and our own resolve/files/copy links stay as they are). So a result
+ * reaches the host exactly as the server wrote it. Minting a link here again,
+ * for any field, is the bug this note exists to prevent: it would be unsigned.
  */
-function proxyImageUrl(url) {
-    if (!url || url.startsWith("data:"))
-        return url;
-    try {
-        const u = new URL(url);
-        // Only proxy external HTTP(S) URLs — skip our own proxy and data URIs
-        if (u.protocol === "http:" || u.protocol === "https:") {
-            const serverUrl = process.env.NOOTICR_API_URL || process.env.NOOTICR_BASE_URL || "";
-            if (serverUrl && !url.startsWith(serverUrl) && !isOwnMediaUrl(url)) {
-                return `${serverUrl.replace(/\/+$/, "")}/media/proxy?url=${encodeURIComponent(url)}`;
-            }
-        }
-    }
-    catch { }
-    return url;
-}
-/** Recursively rewrite URL fields in a structured object for the proxy. */
-export function proxyUrls(obj) {
-    if (typeof obj === "string") {
-        // Check if it looks like a URL
-        if (/^https?:\/\//.test(obj) && !isOwnMediaUrl(obj)) {
-            return proxyImageUrl(obj);
-        }
-        return obj;
-    }
-    if (Array.isArray(obj))
-        return obj.map(proxyUrls);
-    if (obj && typeof obj === "object") {
-        const out = {};
-        for (const [k, v] of Object.entries(obj)) {
-            if (RAW_URL_KEYS.has(k)) {
-                out[k] = v;
-            }
-            else if (["thumbnailUrl", "preview_url", "coverUrl", "avatarUrl", "avatar_thumb", "image_url", "videoUrl", "video_url", "url"].includes(k) && typeof v === "string") {
-                out[k] = proxyImageUrl(v);
-            }
-            else {
-                out[k] = proxyUrls(v);
-            }
-        }
-        return out;
-    }
-    return obj;
-}
 const structuredOf = (res) => (res.structured ?? {});
 /** A structured result this server computed rather than proxied. */
 function toStructured(value) {
@@ -312,9 +242,8 @@ async function toToolResult(proxy, guidance) {
     const htmlPrefix = rawText.startsWith("<")
         ? rawText.substring(0, rawText.indexOf("\n\n{")).trimEnd()
         : "";
-    const structured = proxy.structured;
-    // Proxy thumbnail URLs in structured content for ChatGPT iframe
-    const proxied = structured ? proxyUrls(structured) : {};
+    // URLs arrive already signed by the server; see the note above structuredOf.
+    const structured = proxy.structured ?? {};
     // `_htmlCards` is the rendered card HTML, and the text block already carries
     // it as htmlPrefix below. Leaving it in the structured payload sent the same
     // HTML a second time to the model and a third time into the widget: measured
@@ -322,23 +251,15 @@ async function toToolResult(proxy, guidance) {
     // template reads (zero references in either embedded copy - views render from
     // `posts`). Dropped from both the JSON the model sees and the structured
     // content the widget receives; the prefix keeps the one copy that is used.
-    const { _htmlCards: _renderedSeparately, ...forHosts } = proxied;
+    const { _htmlCards: _renderedSeparately, ...forHosts } = structured;
     const textJson = JSON.stringify(forHosts, null, 2);
-    // Replace image URLs in HTML with proxied versions
-    const proxiedHtml = htmlPrefix ? proxyImageUrlsInHtml(htmlPrefix) : "";
-    const body = proxiedHtml ? `${proxiedHtml}\n\n${textJson}` : textJson;
+    const body = htmlPrefix ? `${htmlPrefix}\n\n${textJson}` : textJson;
     const text = guidance ? `${guidance}\n\n${body}` : body;
     return {
         content: [{ type: "text", text }],
         structuredContent: guidance ? { ...forHosts, guidance } : forHosts,
     };
 }
-/** Replace external image/video src, poster and href URLs in HTML with proxied versions. */
-function proxyImageUrlsInHtml(html) {
-    return html.replace(/(src|href|poster)="(https?:\/\/[^"']+?)"/g, (_match, attr, url) => {
-        return `${attr}="${proxyImageUrl(url)}"`;
-    });
-}
 /**
  * An expired session, however the API happens to phrase it.
  *

package/dist/shared/ui-template.js

@@ -4213,8 +4213,11 @@ export const NOOTICR_UI_TEMPLATE = `<!DOCTYPE html>
         +(coverSrc?'<img class="sound-cover" data-avatar src="'+esc(coverSrc)+'" alt="" loading="lazy"/>':"")+"</span>";
       // The raw CDN URL is signed and cross-origin — only the proxied one
       // actually plays in this sandboxed frame. A bare link never played
-      // anything in-place, which is why sound cards were silent.
-      var play=s.playUrl||s.playProxyUrl||s.url||"";
+      // anything in-place, which is why sound cards were silent. So the
+      // server's signed playProxyUrl comes first: playUrl is not a media key
+      // the server proxies (nooticr-server#912), and this <audio> has no
+      // retry to fall back on (#256).
+      var play=s.playProxyUrl||s.playUrl||s.url||"";
       var secs=Number(s.duration)||0;
       var meta=[s.artist||s.author||"",secs>0?fmtTime(secs):""].filter(Boolean).join(" · ");
       var player=play

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nooticr/mcp",
   "mcpName": "com.nooticr/mcp",
-  "version": "1.26.75",
+  "version": "1.26.77",
   "description": "MCP server for nooticr - fetch, discover and understand TikTok/Instagram/YouTube/X/Reddit/LinkedIn/Weibo posts with AI (media metadata, niche discovery, brand monitoring, hook & viral analysis)",
   "homepage": "https://mcp.nooticr.com",
   "repository": {