@melaya/runner 1.1.50 → 1.1.51

package/dist/browserBridge.js

@@ -214,6 +214,58 @@ async function humanType(page, text) {
         await page.waitForTimeout(Math.round(d));
     }
 }
+// Minimal, safe HTML rendering of plain text for the clipboard `text/html`
+// flavor: preserves paragraph and line breaks so a paste into Google Docs /
+// rich editors keeps structure instead of collapsing to one line.
+function htmlFromPlain(t) {
+    const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    return t.split(/\n{2,}/).map((p) => `<p>${esc(p).replace(/\n/g, "<br>")}</p>`).join("") || "<p></p>";
+}
+// One-shot bulk text insert (the "paste" mode of input_text). Char-by-char
+// humanType is ~100ms/char (700s+ on an article), lands out of order in a live-
+// re-rendering editor, and never reaches a Google Docs <canvas> at all. This
+// writes the whole string to the clipboard (text/plain + text/html) and fires a
+// real Ctrl/Cmd+V, which every surface — <input>, <textarea>, contenteditable,
+// and the Docs canvas — imports in a single operation with formatting intact.
+// Returns "paste" on success, or null when the clipboard is unavailable
+// (permission / non-secure context) so the caller can fall back to CDP
+// Input.insertText. The caller has already focused the field and run the
+// secret-field / publish gates.
+async function pasteBulkText(page, text) {
+    try {
+        const origin = new URL(page.url()).origin;
+        if (origin && origin !== "null") {
+            await page.context().grantPermissions(["clipboard-read", "clipboard-write"], { origin }).catch(() => { });
+        }
+    }
+    catch { /* opaque / non-http origin: grantPermissions would throw */ }
+    const wrote = await page.evaluate(async (args) => {
+        try {
+            const nav = navigator;
+            const CI = globalThis.ClipboardItem;
+            if (nav.clipboard?.write && CI) {
+                await nav.clipboard.write([new CI({
+                        "text/plain": new Blob([args.t], { type: "text/plain" }),
+                        "text/html": new Blob([args.h], { type: "text/html" }),
+                    })]);
+                return true;
+            }
+            if (nav.clipboard?.writeText) {
+                await nav.clipboard.writeText(args.t);
+                return true;
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }, { t: text, h: htmlFromPlain(text) }).catch(() => false);
+    if (wrote) {
+        await page.keyboard.press(process.platform === "darwin" ? "Meta+V" : "Control+V");
+        return "paste";
+    }
+    return null;
+}
 // Break a wheel scroll into a few smaller, jittered steps with pauses.
 async function humanScroll(page, dx, dy) {
     const steps = _randInt(3, 6);
@@ -1558,11 +1610,29 @@ export async function startBrowserBridge(opts) {
                             "Hand off to the human with browser_ask_user so they enter the secret; never type credentials.");
                     }
                     await humanClick(page, pt.x, pt.y);
-                    // Clear-then-type: select-all + humanized type preserves site key handlers.
+                    // Clear-then-type: select-all first so both paths REPLACE the field.
                     await page.keyboard.press(process.platform === "darwin" ? "Meta+A" : "Control+A").catch(() => { });
                     await humanPause(page, 40, 120);
-                    await humanType(page, text);
-                    return { typed: text.length };
+                    // Entry strategy. "human" = per-char cadence (anti-bot, short fields);
+                    // "paste" = one-shot bulk insert; omitted/"auto" = paste for long text
+                    // (char-by-char would blow the 20s tool timeout and scramble on a live
+                    // editor / never reach a Docs canvas). Short text keeps humanType so the
+                    // anti-bot cadence and site keystroke handlers still fire.
+                    const mode = String(args.mode ?? "auto");
+                    const usePaste = mode === "paste" || (mode !== "human" && text.length > 300);
+                    if (!usePaste) {
+                        await humanType(page, text);
+                        return { typed: text.length, via: "human" };
+                    }
+                    let via = await pasteBulkText(page, text);
+                    if (!via) {
+                        // Clipboard blocked: CDP whole-string insert (inputs/textarea/
+                        // contenteditable; not canvas). getCdp is in scope here.
+                        const cdp = await getCdp(rec, page);
+                        await cdpRace(cdp.send("Input.insertText", { text }), "Input.insertText");
+                        via = "insertText";
+                    }
+                    return { typed: text.length, via };
                 }
                 case "press_key": {
                     const key = String(args.key || "");

package/dist/browserGrantVerify.js

@@ -148,11 +148,11 @@ export const DEFAULT_CLOCK_TOLERANCE_SECONDS = 30;
  *  longer life than the issuer can mint is forged or corrupt, so it is
  *  rejected regardless of signature.
  *
- *  Raised 900s -> 4h alongside the server. Because this half ships in the
- *  runner, a server deployed ahead of a runner republish would mint grants
- *  this rejects with claims_invalid — publish the runner before, or at the
- *  same time as, the server change. */
-const MAX_LIFETIME_SECONDS = 4 * 60 * 60;
+ *  Raised 900s -> 4h -> 7d alongside the server (persistent week-long browser
+ *  sessions). Because this half ships in the runner, a server deployed ahead of
+ *  a runner republish would mint grants this rejects with claims_invalid —
+ *  publish the runner before, or at the same time as, the server change. */
+const MAX_LIFETIME_SECONDS = 7 * 24 * 60 * 60;
 function b64urlJson(part, what) {
     let buf;
     try {

package/dist/cli.js

@@ -15,6 +15,7 @@
  */
 import { Command } from "commander";
 import chalk from "chalk";
+import { reportInstallFailure } from "./installReport.js";
 import { connect } from "./connection.js";
 import { detectModels } from "./detect.js";
 // Logo colors: cyan → blue → indigo gradient (matching melaya.org)
@@ -63,6 +64,7 @@ async function main() {
         console.log(chalk.red(`  ✗ A Melaya runner is already running on this machine (pid ${lock.ownerPid}).`));
         console.log(chalk.gray("    Only one runner can run per machine. Stop the other one first"));
         console.log(chalk.gray(`    (e.g. \`kill ${lock.ownerPid}\`, or close its terminal), then start again.`));
+        await reportInstallFailure("single_instance_locked", { token: opts.token, server: opts.server });
         process.exit(1);
     }
     // Detect Python. Fast path: a supported host interpreter (3.10–3.12). If the
@@ -87,6 +89,10 @@ async function main() {
             console.log(chalk.gray("      macOS:   brew install python@3.12"));
             console.log(chalk.gray("      Linux:   sudo apt install python3.12 python3.12-venv    (or: pyenv install 3.12)"));
             console.log(chalk.gray("      Windows: winget install Python.Python.3.12"));
+            await reportInstallFailure("python_missing", {
+                token: opts.token, server: opts.server,
+                detail: py.foundVersion ? `host=${py.foundVersion}` : "none",
+            });
             process.exit(1);
         }
         python = provisioned;
@@ -185,7 +191,16 @@ async function bootstrap() {
     }
     await main();
 }
-bootstrap().catch((e) => {
+bootstrap().catch(async (e) => {
     console.error(chalk.red(`\n  Fatal: ${e.message}\n`));
+    // Token is parsed inside main(); recover it from argv so a crash BEFORE the
+    // socket still reports. Only the STAGE is sent — never the error text, which
+    // routinely carries file paths and usernames.
+    const tokArg = process.argv.find((a) => a.startsWith("--token"));
+    const srvArg = process.argv.find((a) => a.startsWith("--server"));
+    await reportInstallFailure("bootstrap_fatal", {
+        token: tokArg ? tokArg.replace(/^--token[= ]?/, "") : undefined,
+        server: srvArg ? srvArg.replace(/^--server[= ]?/, "") : undefined,
+    });
     process.exit(1);
 });

package/dist/connection.js

@@ -303,11 +303,20 @@ export async function connect(opts) {
         void _prewarmAssistantEnv();
         console.log(chalk.gray("  Waiting for pipeline runs...\n"));
     });
+    // A runner that never connects is invisible to the funnel: last_seen stays
+    // NULL and the reason dies on the user's machine. Report the stage before
+    // exiting — auth-rejected and unreachable are very different fixes.
+    let reportedConnectFailure = false;
     socket.on("connect_error", (err) => {
         spinner.fail(chalk.red(`Connection failed: ${err.message}`));
-        if (err.message.includes("Authentication")) {
+        const authRejected = err.message.includes("Authentication");
+        if (!reportedConnectFailure) {
+            reportedConnectFailure = true;
+            void import("./installReport.js").then((m) => m.reportInstallFailure(authRejected ? "socket_auth_rejected" : "socket_unreachable", { token: opts.token, server: opts.serverUrl })).catch(() => { });
+        }
+        if (authRejected) {
             console.log(chalk.yellow("  Token may be expired or revoked. Generate a new one in Settings → Connectors."));
-            process.exit(1);
+            setTimeout(() => process.exit(1), 300); // let the beacon leave the box
         }
     });
     socket.on("disconnect", (reason) => {

package/dist/installReport.d.ts

@@ -0,0 +1,12 @@
+/** The point at which the runner gave up. Keep in lockstep with the server's
+ *  META_ALLOW entry for `runner_install_failed`. */
+export type InstallFailStage = "single_instance_locked" | "python_missing" | "socket_auth_rejected" | "socket_unreachable" | "bootstrap_fatal";
+/**
+ * Best-effort telemetry for a runner that is about to exit without connecting.
+ * Awaited only so the process does not die mid-flight; it resolves either way.
+ */
+export declare function reportInstallFailure(stage: InstallFailStage, opts?: {
+    token?: string;
+    server?: string;
+    detail?: string;
+}): Promise<void>;

package/dist/installReport.js

@@ -0,0 +1,76 @@
+// packages/runner/src/installReport.ts
+//
+// Report WHY the runner never came up.
+//
+// The activation funnel could see that runner tokens were being issued and that
+// nobody ever connected — measured 2026-09-14 over 48h: **9 tokens issued, 0
+// connections, 0 local runs** — but not one reason, because every failure path
+// here ends in `process.exit(1)` on the user's own machine and the server never
+// hears about it. `runner_tokens.last_seen` stays NULL and that is the entire
+// signal. 9 → 0 is not actionable; "6 of 9 had no usable Python" is.
+//
+// This closes that gap with a single fire-and-forget POST before the exit.
+//
+// Rules it must obey, because it runs while something is already going wrong:
+//   - NEVER throws, never blocks shutdown, hard 3s timeout.
+//   - Sends a STAGE CODE, not a message. No file paths, no usernames, no
+//     hostnames, no error strings — those carry the user's directory layout and
+//     sometimes their name. The stage plus a coarse platform is what makes the
+//     number actionable; the rest is someone's home directory.
+//   - Honours MELAYA_RUNNER_NO_TELEMETRY=1.
+//   - Authenticated by the runner token the user already passed, so the server
+//     can attribute it to the account without any new credential.
+let alreadySent = false;
+/**
+ * Best-effort telemetry for a runner that is about to exit without connecting.
+ * Awaited only so the process does not die mid-flight; it resolves either way.
+ */
+export async function reportInstallFailure(stage, opts = {}) {
+    try {
+        if (alreadySent)
+            return; // one report per launch
+        alreadySent = true;
+        if (process.env.MELAYA_RUNNER_NO_TELEMETRY === "1")
+            return;
+        const token = String(opts.token || "").trim();
+        if (!token)
+            return; // nothing to attribute it to
+        const base = String(opts.server || "https://api.melaya.org").replace(/\/+$/, "");
+        // Version is read the same way connection.ts does; a dev tree without a
+        // package.json simply reports "0.0.0".
+        let version = "0.0.0";
+        try {
+            const { readFileSync } = await import("node:fs");
+            const { join, dirname } = await import("node:path");
+            const { fileURLToPath } = await import("node:url");
+            const here = dirname(fileURLToPath(import.meta.url));
+            version = String(JSON.parse(readFileSync(join(here, "..", "package.json"), "utf-8")).version || "0.0.0");
+        }
+        catch { /* non-fatal */ }
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(), 3000);
+        try {
+            await fetch(`${base}/api/v1/runner/install-report`, {
+                method: "POST",
+                headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+                // `detail` is a SHORT, bounded, non-identifying hint (e.g. the
+                // Python version actually found) — never a path or an error dump.
+                body: JSON.stringify({
+                    stage,
+                    version,
+                    platform: process.platform, // darwin | win32 | linux
+                    arch: process.arch,
+                    node: process.versions.node,
+                    ...(opts.detail ? { detail: String(opts.detail).slice(0, 60) } : {}),
+                }),
+                signal: ac.signal,
+            });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    catch {
+        /* The runner is already failing. Telemetry must never make that worse. */
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@melaya/runner",
-  "version": "1.1.50",
+  "version": "1.1.51",
   "description": "Run Melaya AI pipelines locally with your own LM Studio or Ollama models",
   "license": "UNLICENSED",
   "private": false,