social-autoposter 1.6.74 → 1.6.77

package/mcp/dist/index.js

@@ -19,7 +19,7 @@ import fs from "node:fs";
 import { repoDir, runPython, run, readPlan, writePlan, planPath, scanResultPath, } from "./repo.js";
 import { applySetup, resolveProject, listManagedProjectStatus, REQUIRED_FIELDS, RECOMMENDED_FIELDS, configPath, } from "./setup.js";
 import { xStatus, xConnect, xDetectSources, xScanProfile, summarizeXAuth } from "./twitterAuth.js";
-import { startProvisioning, isProvisioning, readProgress, runtimeReady, readRuntime, resolvePython, resolveChrome, ensureMenubar, } from "./runtime.js";
+import { startProvisioning, isProvisioning, readProgress, runtimeReady, readRuntime, resolvePython, resolveChrome, ensureMenubar, ensurePipelineCurrent, } from "./runtime.js";
 import { blockOnboardingMilestone, completeOnboardingMilestone, ensureDoctorPhase, onboardingLedger, onboardingSnapshot, recordOnboardingAttempt, runDoctorPhase, } from "./onboarding.js";
 import { VERSION, versionStatus, latestPublishedVersion } from "./version.js";
 import { initSentry, sendHeartbeat, captureError, flushSentry } from "./telemetry.js";
@@ -30,6 +30,7 @@ import http from "node:http";
 // (vite-plugin-singlefile) into dist/panel.html alongside this compiled file.
 const DIST_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PANEL_URI = "ui://social-autoposter/panel.html";
+const PRODUCT_LINK_URI = "ui://social-autoposter/product-link.html";
 // Stable id for the accumulating draft review queue. submit_drafts appends each
 // run's drafts here (dedup by tweet URL) so the menu-bar cards PILE UP across a
 // continuous autopilot instead of each run overwriting the last; post_drafts posts
@@ -151,7 +152,7 @@ async function unloadPlist(label, plistPath, uid) {
 // so serverInfo.version finally reflects what the user actually has installed
 // instead of a frozen literal.
 const server = new McpServer({
-    name: "social-autoposter",
+    name: "S4L",
     version: VERSION,
 }, {
     // Host injects this into the agent's system prompt, so be proactive about
@@ -182,12 +183,18 @@ const server = new McpServer({
         "autopilot by calling the HOST tool `create_scheduled_task` with: taskId " +
         "'social-autoposter-autopilot'; cronExpression '* * * * *' (continuous, like the pipeline; the " +
         "host runs one at a time and skips overlapping fires, so cycles run back-to-back); and a " +
-        "self-contained prompt telling the run to call scan_candidates, draft ONE on-brand reply " +
-        "(<=250 chars, same language as the thread, adds real value) for each candidate worth engaging, " +
-        "then call submit_drafts with those drafts, and NOT post (drafts pile up in the menu-bar " +
-        "approval cards for the user to approve). Then run ONE cycle yourself now (scan_candidates -> " +
-        "draft -> submit_drafts) to seed the cards and pre-approve the tools, so unattended fires do not " +
-        "stall on a permission prompt. If the host exposes no create_scheduled_task tool, tell the user " +
+        "self-contained prompt telling the run to call scan_candidates (which long-polls — if it " +
+        "returns a `Scan in progress` status, call scan_candidates again with the same args and keep " +
+        "re-calling until it returns candidates; never sleep or use background waits between calls), " +
+        "then (if it needs the project's brand voice to draft on-brand) call project_config to read it, " +
+        "draft ONE on-brand reply (<=250 chars, same language as the thread, adds real value) for each " +
+        "candidate worth engaging, then call submit_drafts with those drafts, and NOT post (drafts pile " +
+        "up in the menu-bar approval cards for the user to approve). The prompt MUST name EVERY tool the " +
+        "run can use (scan_candidates, project_config, submit_drafts) so none is a surprise mid-run. " +
+        "Then run ONE FULL cycle yourself now that exercises ALL of them " +
+        "(scan_candidates -> project_config -> draft -> submit_drafts) to seed the cards AND pre-approve " +
+        "every tool, so unattended fires never stall waiting on a per-tool permission prompt. If the host " +
+        "exposes no create_scheduled_task tool, tell the user " +
         "the autopilot could not be scheduled here and to run a draft cycle manually instead.\n\n" +
         "BE PROACTIVE ABOUT MARKETING MOMENTS. Whenever the user ships, finishes, merges, or releases " +
         "something worth talking about in this session (a new feature, a launch, a long-awaited fix, a " +
@@ -524,6 +531,10 @@ async function postApproved(batchId, plan) {
     const approved = (plan.candidates || []).filter((c) => c.approved === true);
     if (approved.length === 0)
         return { attempted: 0, exit_code: 0, summary: "nothing approved" };
+    // Posting is a priority over scanning: abort any in-flight plugin scan so the
+    // approved post takes the browser immediately instead of waiting on the lock.
+    // Plugin pipeline only — never affects the plist autopilot.
+    preemptScanForPost();
     const approvedBatch = `${batchId}_approved`;
     writePlan(approvedBatch, { ...plan, candidates: approved });
     // SAPS_SKIP_CAMPAIGN_SUFFIX=1: manual/reviewed posts from this MCP draft_cycle
@@ -590,7 +601,7 @@ async function postApproved(batchId, plan) {
 // drift from REQUIRED_FIELDS / the project_config tool's flow. All real logic stays
 // in `project_config`; this is just a convenience handle to begin.
 server.registerPrompt("getting-started", {
-    title: "Set up social-autoposter",
+    title: "Set up S4L",
     description: "Start here. Walks you through configuring a product and connecting your X/Twitter " +
         "account so the autoposter can draft and post for you.",
 }, async () => ({
@@ -637,8 +648,10 @@ const WEBSITE_RESEARCH_INSTRUCTIONS = "PRODUCT RESEARCH (do this before saving t
     "register, vibe) while keeping every product CLAIM factual to the site. Don't invent " +
     "features, metrics, or guarantees the site doesn't state.\n" +
     "5. Save the best conservative factual draft without adding a confirmation round-trip. Call " +
-    "project_config with name + the product fields (plus voice/search_topics from the profile scan). If the " +
-    "site is thin or unreachable, use only supported facts and leave optional detail conservative; " +
+    "project_config with name + the product fields (plus voice/search_topics from the profile scan), AND " +
+    "expand those topics into a `search_queries` array of ~30 concrete X advanced-search strings in the " +
+    "SAME call — YOU are the model, so do the expansion in-session; it seeds directly with no `claude -p`. " +
+    "If the site is thin or unreachable, use only supported facts and leave optional detail conservative; " +
     "ask the user only if a required field is genuinely unknowable.";
 // ---- project_config: per-project config (the "brain": project, website, voice) -----
 // Run this FIRST. The action tools refuse until at least one project is ready.
@@ -730,6 +743,14 @@ tool("project_config", {
             .union([z.array(z.string()), z.string()])
             .optional()
             .describe("Topics/keywords to monitor on X (comma-separated or array)"),
+        search_queries: z
+            .array(z.string())
+            .optional()
+            .describe("Cold-start X search-query bank YOU expand from search_topics, in this same call. " +
+            "Fan each topic into a few concrete X advanced-search strings (aim ~30 total, e.g. " +
+            "'mac menu bar app -filter:replies', 'screen recording privacy lang:en') so the cycle " +
+            "fans out instead of running one crude topic-as-query. Seeded directly with NO `claude " +
+            "-p` — you are the model doing the expansion, so setup never needs the claude CLI."),
         get_started_link: z
             .string()
             .optional()
@@ -1001,13 +1022,28 @@ tool("project_config", {
             // search queries (project_search_queries) so the deterministic Phase 1
             // bank (qualified_query_bank.py) has something to run on day one.
             // Without this, a freshly-configured project's bank is empty and the
-            // cycle falls back to ONE crude topic-as-query. Best-effort: a failure
-            // here never fails setup; the topic-as-query fallback still works, just
-            // narrower. Supply-test is auto (only if the harness is up), so this
-            // stays fast when X isn't connected yet. (2026-06-04)
-            if (seed.code === 0) {
+            // cycle falls back to ONE crude topic-as-query.
+            //
+            // CLAUDE-FREE: the in-session agent (you) expands topics -> queries and
+            // passes them as `search_queries` in THIS call. We seed them directly via
+            // --queries-json, so setup never shells out to `claude -p` (which isn't
+            // installed in the Desktop / .mcpb lane and was the FileNotFoundError
+            // users hit). If the agent didn't supply queries, we skip expansion
+            // entirely — the topic-as-query fallback still runs, just narrower — and
+            // nudge the agent to re-run with search_queries. (2026-06-19)
+            const agentQueries = Array.isArray(args.search_queries)
+                ? args.search_queries.map((q) => String(q).trim()).filter(Boolean)
+                : [];
+            if (seed.code === 0 && agentQueries.length) {
                 try {
-                    const qseed = await runPython("scripts/seed_search_queries.py", ["--project", result.project, "--supply-test", "auto", "--emit-json"], { timeoutMs: 600_000 });
+                    const qfile = path.join(os.tmpdir(), `saps-queries-${result.project}-${Date.now()}.json`);
+                    fs.writeFileSync(qfile, JSON.stringify({ queries: agentQueries.map((q) => ({ query: q, topic: "" })) }));
+                    const qseed = await runPython("scripts/seed_search_queries.py", ["--project", result.project, "--queries-json", qfile,
+                        "--supply-test", "auto", "--emit-json"], { timeoutMs: 600_000 });
+                    try {
+                        fs.unlinkSync(qfile);
+                    }
+                    catch { /* best-effort cleanup */ }
                     const qm = /seeded=(\d+)\s+inserted=(\d+)\s+updated=(\d+)/.exec(qseed.stdout);
                     const qjson = qseed.stdout.split("===QUERIES_JSON===")[1];
                     if (qjson) {
@@ -1020,17 +1056,20 @@ tool("project_config", {
                     }
                     if (qseed.code === 0 && qm) {
                         const n = searchQueries.length || Number(qm[1]);
-                        seedNote += ` Expanded them into ${n} search quer${n === 1 ? "y" : "ies"} so the cycle can fan out instead of running a single query.`;
+                        seedNote += ` Seeded ${n} search quer${n === 1 ? "y" : "ies"} so the cycle can fan out instead of running a single query.`;
                     }
                     else if (qseed.code !== 0) {
                         const qtail = (qseed.stderr || qseed.stdout).trim().split("\n").slice(-1)[0] || "unknown error";
-                        seedNote += ` (Search queries not expanded yet — ${qtail}. The cycle still runs off the seeded topics.)`;
+                        seedNote += ` (Search queries not seeded yet — ${qtail}. The cycle still runs off the seeded topics.)`;
                     }
                 }
                 catch (e) {
-                    seedNote += ` (Search-query expansion skipped — ${e.message}.)`;
+                    seedNote += ` (Search-query seeding skipped — ${e.message}.)`;
                 }
             }
+            else if (seed.code === 0) {
+                seedNote += ` (No search_queries supplied, so the cycle will run off the seeded topics one at a time. To fan out, re-call project_config with a search_queries array of ~30 X search strings you expand from these topics — it seeds them directly, no claude CLI.)`;
+            }
         }
         // Surface any advanced (escape-hatch) field edits in the note so the
         // agent can confirm exactly what changed to the user.
@@ -1447,13 +1486,16 @@ let localPanel = null;
 // Read the built panel.html and flip it into HTTP-bridge mode by injecting a
 // flag the front-end reads at boot. Same bytes as the inline ui:// resource,
 // minus the postMessage host (there's none over loopback).
-function panelHtmlForHttp() {
-    const html = fs.readFileSync(path.join(DIST_DIR, "panel.html"), "utf-8");
+function widgetHtmlForHttp(file) {
+    const html = fs.readFileSync(path.join(DIST_DIR, file), "utf-8");
     const inject = `<script>window.__SAPS_BRIDGE__=${JSON.stringify("http")};</script>`;
     if (html.includes("</head>"))
         return html.replace("</head>", inject + "</head>");
     return inject + html;
 }
+function panelHtmlForHttp() {
+    return widgetHtmlForHttp("panel.html");
+}
 function readBody(req) {
     return new Promise((resolve, reject) => {
         const chunks = [];
@@ -1478,6 +1520,12 @@ function startLocalPanel() {
                     res.end(panelHtmlForHttp());
                     return;
                 }
+                if (req.method === "GET" &&
+                    (url.pathname === "/product-link" || url.pathname === "/product-link.html")) {
+                    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                    res.end(widgetHtmlForHttp("product-link.html"));
+                    return;
+                }
                 if (req.method === "GET" && url.pathname === "/health") {
                     res.writeHead(200, { "Content-Type": "application/json" });
                     res.end(JSON.stringify({ ok: true }));
@@ -1632,9 +1680,20 @@ async function runScanCandidates(project, onProgress) {
         env.BH_CHROME_BIN = chrome;
     let step = 0;
     let lastMsg = "";
+    // Specific phase label for the menu bar for the whole multi-minute scan, so the
+    // long-poll doesn't leave it on a generic "working" (or flicker to idle between
+    // re-calls). Cleared by the handler when the scan resolves.
+    writeActivity("scanning", project ? `scanning X for ${project}` : "scanning X");
     const res = await run("bash", ["skill/run-twitter-cycle.sh"], {
         env,
         timeoutMs: 900_000,
+        onSpawn: (c) => {
+            // Track the PLUGIN's own scan process so an approved post can abort exactly
+            // this scan (posting preempts scanning). This is the plugin pipeline only —
+            // the plist autopilot's scan is a separate launchd process the MCP server
+            // never spawns and has no handle to, so it can never be touched here.
+            scanChild = c;
+        },
         onLine: (line) => {
             const t = line.replace(/\s+$/, "");
             if (t.trim())
@@ -1648,6 +1707,7 @@ async function runScanCandidates(project, onProgress) {
             }
         },
     });
+    scanChild = null; // scan finished on its own; nothing to preempt.
     const marker = /SCAN_ONLY_RESULT=(\/\S+\.json)/.exec(res.stdout + "\n" + res.stderr);
     if (marker && marker[1]) {
         try {
@@ -1671,6 +1731,20 @@ async function runScanCandidates(project, onProgress) {
     if (blockedMarker && blockedMarker[1]) {
         return { batchId: null, candidates: [], blocked: blockedReasonMessage(blockedMarker[1]) };
     }
+    // The pipeline's single-flight guard prints too_many_inflight and exits 0 when
+    // ANOTHER scan already holds the twitter-cycle slot (commonly the legacy
+    // claude -p autopilot, which we deliberately keep running). That is CONTENTION,
+    // not an empty batch — flag it so the caller retries instead of concluding
+    // "no candidates" (a clean empty scan returns a batch_id with count:0).
+    if (/too_many_inflight/.test(res.stdout + res.stderr)) {
+        return {
+            batchId: null,
+            candidates: [],
+            busy: true,
+            blocked: "Another scan already holds the pipeline slot (likely the legacy autopilot). Contention, " +
+                "not an empty result — retry scan_candidates shortly.",
+        };
+    }
     return {
         batchId: null,
         candidates: [],
@@ -1679,17 +1753,92 @@ async function runScanCandidates(project, onProgress) {
             res.stderr.split("\n").slice(-12).join("\n"),
     };
 }
-tool("scan_candidates", {
-    title: "Scan X for reply candidates (no drafting, no posting)",
-    description: "Step 1 of a hands-free / scheduled autopilot run. Runs the scan+score half of the pipeline " +
-        "and returns the top scored X/Twitter threads worth replying to — WITHOUT drafting or posting, " +
-        "and without spending any `claude -p` budget. You (this session) then draft an on-brand reply " +
-        "for each good candidate YOURSELF and submit them with `submit_drafts`. Each candidate includes " +
-        "its candidate_id (pass it back), the thread text/author, the matched project, and engagement " +
-        "metrics. Optional `project` scopes the scan to one configured project.",
-    inputSchema: { project: z.string().optional() },
-}, async (args) => {
-    const scan = await runScanCandidates(args?.project);
+// At most one scan runs at a time (mirrors the pipeline's own max=1 lock). Kept
+// across calls so a later poll attaches to the SAME running scan instead of
+// starting a new one.
+let currentScanJob = null;
+// The PLUGIN's currently-spawned scan subprocess (captured via run()'s onSpawn),
+// so an approved post can abort exactly this scan and take the browser
+// immediately. Only ever references a scan the MCP server itself launched — never
+// the plist autopilot's launchd scan.
+let scanChild = null;
+// Posting takes priority over scanning (plugin pipeline only). When the user
+// approves a post, abort any in-flight plugin scan so the browser frees up at
+// once: killing the scan's bash leaves a dead lock-holder pid that the poster's
+// twitter_browser.py steals via its liveness check, so the post acquires the
+// browser without the 45s lock wait. The aborted scan just re-runs next cron
+// tick. Best-effort; never throws. Does NOT touch the plist autopilot (separate
+// process, no handle here) or any locked pipeline script.
+function preemptScanForPost() {
+    try {
+        if (scanChild && scanChild.pid && scanChild.exitCode === null) {
+            console.error(`[post] preempting in-flight plugin scan (pid ${scanChild.pid}) so the approved post takes the browser`);
+            try {
+                scanChild.kill("SIGTERM");
+            }
+            catch {
+                /* already gone */
+            }
+        }
+    }
+    catch {
+        /* best effort */
+    }
+    // Drop the long-poll job so a queued poller stops waiting on the aborted scan;
+    // the next scan_candidates call starts fresh.
+    currentScanJob = null;
+    scanChild = null;
+}
+// Per-call long-poll window. Must stay under the ~60s MCP client request timeout
+// so every scan_candidates call returns a real response before the client gives
+// up. Override with SAPS_SCAN_POLL_WAIT_MS for non-standard clients.
+const SCAN_POLL_WAIT_MS = Number(process.env.SAPS_SCAN_POLL_WAIT_MS) || 45_000;
+// After a contention hit (too_many_inflight), wait this long before launching a
+// fresh scan, so polls don't hammer the pipeline with back-to-back no-op scans
+// while the other holder finishes. Polls during the cooldown just report "busy".
+const SCAN_BUSY_COOLDOWN_MS = Number(process.env.SAPS_SCAN_BUSY_COOLDOWN_MS) || 20_000;
+let scanBusyUntil = 0;
+function scanBusy() {
+    return textContent("Another scan is already running on this machine (likely the legacy autopilot holding the " +
+        "twitter-cycle slot). This is CONTENTION, not an empty result. Call scan_candidates again in " +
+        "~20s to retry — do NOT conclude there are no candidates, and do NOT sleep; just re-call.");
+}
+// Resolve to {done:true,value} the moment `p` settles, or {done:false} after
+// `ms` — whichever is first. The job promise keeps running either way, so a
+// later poll re-attaches to it.
+function waitUpTo(p, ms) {
+    return Promise.race([
+        p.then((value) => ({ done: true, value })),
+        new Promise((resolve) => setTimeout(() => resolve({ done: false }), ms)),
+    ]);
+}
+function startScanJob(project) {
+    const job = {
+        project,
+        startedAt: Date.now(),
+        done: false,
+        promise: undefined,
+    };
+    job.promise = runScanCandidates(project)
+        .then((r) => {
+        job.result = r;
+        job.done = true;
+        return r;
+    })
+        .catch((e) => {
+        const r = {
+            batchId: null,
+            candidates: [],
+            blocked: `The scan crashed before producing a result: ${String(e?.message || e)}. ` +
+                `Call scan_candidates again to retry.`,
+        };
+        job.result = r;
+        job.done = true;
+        return r;
+    });
+    return job;
+}
+function formatScanResult(scan) {
     if (!scan.batchId) {
         return textContent(scan.blocked || "No candidates found.");
     }
@@ -1702,6 +1851,62 @@ tool("scan_candidates", {
             `"${scan.batchId}" and one entry per drafted reply ({candidate_id, reply_text}). Nothing posts ` +
             `until the user approves.`,
     });
+}
+function scanInProgress(job) {
+    const elapsed = Math.round((Date.now() - job.startedAt) / 1000);
+    return textContent(`Scan in progress (${elapsed}s elapsed). The X scan drives a real browser and usually takes ` +
+        `1-3 minutes. Call scan_candidates again RIGHT NOW to keep waiting — each call long-polls up ` +
+        `to ~${Math.round(SCAN_POLL_WAIT_MS / 1000)}s and returns the candidates the moment the scan ` +
+        `finishes. Do NOT sleep, run a background command, or do other work to bridge the gap; just ` +
+        `re-call scan_candidates until it returns candidates or reports no candidates.`);
+}
+tool("scan_candidates", {
+    title: "Scan X for reply candidates (no drafting, no posting)",
+    description: "Step 1 of a hands-free / scheduled autopilot run. Runs the scan+score half of the pipeline " +
+        "and returns the top scored X/Twitter threads worth replying to — WITHOUT drafting or posting, " +
+        "and without spending any `claude -p` budget. You (this session) then draft an on-brand reply " +
+        "for each good candidate YOURSELF and submit them with `submit_drafts`. Each candidate includes " +
+        "its candidate_id (pass it back), the thread text/author, the matched project, and engagement " +
+        "metrics. Optional `project` scopes the scan to one configured project. The scan drives a real " +
+        "browser and can take 1-3 minutes: this call long-polls and may return a `Scan in progress` " +
+        "status instead of candidates — if so, just call scan_candidates again (same args) and keep " +
+        "re-calling until it returns candidates. Never sleep or use a background wait to bridge the gap.",
+    inputSchema: { project: z.string().optional() },
+}, async (args) => {
+    // Long-poll the single in-flight scan job (see the ScanJob registry above).
+    // A finished-but-unconsumed job: hand back its result and clear the slot so a
+    // later call starts a fresh scan.
+    if (currentScanJob?.done) {
+        const finished = currentScanJob;
+        currentScanJob = null;
+        if (finished.result?.busy) {
+            scanBusyUntil = Date.now() + SCAN_BUSY_COOLDOWN_MS;
+            return scanBusy();
+        }
+        return formatScanResult(finished.result);
+    }
+    // Contention cooldown: another scan holds the slot — report busy without
+    // launching yet another no-op scan against the locked pipeline.
+    if (!currentScanJob && Date.now() < scanBusyUntil) {
+        return scanBusy();
+    }
+    // Nothing running -> start one scan (single-flight: never spawn a second
+    // run-twitter-cycle.sh that would just hit the pipeline's too_many_inflight).
+    if (!currentScanJob) {
+        currentScanJob = startScanJob(args?.project);
+    }
+    // Wait for the in-flight scan, but no longer than the client timeout allows.
+    const waited = await waitUpTo(currentScanJob.promise, SCAN_POLL_WAIT_MS);
+    if (waited.done) {
+        currentScanJob = null;
+        if (waited.value.busy) {
+            scanBusyUntil = Date.now() + SCAN_BUSY_COOLDOWN_MS;
+            return scanBusy();
+        }
+        return formatScanResult(waited.value);
+    }
+    // Still scanning — tell the agent to simply call scan_candidates again.
+    return scanInProgress(currentScanJob);
 });
 tool("submit_drafts", {
     title: "Submit drafted replies for review",
@@ -1809,8 +2014,8 @@ tool("submit_drafts", {
         `"${REVIEW_QUEUE_ID}" and the numbers to post.`);
 });
 appTool("dashboard", {
-    title: "Social Autoposter dashboard",
-    description: "Render the Social Autoposter dashboard in chat: a visual surface showing project setup, X " +
+    title: "S4L dashboard",
+    description: "Render the S4L dashboard in chat: a visual surface showing project setup, X " +
         "connection, autopilot state, and 7-day stats, with buttons to run a draft cycle, connect X, " +
         "and refresh. Use when the user asks to see the dashboard, panel, " +
         "status, or controls. ALSO call this at the end of any state-changing or results-producing " +
@@ -1824,7 +2029,7 @@ appTool("dashboard", {
     _meta: { ui: { resourceUri: PANEL_URI } },
 }, async () => {
     const snap = await buildSnapshot();
-    const human = `Social Autoposter v${snap.version}` +
+    const human = `S4L v${snap.version}` +
         (snap.update_available && snap.latest_version ? ` (update to ${snap.latest_version})` : "") +
         ` — projects ${snap.projects_ready}/${snap.projects_total} ready, ` +
         `X ${snap.x_connected ? "connected" : "not connected"}, ` +
@@ -1864,6 +2069,52 @@ appTool("dashboard", {
         return base;
     }
 });
+// ---- add your product: focused single-field onboarding widget --------------
+// A standalone ui:// widget (separate from the dashboard panel) that captures
+// the user's product URL. The widget itself reads project status and either
+// writes the website via project_config (callServerTool) or, on a cold start,
+// hands the URL to the model via sendMessage. Same inline/loopback duality as
+// `dashboard`.
+appTool("connect_product", {
+    title: "Add your product",
+    description: "Render the 'add your product' widget in chat: a single-field form where the user pastes " +
+        "their product's website. Use at the START of onboarding when you need the product URL, " +
+        "instead of asking for it in plain prose. If a project already needs a website the widget " +
+        "saves it directly; on a cold start it kicks off end-to-end setup. Hosts without UI support " +
+        "get a loopback URL.",
+    inputSchema: {},
+    outputSchema: { snapshot: z.string(), fallback_url: z.string().optional() },
+    _meta: { ui: { resourceUri: PRODUCT_LINK_URI } },
+}, async () => {
+    const snap = await buildSnapshot();
+    // Inline-capable host: paint the resource named by _meta.ui.resourceUri.
+    // Emit no text content so the chat shows only the widget (see `dashboard`).
+    if (hostRendersAppUi()) {
+        return { content: [], structuredContent: { snapshot: JSON.stringify(snap) } };
+    }
+    // No inline UI: serve the identical product-link.html from the loopback
+    // server at /product-link and return its URL.
+    try {
+        const base = await startLocalPanel();
+        const url = base.replace(/\/$/, "") + "/product-link";
+        await openInBrowser(url);
+        return {
+            content: [{
+                    type: "text",
+                    text: "Add your product: paste your product's website to begin setup.\n\n" +
+                        `This host can't render the widget inline. Loopback URL: ${url}`,
+                }],
+            structuredContent: { snapshot: JSON.stringify(snap), fallback_url: url },
+        };
+    }
+    catch (e) {
+        console.error("[social-autoposter-mcp] product-link fallback failed:", e?.message || e);
+        return {
+            content: [{ type: "text", text: "Paste your product's website in the chat to begin setup." }],
+            structuredContent: { snapshot: JSON.stringify(snap) },
+        };
+    }
+});
 // ---- show browser to user: live CDP screencast ----------------------------
 // Streams a live view of the autoposter's managed Chrome into the panel. Frames
 // travel back through the normal tool-result channel as a data: URL (which the
@@ -1935,7 +2186,7 @@ tool("show_browser_to_user", {
         frame: frame ? `data:image/jpeg;base64,${frame}` : null,
     });
 });
-registerAppResource(server, "Social Autoposter panel", PANEL_URI, { mimeType: RESOURCE_MIME_TYPE }, async () => ({
+registerAppResource(server, "S4L panel", PANEL_URI, { mimeType: RESOURCE_MIME_TYPE }, async () => ({
     contents: [
         {
             uri: PANEL_URI,
@@ -1944,8 +2195,22 @@ registerAppResource(server, "Social Autoposter panel", PANEL_URI, { mimeType: RE
         },
     ],
 }));
+registerAppResource(server, "S4L product link", PRODUCT_LINK_URI, { mimeType: RESOURCE_MIME_TYPE }, async () => ({
+    contents: [
+        {
+            uri: PRODUCT_LINK_URI,
+            mimeType: RESOURCE_MIME_TYPE,
+            text: fs.readFileSync(path.join(DIST_DIR, "product-link.html"), "utf-8"),
+        },
+    ],
+}));
 async function main() {
     initSentry();
+    // A plugin UPDATE refreshes this server (dist/) but not the materialized
+    // pipeline. Re-extract the bundled pipeline.tgz when it's newer than what's on
+    // disk, BEFORE serving, so the very first scan uses the shipped pipeline (not
+    // the version first materialized at install). Synchronous + best-effort.
+    ensurePipelineCurrent();
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error(`[social-autoposter-mcp] connected. v=${VERSION} repo=${repoDir()}`);