@m13v/s4l 1.6.197-rc.9 → 1.6.199

package/mcp/dist/index.js

@@ -20,12 +20,12 @@ import os from "node:os";
 import path from "node:path";
 import fs from "node:fs";
 import { repoDir, runPython, run, readPlan, writePlan, planPath, } from "./repo.js";
-import { applySetup, resolveProject, personaReady, listManagedProjectStatus, ensureShortLinksDefault, ensurePersonaProject, findPersonaProject, REQUIRED_FIELDS, RECOMMENDED_FIELDS, configPath, normalizeStringList, } from "./setup.js";
+import { applySetup, resolveProject, personaReady, listManagedProjectStatus, listProjectSettings, ensureShortLinksDefault, ensurePersonaProject, findPersonaProject, REQUIRED_FIELDS, RECOMMENDED_FIELDS, configPath, normalizeStringList, } from "./setup.js";
 import { xStatus, xConnect, xDetectSources, xScanProfile, summarizeXAuth } from "./twitterAuth.js";
 import { startProvisioning, isProvisioning, readProgress, runtimeReady, readRuntime, resolvePython, resolveChrome, ensureMenubar, menubarRunning, clearMenubarStop, ensurePipelineCurrent, ensureRuntimeProvisioned, } 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, startLogStreaming, flushLogs } from "./telemetry.js";
+import { initSentry, sendHeartbeat, sendStateSnapshot, captureError, flushSentry, startLogStreaming, flushLogs, logLine } from "./telemetry.js";
 import { registerAppTool, registerAppResource, RESOURCE_MIME_TYPE, getUiCapability, } from "@modelcontextprotocol/ext-apps/server";
 import { fileURLToPath } from "node:url";
 import http from "node:http";
@@ -364,8 +364,41 @@ function withActivity(name, cb) {
         }
     };
 }
+// Tool-call telemetry: one structured relay line at the start and end of every
+// tool invocation (context "tool-call" in Cloud Logging). This is the record
+// that was missing on 2026-07-03, when reconstructing WHAT the setup agent
+// actually called (and which calls the client abandoned at its hard 60s
+// timeout) required inference from subprocess side effects. Start+end pairs
+// make abandoned/long calls visible: a start line with no end line inside the
+// expected window means the handler is still running or died. Argument VALUES
+// are never logged (they can carry persona/voice text); only the action field
+// and the argument key names.
+function withToolLog(name, cb) {
+    return async (args, extra) => {
+        const action = typeof args?.action === "string" ? args.action : undefined;
+        const argKeys = args && typeof args === "object" ? Object.keys(args).slice(0, 30) : [];
+        const startedAt = Date.now();
+        logLine("stdout", JSON.stringify({ ev: "start", tool: name, action, arg_keys: argKeys }), "tool-call");
+        try {
+            const result = await cb(args, extra);
+            logLine("stdout", JSON.stringify({ ev: "end", tool: name, action, ok: true, ms: Date.now() - startedAt }), "tool-call");
+            return result;
+        }
+        catch (e) {
+            logLine("stderr", JSON.stringify({
+                ev: "end",
+                tool: name,
+                action,
+                ok: false,
+                ms: Date.now() - startedAt,
+                error: String(e?.message || e).slice(0, 500),
+            }), "tool-call");
+            throw e;
+        }
+    };
+}
 const tool = ((name, config, cb) => {
-    const h = withActivity(name, cb);
+    const h = withToolLog(name, withActivity(name, cb));
     TOOL_HANDLERS[name] = h;
     return baseRegisterTool(name, config, h);
 });
@@ -383,7 +416,7 @@ const appTool = ((name, config, cb) => {
             throw e;
         }
     });
-    const h = withActivity(name, wrapped);
+    const h = withToolLog(name, withActivity(name, wrapped));
     TOOL_HANDLERS[name] = h;
     return registerAppTool(server, name, config, h);
 });
@@ -1072,54 +1105,79 @@ const WEBSITE_RESEARCH_INSTRUCTIONS = "PRODUCT RESEARCH (do this before saving t
     "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.";
+// Background query-seeding state. The seed run (dedup + optional live
+// supply-test against the X browser) can take 3-10+ minutes when the
+// twitter-browser lock is contended, but Claude Desktop kills any MCP tool
+// call at a hard 60s. Awaiting the seed inside set therefore GUARANTEED a
+// client timeout, and each retry stacked another seed process on the browser
+// lock (Karol, 2026-07-03). So the seed now runs fire-and-forget: `set`
+// returns as soon as the durable writes land, and retries while a seed is
+// in flight are cheap no-ops.
+const seedInFlight = new Map(); // project -> startedAt ms
 async function seedSearchQueriesForProject(project, rawQueries) {
     const agentQueries = normalizeStringList(rawQueries) ?? [];
-    let queries = [];
     if (!agentQueries.length) {
         return {
             note: " (No search_queries supplied, so the cycle will run off the seeded topics one at a time. " +
                 "To fan out, re-run with a search_queries array of ~30 X search strings you expand from these " +
                 "topics — it seeds them directly, no claude CLI.)",
+            queries: [],
+        };
+    }
+    // Echo the supplied queries back so callers can show the user the bank
+    // without waiting for persistence.
+    const queries = agentQueries.map((q) => ({ query: q }));
+    // A retry after a client-side timeout must NOT queue another seed process on
+    // the twitter-browser lock. 20 min covers the worst case (600s lock wait +
+    // the ~3 min live run); a stale entry past that is assumed dead.
+    const started = seedInFlight.get(project);
+    if (started && Date.now() - started < 20 * 60_000) {
+        return {
+            note: ` Query seeding for '${project}' is already running in the background from a previous call; ` +
+                "this retry is a safe no-op. The bank will be live within a few minutes — do NOT re-run.",
             queries,
         };
     }
     try {
         const qfile = path.join(os.tmpdir(), `saps-queries-${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", 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) {
+        seedInFlight.set(project, Date.now());
+        // Fire-and-forget: runPython keeps the output on the repo.ts tee (so the
+        // whole run still lands in the Cloud Logging relay), but the tool response
+        // does not wait for it. The script is idempotent (dedup by normalized
+        // core), so even a duplicate run after the in-flight window is harmless.
+        void runPython("scripts/seed_search_queries.py", ["--project", project, "--queries-json", qfile, "--supply-test", "auto", "--emit-json"], { timeoutMs: 900_000 })
+            .then((qseed) => {
+            const qm = /seeded=(\d+)\s+inserted=(\d+)\s+updated=(\d+)/.exec(qseed.stdout);
+            console.error(`[seed_search_queries] background seed for '${project}' finished: ` +
+                (qseed.code === 0
+                    ? qm
+                        ? `seeded=${qm[1]} inserted=${qm[2]} updated=${qm[3]}`
+                        : "ok"
+                    : `exit ${qseed.code}: ${(qseed.stderr || qseed.stdout).trim().split("\n").slice(-1)[0] || "unknown error"}`));
+        })
+            .catch((e) => {
+            console.error(`[seed_search_queries] background seed for '${project}' failed:`, e?.message || e);
+            captureError(e, { component: "seed_search_queries", project });
+        })
+            .finally(() => {
+            seedInFlight.delete(project);
             try {
-                queries = (JSON.parse(qjson.trim()).queries ?? []);
+                fs.unlinkSync(qfile);
             }
             catch {
-                /* leave empty; count note still informs the user */
+                /* best-effort cleanup */
             }
-        }
-        if (qseed.code === 0 && qm) {
-            const n = queries.length || Number(qm[1]);
-            return {
-                note: ` Seeded ${n} search quer${n === 1 ? "y" : "ies"} so the cycle can fan out instead of running a single query.`,
-                queries,
-            };
-        }
-        if (qseed.code !== 0) {
-            const qtail = (qseed.stderr || qseed.stdout).trim().split("\n").slice(-1)[0] || "unknown error";
-            return {
-                note: ` (Search queries not seeded yet — ${qtail}. The cycle still runs off the seeded topics.)`,
-                queries,
-            };
-        }
-        return { note: "", queries };
+        });
+        return {
+            note: ` Queued ${agentQueries.length} search quer${agentQueries.length === 1 ? "y" : "ies"} for ` +
+                "background seeding (dedup + live supply-test). They persist automatically within a few " +
+                "minutes and the cycle picks them up on its own — no need to wait, verify, or re-run this call.",
+            queries,
+        };
     }
     catch (e) {
+        seedInFlight.delete(project);
         return { note: ` (Search-query seeding skipped — ${e.message}.)`, queries };
     }
 }
@@ -1397,9 +1455,14 @@ tool("project_config", {
     inputSchema: {
         status: z.boolean().optional(),
         action: z
-            .enum(["connect_x", "detect_x_sources", "profile_scan"])
+            .enum(["get", "connect_x", "detect_x_sources", "profile_scan"])
             .optional()
-            .describe("connect_x = import/validate your X session in the autoposter's managed browser. " +
+            .describe("get = read the CURRENT SAVED VALUES of every project's editable fields (website, " +
+            "description, icp, voice, differentiator, search_topics, get_started_link, " +
+            "content_guardrails, content_angle) plus readiness — the read companion to editing. " +
+            "Use it before tweaking part of a nested value; the panel's Project settings section " +
+            "is built on it. " +
+            "connect_x = import/validate your X session in the autoposter's managed browser. " +
             "With an explicit setup/connect request, warn about possible keychain prompts and call " +
             "with confirm:true without waiting for another yes/no reply. Without confirm:true it " +
             "only previews the operation for users who asked to inspect it rather than run it. " +
@@ -1469,12 +1532,25 @@ tool("project_config", {
             "weight, platform, voice_relationship, booking_link, qualification, subreddit_bans, " +
             "short_links_host, short_links_live, content_angle, messaging, landing_pages, posthog. " +
             "Pass {name:'<project>', fields:{<key>:<value>, ...}}; each key SHALLOW-merges onto the " +
-            "project, REPLACING that key's whole value (read the current value via status:true first if " +
+            "project, REPLACING that key's whole value (read the current value via action:'get' first if " +
             "you only want to tweak part of a nested object, then pass the full new value). A value of " +
             "null DELETES the key. 'name' is ignored here (can't rename through this path). This is how " +
             "you edit advanced config without any raw whole-file overwrite."),
     },
 }, async (args) => {
+    // ---- Read current saved values (the panel's Project settings source) ---
+    // Whitelisted field values + readiness for every managed project and the
+    // persona. Read-only; the write path stays the validated merge below.
+    if (args.action === "get") {
+        return jsonContent({
+            action: "get",
+            projects: listProjectSettings(),
+            config_path: configPath(),
+            note: "Current saved values of each project's editable fields. To change one, call project_config " +
+                "with {name, <field>: <new value>} — it merges onto what's saved and re-seeds topics. " +
+                "extra_keys lists advanced keys editable only via the `fields` escape hatch.",
+        });
+    }
     // ---- List import sources (for the panel dropdown) ---------------------
     // Read-only browser/profile detection. Never reads the keychain or decrypts
     // a cookie, so it shows no macOS Safe Storage prompt. Lets the user pick the
@@ -1724,11 +1800,20 @@ tool("project_config", {
     // Apply mode (incremental): merge whatever fields were supplied onto the
     // named project, then report whether it's now ready or still missing fields.
     try {
-        recordOnboardingAttempt("project_ready", {
-            missing_count: 0,
-        });
+        // Editing the persona project must not touch the PRODUCT onboarding
+        // milestone (a persona is never "project_ready" in the product sense; it
+        // validates against PERSONA_REQUIRED_FIELDS inside applySetup).
+        const editingPersona = findPersonaProject()?.name === args.name;
+        if (!editingPersona) {
+            recordOnboardingAttempt("project_ready", {
+                missing_count: 0,
+            });
+        }
         const result = applySetup(args);
-        if (result.ready) {
+        if (result.persona) {
+            // no-op on the onboarding ledger; readiness is reported below as usual.
+        }
+        else if (result.ready) {
             completeOnboardingMilestone("project_ready", { missing_count: 0 });
         }
         else {
@@ -1809,6 +1894,7 @@ tool("project_config", {
             ok: true,
             project: result.project,
             action: result.created ? "created" : "updated",
+            persona: result.persona,
             ready: result.ready,
             missing_required: result.missing_required,
             topics_seeded: topicsSeeded,
@@ -1820,16 +1906,19 @@ tool("project_config", {
             fields_removed: result.fields_removed,
             config_path: configPath(),
             onboarding: onboardingSnapshot(),
-            note: (result.ready
-                ? `Project '${result.project}' is fully configured.${seedNote} Next: if X is not connected, ` +
-                    `detect sources, warn about keychain prompts, and call project_config with ` +
-                    `action:'connect_x', confirm:true immediately. Once X is connected, schedule the autopilot ` +
-                    `(queue_setup + create_scheduled_task per task); the autopilot then drafts on its own. Call the ` +
-                    `dashboard to confirm the schedule is firing (schedule_state 'ok') — that is the final step, ` +
-                    `no need to wait for or verify a draft card.`
-                : `Saved what you provided for '${result.project}'. Still need: ${result.missing_required.join(", ")}. ` +
-                    `First derive those fields from existing context, profile_scan, and website research, then ` +
-                    `call project_config again with name='${result.project}'. Ask only if a required field is genuinely unknowable.`) +
+            note: (result.persona
+                ? `Persona '${result.project}' updated.${seedNote}` +
+                    (result.ready ? "" : ` Still needs: ${result.missing_required.join(", ")}.`)
+                : result.ready
+                    ? `Project '${result.project}' is fully configured.${seedNote} Next: if X is not connected, ` +
+                        `detect sources, warn about keychain prompts, and call project_config with ` +
+                        `action:'connect_x', confirm:true immediately. Once X is connected, schedule the autopilot ` +
+                        `(queue_setup + create_scheduled_task per task); the autopilot then drafts on its own. Call the ` +
+                        `dashboard to confirm the schedule is firing (schedule_state 'ok') — that is the final step, ` +
+                        `no need to wait for or verify a draft card.`
+                    : `Saved what you provided for '${result.project}'. Still need: ${result.missing_required.join(", ")}. ` +
+                        `First derive those fields from existing context, profile_scan, and website research, then ` +
+                        `call project_config again with name='${result.project}'. Ask only if a required field is genuinely unknowable.`) +
                 advancedNote,
         });
     }
@@ -4004,7 +4093,7 @@ tool("show_browser_to_user", {
         const message = ensured.error === "no_browser"
             ? "No managed Chrome is running right now. Start a draft cycle or autopilot so there's a live browser session to show."
             : ensured.error === "no_websocket"
-                ? "This Node runtime has no WebSocket support (needs Node 21+), so a screencast can't be opened."
+                ? "This runtime has no WebSocket support, so a live screencast can't be opened. Use 'Bring to front' to see the browser window instead."
                 : "Couldn't attach to the browser: " + String(ensured.error);
         return jsonContent({ ok: false, running: false, frame: null, message });
     }
@@ -4202,6 +4291,40 @@ async function main() {
     void sendHeartbeat("startup");
     const hb = setInterval(() => void sendHeartbeat("interval"), 15 * 60_000);
     hb.unref();
+    // Ship Claude session transcripts (scheduled queue-worker runs + s4l repo
+    // sessions) to the Cloud Logging relay so a user's session can be
+    // reconstructed remotely (the artifact that was missing for the 2026-07-03
+    // Karol setup investigation). The script is incremental (per-file byte
+    // offsets), self-locking, and scope-limited to s4l-related project dirs.
+    // Best-effort; opt out with S4L_TRANSCRIPT_RELAY=0.
+    if ((process.env.S4L_TRANSCRIPT_RELAY ?? "1") !== "0") {
+        let transcriptRelayRunning = false;
+        const relayTranscripts = () => {
+            if (transcriptRelayRunning)
+                return;
+            transcriptRelayRunning = true;
+            runPython("scripts/relay_session_transcripts.py", ["--max-lines", "600"], {
+                timeoutMs: 120_000,
+            })
+                .catch((e) => {
+                console.error("[social-autoposter-mcp] transcript relay failed:", e?.message || e);
+            })
+                .finally(() => {
+                transcriptRelayRunning = false;
+            });
+        };
+        const trBoot = setTimeout(relayTranscripts, 90_000); // off the boot hot path
+        trBoot.unref();
+        const tr = setInterval(relayTranscripts, 5 * 60_000);
+        tr.unref();
+    }
+    // Sync the install's configuration state (config.json, persona corpus, mode,
+    // queues, onboarding ledger) to the backend. Hash-gated on the interval, so
+    // the recurring tick only POSTs when something actually changed; setup.ts
+    // additionally fires it right after every config write.
+    void sendStateSnapshot("startup");
+    const ss = setInterval(() => void sendStateSnapshot("interval"), 15 * 60_000);
+    ss.unref();
 }
 main().catch(async (err) => {
     console.error("[social-autoposter-mcp] fatal:", err);