@nooticr/mcp 1.26.57 → 1.26.59

package/README.md

@@ -52,7 +52,7 @@ npx @nooticr/mcp login   # one-time sign-in (Google)
 
 ## Tools
 
-90 tools, grouped by what you are trying to do. Prices are in nooticr credits and
+93 tools, grouped by what you are trying to do. Prices are in nooticr credits and
 match what the server actually charges.
 
 The job tools under **Answer a question you actually have** are not
@@ -151,6 +151,7 @@ a `scanId` for the rest.
 | `get_amazon_product` | 3 | One listing by ASIN or URL: price, rating, the full star histogram, features, specs, Amazon's review digest and aspect breakdown, and the reviews. |
 | `scan_marketplace_category` | 3 per product collected (30 by default) | The same category read on eleven more sites — AliExpress, Cdiscount, Flipkart, Mercado Libre, Lazada, Otto, Rakuten, Trendyol, Jumia, Vinted and Temu. Vinted is resale rather than retail, so its `rating` describes the seller and the scan says so in `ratingScope` — do not read it as a product's reviews. `marketplace` picks the site; `market` picks the storefront for the sites that have several, and the argument names the real set per site so a model cannot send Otto a Lazada region. Same rollup, same confirmation before spending. |
 | `marketplace_scan_status` | free | Picks a running marketplace collection back up by `scanId` and the same `marketplace`. Free, for the same reason `amazon_scan_status` is. |
+| `marketplace_changes` | free | What moved in a category since the previous scan of the same `marketplace` and `query`: products that entered or left the results and ones whose price or place changed. Read from the two latest stored scans, so it fetches nothing; a category scanned once says it has no earlier run. |
 | `get_marketplace_product` | 3 | One product from any of the twelve sites, by id or URL: price, rating, the full star histogram, specs and the reviews. |
 | `show_amazon_category_insights` | free | Draws the read **your model** wrote — purchase drivers, barriers, what each brand does well, the gaps, the positioning angles — beside the listings and their reviews, so a person can click a product and check any claim against the text it came from. The conclusions are attributed to your model, never presented as a nooticr rating of anyone's product. Given the `scanId`, it re-reads the listings from the scan itself (free) instead of drawing whatever the model re-sends, and flags any ASIN the read cites that the scan does not contain; without one, the card says its listings were not checked. |
 | `show_marketplace_category_insights` | free | The same card for the other eleven marketplaces: your read beside that site's listings and reviews, labelled with the right site, re-read from the scan by `scanId` and `marketplace` so nothing is re-typed. |
@@ -181,6 +182,8 @@ a `scanId` for the rest.
 | `nooticr_login` | free | Re-link the account when a call fails with an authentication error. |
 | `list_social_connections` | free | What you have connected and what each connection is actually allowed to do — read the account, publish a post, manage comments — as yes, no or **unknown**. "Manage comments" reports the platform's grant; no nooticr tool posts or replies to a comment. Unknown means the grant predates scope recording: treat it as "try it", not as a refusal. Also says which platforms can be linked at all, which is a smaller set than the networks nooticr reads. |
 | `connect_social_account` | free | A link the user opens to connect one account. They approve at the provider in their own browser; nothing is connected until they do, and no credential passes through the tool or the model's context. Each call mints a fresh link — an old one does not work twice. |
+| `connect_store` | free | A link a workspace owner or admin opens to connect an Amazon seller account or a Shopify shop. They approve at the store; nothing is connected until they do, and no credential passes through the tool. |
+| `list_store_products` | free | Read the connected store's own catalogue: title, description, status, price, and Amazon listing issues. Read-only. |
 | `create_product` | free | Create a product in your own workspace — the row every other own-account tool needs before it has anything to work with. Always creates in the calling session's workspace, never one you could name. `name` and `slug` are required; every other field is snake_case and read by exact key, so a camelCase `websiteUrl` lands nowhere. Writes no brand playbook. |
 | `update_product` | free | Patch a product's fields. An omitted argument leaves its column unchanged, so this cannot blank a field by not mentioning it, and the result lists what was actually written — a misspelled field shows up as one that did not change rather than as a silent no-op. |
 

package/dist/shared/backend-only.js

@@ -20,7 +20,7 @@ export const BACKEND_ONLY_TOOLS = {
     schedule_post: "Rendering and publishing stay in the dashboard (#92).",
     get_batch_history: "History of the dashboard's compose batches, which only exist once rendering does; stays with #92.",
     get_latest_analysis: "Returns the dashboard's stored AI fleet-analysis verdict; the public surface sells the evidence, not a judgement of ours.",
-    propose_listing_update: "Commerce writes (nooticr-server C1 3/4) stay in the dashboard until exposing store writes to hosts is a product decision. connect_store and list_store_products, the C1 read pair, are undecided and want settling together with these.",
+    propose_listing_update: "Commerce writes (nooticr-server C1 3/4) stay in the dashboard until exposing store writes to hosts is a product decision.",
     apply_listing_update: "Commerce writes (nooticr-server C1 3/4) stay in the dashboard until exposing store writes to hosts is a product decision; applying a change edits the merchant's live store.",
     propose_price_change: "Commerce writes (nooticr-server C1 3/4) stay in the dashboard until exposing store writes to hosts is a product decision.",
     apply_price_change: "Commerce writes (nooticr-server C1 3/4) stay in the dashboard until exposing store writes to hosts is a product decision; applying a change edits the merchant's live prices.",

package/dist/shared/loading-plans.js

@@ -436,6 +436,8 @@ export const LOADING_PLANS = {
         steps: [],
         free: true,
     },
+    // Free: reads two stored scans, fetches nothing.
+    marketplace_changes: { label: "Comparing the two scans", kind: "list", n: 6, steps: [], free: true },
     get_marketplace_product: {
         label: "Reading the product",
         kind: "text",
@@ -477,6 +479,9 @@ export const LOADING_PLANS = {
     list_brand_watches: { label: "Reading your watches", kind: "list", n: 3, steps: [], free: true },
     stop_brand_watch: { label: "Stopping the watch", kind: "text", n: 1, steps: [], free: true },
     update_watch_portfolio: { label: "Updating the portfolio", kind: "text", n: 1, steps: [], free: true },
+    // ─── Store connections (store-read.ts): a link, and a read of the store's own catalogue ───
+    connect_store: { label: "Minting a store link", kind: "text", n: 1, steps: [], free: true },
+    list_store_products: { label: "Reading your store's catalogue", kind: "list", n: 3, steps: [], free: true },
     // ─── Own-account reads: nooticr's own stored rows, never an upstream call ───
     list_own_apps: { label: "Reading your products", kind: "list", n: 3, steps: [], free: true },
     get_content_plan: { label: "Reading the saved plan", kind: "text", n: 1, steps: [], free: true },

package/dist/shared/marketplace.js

@@ -400,6 +400,45 @@ export function registerMarketplaceTools(server, makeClient) {
             return toolError("marketplace_scan_status failed", err);
         }
     });
+    server.registerTool("marketplace_changes", {
+        title: "Marketplace Changes",
+        description: "What moved in a category since the run before: products that entered or left a search's " +
+            "results, and ones whose price or place changed. Compared from the two latest stored scans " +
+            "of the same marketplace and `query`, so it fetches nothing and never re-scans — run " +
+            "scan_marketplace_category first, and again later, to have two runs to compare. `new` and " +
+            "`gone` mean entered or left the results, not listed or delisted. A category scanned only " +
+            "once has no earlier run and says so. Free.",
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        outputSchema: OUTPUT_SCHEMAS.marketplace_changes,
+        inputSchema: z
+            .object({
+            marketplace: marketplaceArg,
+            query: z.string().describe("The category search to compare, exactly as it was scanned."),
+            market: z.string().optional().describe("The storefront the scan read, if the site has several."),
+        })
+            .strict(),
+    }, async (args, extra) => {
+        const client = await makeClient({ ...extra, arguments: args });
+        const m = marketOf(args.marketplace);
+        if (!m)
+            return toolError("marketplace_changes failed", new Error(`unknown marketplace — one of ${SLUGS}`));
+        try {
+            const res = await client.callTool("marketplace_changes", args);
+            const payload = structured(res);
+            return {
+                content: [{ type: "text", text: JSON.stringify(payload) }],
+                structuredContent: payload,
+            };
+        }
+        catch (err) {
+            return toolError("marketplace_changes failed", err);
+        }
+    });
     server.registerTool("get_marketplace_product", {
         title: "Get Marketplace Product",
         _meta: viewMeta("get_marketplace_product"),

package/dist/shared/output-schemas.js

@@ -1598,6 +1598,24 @@ export const OUTPUT_SCHEMAS = {
         connectUrl: scalar().describe("Open this in a browser to approve the connection."),
         message: scalar(),
     }),
+    // Store connections (nooticr-server C1). The catalogue rows are the platform's
+    // own shape, so only the stable fields are named.
+    connect_store: open({
+        platform: scalar(),
+        connectUrl: scalar().describe("Open this in a browser to approve the connection."),
+        message: scalar(),
+    }),
+    list_store_products: open({
+        products: listOf(anyObject()),
+        nextCursor: scalar(),
+        status: scalar(),
+        reportId: scalar(),
+        poll: anyObject().nullish(),
+        nextCall: anyObject().nullish(),
+        needsConnection: scalar(),
+        connections: listOf(anyObject()),
+        message: scalar(),
+    }),
     // Marketplace. One shape for all three collection tools: a status poll
     // returns exactly what the scan that started it returns, and a single
     // product is a scan of one — describing them differently would be three
@@ -1611,6 +1629,24 @@ export const OUTPUT_SCHEMAS = {
     // the result does not have to know which site it asked.
     scan_marketplace_category: marketplaceScan,
     marketplace_scan_status: marketplaceScan,
+    // A diff of two stored scans, drawn by no view: the rows are the answer.
+    marketplace_changes: open({
+        display: scalar(),
+        hasBaseline: scalar(),
+        since: scalar(),
+        takenAt: scalar(),
+        counts: open({ new: scalar(), gone: scalar(), moved: scalar() }).nullish(),
+        totalChanges: scalar(),
+        rows: listOf(open({
+            change: scalar(),
+            id: scalar(),
+            title: scalar(),
+            meta: scalar(),
+            url: scalar(),
+            move: scalar(),
+        })),
+        note: scalar(),
+    }),
     get_marketplace_product: open({
         ...marketplaceScanShape,
         product: amazonProduct.nullish().describe("The single product, also present as products[0]."),

package/dist/shared/store-read.js

@@ -0,0 +1,82 @@
+/**
+ * Store connections (nooticr-server C1): get the link a workspace owner opens to
+ * connect an Amazon seller account or a Shopify shop, and read that store's own
+ * catalogue. Both are passthroughs to the server's `POST /mcp` dispatch; the
+ * server owns the owner/admin check, the one-time link and the platform calls.
+ *
+ * The store *write* tools (propose/apply listing and price changes) are not
+ * here: they stay in BACKEND_ONLY_TOOLS until exposing them to hosts is decided.
+ * Neither tool has a view yet: a catalogue would be a table the design system
+ * has no card for.
+ */
+import { z } from "zod";
+import { OUTPUT_SCHEMAS } from "./output-schemas.js";
+function toResult(proxy) {
+    const textBlock = proxy.contentBlocks.find((c) => c.type === "text");
+    const structured = proxy.structured;
+    // No view draws structuredContent here, so the model reads it from the text.
+    const text = structured ? JSON.stringify(structured) : String(textBlock?.text ?? "");
+    return { content: [{ type: "text", text }], structuredContent: structured };
+}
+function failed(prefix, err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: [{ type: "text", text: `${prefix}: ${msg}` }], isError: true };
+}
+const platform = z.enum(["amazon", "shopify"]);
+export function registerStoreReadTools(server, makeClient) {
+    const passthrough = (name) => async (args, extra) => {
+        const client = await makeClient({ ...extra, arguments: args });
+        try {
+            return toResult(await client.callTool(name, args));
+        }
+        catch (err) {
+            return failed(`${name} failed`, err);
+        }
+    };
+    server.registerTool("connect_store", {
+        title: "Connect Store",
+        description: "Get a link a workspace owner or admin opens to connect an Amazon seller account " +
+            "(platform \"amazon\", optional region na/eu/fe) or a Shopify shop (platform \"shopify\", " +
+            "shop \"your-store.myshopify.com\"). Optionally appId ties the store to one product. The " +
+            "owner approves at Amazon or Shopify; nothing is connected until they do, and no " +
+            "credential passes through this tool. Nooticr only asks for access to listing copy and " +
+            "prices. Each call mints a fresh link. No cost to call.",
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+        inputSchema: z
+            .object({
+            platform: platform.describe("Which store platform to connect."),
+            shop: z.string().optional().describe("Shopify shop domain, e.g. your-store.myshopify.com."),
+            region: z.enum(["na", "eu", "fe"]).optional().describe("Amazon region; defaults to na."),
+            appId: z.string().optional().describe("Product id to tie the store to."),
+        })
+            .strict(),
+        outputSchema: OUTPUT_SCHEMAS.connect_store,
+    }, passthrough("connect_store"));
+    server.registerTool("list_store_products", {
+        title: "List Store Products",
+        description: "Read the connected store's own catalogue: title, bullets, description, status, price, " +
+            "currency and Amazon listing issues. connectionId is optional when one store is " +
+            "connected; with several, the answer lists them and asks you to choose. query (Amazon: " +
+            "exact SKU; Shopify: product search), limit (up to 50), cursor from nextCursor, " +
+            "productRef to read one product by SKU or GID, includeIssues, includePricing (Amazon). " +
+            "For Amazon, source \"report\" reads the whole catalogue through a report: it answers " +
+            "status in_progress with a reportId and poll arguments until done. Read-only. No cost to call.",
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        inputSchema: z
+            .object({
+            connectionId: z.string().optional().describe("Store connection id; optional when one store is connected."),
+            platform: platform.optional(),
+            query: z.string().optional().describe("Amazon: exact SKU. Shopify: product search query."),
+            limit: z.number().int().min(1).max(50).optional(),
+            cursor: z.string().optional().describe("nextCursor from the previous page."),
+            includeIssues: z.boolean().optional(),
+            includePricing: z.boolean().optional(),
+            productRef: z.string().optional().describe("Amazon SKU or Shopify product GID to read one product."),
+            marketplaceId: z.string().optional().describe("Amazon marketplace id; defaults to the first."),
+            source: z.enum(["live", "report"]).optional(),
+            reportId: z.string().optional().describe("Report id from an in_progress answer."),
+        })
+            .strict(),
+        outputSchema: OUTPUT_SCHEMAS.list_store_products,
+    }, passthrough("list_store_products"));
+}

package/dist/shared/tools-def.js

@@ -402,6 +402,18 @@ export const TOOL_DEFINITIONS = [
         description: "Get a link to open so you can connect one social account. The user approves at the provider; nothing is connected until they do, and no credential ever passes through this tool. For YouTube, pass capabilities [\"manage_comments\"] to also ask for the comment-management grant. No cost to call.",
         inputSchema: z.object({ platform: z.string().describe("Which network to connect."), influencerId: z.number().int().optional(), appId: z.number().int().optional(), capabilities: z.array(z.enum(["manage_comments"])).optional().describe("YouTube only: [\"manage_comments\"] asks for the comment-management grant.") }).strict(),
     },
+    {
+        name: "connect_store",
+        title: "Connect Store",
+        description: "Get a link a workspace owner or admin opens to connect an Amazon seller account (platform \"amazon\", optional region na/eu/fe) or a Shopify shop (platform \"shopify\", shop \"your-store.myshopify.com\"). Optionally appId ties the store to one product. The owner approves at Amazon or Shopify; nothing is connected until they do, and no credential passes through this tool. Nooticr only asks for access to listing copy and prices. Each call mints a fresh link. No cost to call.",
+        inputSchema: z.object({ platform: z.enum(["amazon", "shopify"]).describe("Which store platform to connect."), shop: z.string().optional().describe("Shopify shop domain, e.g. your-store.myshopify.com."), region: z.enum(["na", "eu", "fe"]).optional().describe("Amazon region; defaults to na."), appId: z.string().optional().describe("Product id to tie the store to.") }).strict(),
+    },
+    {
+        name: "list_store_products",
+        title: "List Store Products",
+        description: "Read the connected store's own catalogue: title, bullets, description, status, price, currency and Amazon listing issues. connectionId is optional when one store is connected; with several, the answer lists them and asks you to choose. query (Amazon: exact SKU; Shopify: product search), limit (up to 50), cursor from nextCursor, productRef to read one product by SKU or GID, includeIssues, includePricing (Amazon). For Amazon, source \"report\" reads the whole catalogue through a report: it answers status in_progress with a reportId and poll arguments until done. Read-only. No cost to call.",
+        inputSchema: z.object({ connectionId: z.string().optional().describe("Store connection id; optional when one store is connected."), platform: z.enum(["amazon", "shopify"]).optional(), query: z.string().optional().describe("Amazon: exact SKU. Shopify: product search query."), limit: z.number().int().min(1).max(50).optional(), cursor: z.string().optional().describe("nextCursor from the previous page."), includeIssues: z.boolean().optional(), includePricing: z.boolean().optional(), productRef: z.string().optional().describe("Amazon SKU or Shopify product GID to read one product."), marketplaceId: z.string().optional().describe("Amazon marketplace id; defaults to the first."), source: z.enum(["live", "report"]).optional(), reportId: z.string().optional().describe("Report id from an in_progress answer.") }).strict(),
+    },
     {
         name: "answer_my_audience",
         title: "Answer My Audience",
@@ -510,6 +522,12 @@ export const TOOL_DEFINITIONS = [
         description: "Pick up a scan_marketplace_category collection that was still running, by scanId and the same marketplace — the products and reviews collected since, with the same rollup and the same instructions for reading them. Free: it is the poll scan_marketplace_category asked for, and charging for the second half of one answer would bill a wait this server chose. Call it when a scan came back incomplete, and keep calling it until it reports complete: true; only then write your read, from the full set. Do not end your turn between polls.",
         inputSchema: z.object({ marketplace: z.string().describe("The same site the scan ran against."), scanId: z.string().describe("The scanId scan_marketplace_category returned."), waitSeconds: z.number().int().optional().describe("How long to wait for more products before answering (default 30, max 55)."), focus: z.string().optional().describe("Same optional steer as scan_marketplace_category.") }).strict(),
     },
+    {
+        name: "marketplace_changes",
+        title: "Marketplace Changes",
+        description: "What moved in a category since the run before: products that entered or left a search's results, and ones whose price or place changed. Compared from the two latest stored scans of the same marketplace and `query`, so it fetches nothing and never re-scans — run scan_marketplace_category first, and again later, to have two runs to compare. `new` and `gone` mean entered or left the results, not listed or delisted. A category scanned only once has no earlier run and says so. Free.",
+        inputSchema: z.object({ marketplace: z.string().describe("Which site the scan read."), query: z.string().describe("The category search to compare, exactly as it was scanned."), market: z.string().optional().describe("The storefront the scan read, if the site has several.") }).strict(),
+    },
     {
         name: "get_marketplace_product",
         title: "Get Marketplace Product",

package/dist/shared/tools.js

@@ -23,6 +23,7 @@ import { registerJobTools } from "./jobs.js";
 import { registerBrandWatch } from "./brand-watch.js";
 import { registerOwnAccountTools } from "./own-account.js";
 import { registerConnectionTools } from "./connections.js";
+import { registerStoreReadTools } from "./store-read.js";
 import { registerGettingStarted, SERVER_INSTRUCTIONS } from "./getting-started.js";
 import { loadingPlansJson } from "./loading-plans.js";
 import { registerHandoff } from "./handoff.js";
@@ -31,7 +32,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.57";
+export const MCP_SERVER_VERSION = "1.26.59";
 /** MCP Apps extension identifier */
 const UI_EXTENSION = "io.modelcontextprotocol/ui";
 /** MIME type for MCP Apps HTML resources */
@@ -2886,6 +2887,8 @@ export function createMcpServer(rawMakeClient, opts) {
     registerBrandWatch(server, makeClient);
     registerOwnAccountTools(server, makeClient);
     registerConnectionTools(server, makeClient);
+    // Store connections (store-read.ts): the connect link and the catalogue read.
+    registerStoreReadTools(server, makeClient);
     registerGettingStarted(server, makeClient, watchStore);
     // Neither fetches, neither takes a client: one formats what the model
     // classified for a tracker on another server, the other draws what it scored.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nooticr/mcp",
   "mcpName": "com.nooticr/mcp",
-  "version": "1.26.57",
+  "version": "1.26.59",
   "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": {