chromeflow 0.11.1 → 0.12.2

package/bin/chromeflow.mjs

@@ -24760,6 +24760,10 @@ var WsBridge = class {
 import { homedir } from "node:os";
 import { join, dirname } from "node:path";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "node:fs";
+var PROMOTE_AT_SUCCESS = 2;
+var PRUNE_AT_FAILS = 2;
+var PROVISIONAL_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+var ATOM_KEYS = ["tool", "target", "selector", "recovered_via", "signal", "fragile", "reason"];
 function originKey(url) {
   if (!url) return void 0;
   try {
@@ -24772,20 +24776,49 @@ function originKey(url) {
   }
 }
 var FRAGILE_RE = /:nth-(of-type|child)\(|>\s*\w+:nth/;
+function signatureOf(steps) {
+  return JSON.stringify(steps.map((a) => [a.tool, a.target, a.selector ?? ""]));
+}
+function sanitizeAtom(a) {
+  const out = {};
+  for (const k of ATOM_KEYS) {
+    if (a[k] !== void 0) out[k] = a[k];
+  }
+  return out;
+}
+function autoLabel(k, steps) {
+  const tools = [...new Set(steps.map((s) => s.tool.replace("_element", "")))].join("+");
+  let path2 = "/";
+  try {
+    path2 = new URL(k).pathname || "/";
+  } catch {
+  }
+  return `auto: ${tools} @ ${path2}`;
+}
 var FlowStore = class {
   path;
   data;
   version;
+  now;
   // In-memory, per-session state (never persisted):
   buffer = /* @__PURE__ */ new Map();
   // notable atoms not yet committed, by origin
   surfaced = /* @__PURE__ */ new Set();
   // origins whose recall hint already fired this session
+  recalled = /* @__PURE__ */ new Set();
+  // origins whose trusted flow was actually shown this session
   lastOrigin;
-  constructor(version2, baseDir) {
+  lastAutosaved = null;
+  // most recent autosave, for save_flow to vouch for
+  constructor(version2, baseDir, now = Date.now) {
     this.version = version2;
+    this.now = now;
     this.path = join(baseDir ?? join(homedir(), ".chromeflow"), "flows.json");
     this.data = this.load();
+    this.pruneExpired();
+  }
+  nowIso() {
+    return new Date(this.now()).toISOString();
   }
   load() {
     try {
@@ -24810,10 +24843,36 @@ var FlowStore = class {
     } catch {
     }
   }
-  /** Update the "current origin" from any URL chromeflow observed. */
+  /** Drop expired provisional flows and any flow already past the fail ceiling. */
+  pruneExpired() {
+    const cutoff = this.now() - PROVISIONAL_TTL_MS;
+    let changed = false;
+    for (const [k, flows] of Object.entries(this.data.origins)) {
+      const kept = flows.filter((f) => {
+        if (f.fail_count >= PRUNE_AT_FAILS) return false;
+        if (f.tier === "provisional" && Date.parse(f.last_verified) < cutoff) return false;
+        return true;
+      });
+      if (kept.length !== flows.length) {
+        changed = true;
+        if (kept.length === 0) delete this.data.origins[k];
+        else this.data.origins[k] = kept;
+      }
+    }
+    if (changed) this.persist();
+  }
+  /**
+   * Update the "current origin". Crossing to a DIFFERENT origin first autosaves
+   * the origin we are leaving — that boundary is our best server-side proxy for
+   * "a task on that site just finished".
+   */
   noteUrl(url) {
     const k = originKey(url);
-    if (k) this.lastOrigin = k;
+    if (!k) return;
+    if (this.lastOrigin && this.lastOrigin !== k && (this.buffer.get(this.lastOrigin)?.length ?? 0) > 0) {
+      this.autoCommit(this.lastOrigin);
+    }
+    this.lastOrigin = k;
   }
   /** Buffer a notable atom against an origin (defaults to last-seen origin). */
   observe(atom, url) {
@@ -24823,16 +24882,67 @@ var FlowStore = class {
     const list = this.buffer.get(k) ?? [];
     const sig = `${atom.tool}|${atom.target}|${atom.selector ?? ""}`;
     if (list.some((a) => `${a.tool}|${a.target}|${a.selector ?? ""}` === sig)) return;
-    list.push(atom);
+    list.push(sanitizeAtom(atom));
     this.buffer.set(k, list);
   }
-  /** Compact recall hint for an origin, at most once per origin per session. */
+  /** Autosave a single origin's buffer as a provisional flow (or promote a match). */
+  autoCommit(k) {
+    const buf = this.buffer.get(k);
+    if (!buf || buf.length === 0) return;
+    this.buffer.delete(k);
+    this.upsert(k, buf, null);
+    this.lastAutosaved = { key: k, sig: signatureOf(buf) };
+    this.pruneExpired();
+    this.persist();
+  }
+  /** Flush every buffered origin. Call on shutdown and for single-origin sessions. */
+  flushAll() {
+    for (const k of [...this.buffer.keys()]) this.autoCommit(k);
+  }
+  /**
+   * Insert or reinforce a flow for an origin.
+   * label === null  → autosave: create provisional, or bump+maybe-promote a match.
+   * label is string → manual save_flow: create trusted, or promote+relabel a match.
+   */
+  upsert(k, steps, label) {
+    const now = this.nowIso();
+    const sig = signatureOf(steps);
+    const flows = this.data.origins[k] ?? [];
+    const existing = flows.find((f) => signatureOf(f.steps) === sig);
+    if (existing) {
+      existing.success_count += 1;
+      existing.last_verified = now;
+      existing.chromeflow_version = this.version;
+      if (label !== null) {
+        existing.tier = "trusted";
+        existing.task_label = label;
+      } else if (existing.success_count >= PROMOTE_AT_SUCCESS) {
+        existing.tier = "trusted";
+      }
+    } else {
+      flows.push({
+        id: `${k}#${flows.length + 1}`,
+        task_label: label ?? autoLabel(k, steps),
+        steps,
+        tier: label !== null ? "trusted" : "provisional",
+        created_at: now,
+        last_verified: now,
+        success_count: 1,
+        fail_count: 0,
+        chromeflow_version: this.version
+      });
+    }
+    this.data.origins[k] = flows;
+    return { saved: steps.length };
+  }
+  /** Compact recall hint for an origin (TRUSTED flows only), at most once per origin per session. */
   recallHint(url) {
     const k = originKey(url);
     if (!k || this.surfaced.has(k)) return "";
-    const flows = this.data.origins[k];
-    if (!flows || flows.length === 0) return "";
+    const flows = (this.data.origins[k] ?? []).filter((f) => f.tier === "trusted");
+    if (flows.length === 0) return "";
     this.surfaced.add(k);
+    this.recalled.add(k);
     const best = [...flows].sort((a, b) => b.success_count - a.success_count).slice(0, 3);
     const lines = best.map((f) => {
       const steps = f.steps.map((s, i) => {
@@ -24850,7 +24960,31 @@ ${steps}`;
 \u2139 known_flow for ${k} \u2014 prefer these proven steps over rediscovery (verify each as usual):
 ${lines.join("\n")}`;
   }
-  /** Nudge to save buffered hard-won steps, when there are uncommitted ones. */
+  /**
+   * A recalled trusted step failed on replay. Raise its fail_count; drop the flow
+   * once it crosses PRUNE_AT_FAILS. Gated on the flow having actually been recalled
+   * this session, so an unrelated failure can't ding a flow the agent never used.
+   */
+  observeFailure(url, selectorOrText) {
+    const k = originKey(url) ?? this.lastOrigin;
+    if (!k || !selectorOrText || !this.recalled.has(k)) return;
+    const flows = this.data.origins[k];
+    if (!flows) return;
+    let changed = false;
+    for (const f of flows) {
+      if (f.tier !== "trusted") continue;
+      const hit = f.steps.some((s) => s.selector === selectorOrText || s.target === selectorOrText || s.target === `selector=${selectorOrText}`);
+      if (hit) {
+        f.fail_count += 1;
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.pruneExpired();
+      this.persist();
+    }
+  }
+  /** Nudge to save buffered hard-won steps — kept as the manual instant-vouch path. */
   capturableHint(url) {
     const k = originKey(url) ?? this.lastOrigin;
     if (!k) return "";
@@ -24859,40 +24993,39 @@ ${lines.join("\n")}`;
     const reasons = [...new Set(buf.map((a) => a.reason))].slice(0, 2).join("; ");
     return `
 
-\u2139 flow_capturable: ${buf.length} hard-won step(s) on ${k} not yet saved (${reasons}). Call save_flow("<task label>") to persist them so future runs skip the trial-and-error.`;
+\u2139 flow_capturable: ${buf.length} hard-won step(s) on ${k} buffered (${reasons}). They autosave on leaving the site; call save_flow("<task label>") to trust them immediately.`;
   }
-  /** Commit the buffered atoms for an origin as a named flow. */
+  /** Manual save_flow: commit the buffered atoms for an origin as a TRUSTED flow. */
   commit(taskLabel, url) {
     const k = originKey(url) ?? this.lastOrigin;
     if (!k) return { saved: 0, origin: null, message: "No origin known yet \u2014 navigate or interact with a page first." };
     const buf = this.buffer.get(k) ?? [];
     if (buf.length === 0) {
+      if (this.lastAutosaved) {
+        const flows = this.data.origins[this.lastAutosaved.key] ?? [];
+        const f = flows.find((x) => signatureOf(x.steps) === this.lastAutosaved.sig);
+        if (f) {
+          f.tier = "trusted";
+          f.task_label = taskLabel;
+          f.last_verified = this.nowIso();
+          const promotedKey = this.lastAutosaved.key;
+          this.lastAutosaved = null;
+          this.persist();
+          return { saved: f.steps.length, origin: promotedKey, message: `Promoted the just-autosaved flow to trusted: "${taskLabel}" (${f.steps.length} steps) for ${promotedKey}.` };
+        }
+      }
       return { saved: 0, origin: k, message: `Nothing notable buffered for ${k}. Flows capture hard-won steps (a fallback fired, a verified submit, a field needing real keystrokes) \u2014 an ordinary first-try click isn't recorded.` };
     }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const sig = JSON.stringify(buf.map((a) => [a.tool, a.target, a.selector ?? ""]));
-    const flows = this.data.origins[k] ?? [];
-    const existing = flows.find((f) => f.task_label === taskLabel && JSON.stringify(f.steps.map((a) => [a.tool, a.target, a.selector ?? ""])) === sig);
-    if (existing) {
-      existing.success_count += 1;
-      existing.last_verified = now;
-      existing.chromeflow_version = this.version;
-    } else {
-      flows.push({
-        id: `${k}#${flows.length + 1}`,
-        task_label: taskLabel,
-        steps: buf,
-        created_at: now,
-        last_verified: now,
-        success_count: 1,
-        fail_count: 0,
-        chromeflow_version: this.version
-      });
-    }
-    this.data.origins[k] = flows;
     this.buffer.delete(k);
+    const { saved } = this.upsert(k, buf, taskLabel);
+    this.pruneExpired();
     this.persist();
-    return { saved: buf.length, origin: k, message: `Saved flow "${taskLabel}" (${buf.length} steps) for ${k}.` };
+    return { saved, origin: k, message: `Saved flow "${taskLabel}" (${saved} steps) for ${k} \u2014 trusted.` };
+  }
+  /** Test-only accessor: the persisted flows for an origin. */
+  _flowsFor(url) {
+    const k = originKey(url) ?? url;
+    return this.data.origins[k] ?? [];
   }
 };
 function isFragileSelector(selector) {
@@ -25022,9 +25155,12 @@ Examples: switch_to_tab({tab: 1}) for the first tab, switch_to_tab({tab: "form"}
       if (response.type !== "tabs_response") throw new Error("Unexpected response");
       const tabs = response.tabs;
       const lines = tabs.map((t) => `${t.index}. ${t.active ? "[active] " : ""}${t.title} \u2014 ${t.url}`);
+      const activeUrl = tabs.find((t) => t.active)?.url;
+      flowStore.noteUrl(activeUrl);
+      const recall = flowStore.recallHint(activeUrl);
       return {
         content: [{ type: "text", text: `Open tabs:
-${lines.join("\n")}` }]
+${lines.join("\n")}${recall}` }]
       };
     }
   );
@@ -25951,9 +26087,10 @@ Current URL: ${activeTab.url}`;
         }, actionUrl);
       }
       flowStore.noteUrl(nowUrl);
-      const recall = flowStore.recallHint(nowUrl);
+      const recall = flowStore.recallHint(actionUrl) || flowStore.recallHint(nowUrl);
       const capturable = flowStore.capturableHint(actionUrl);
       if (!r.success) {
+        flowStore.observeFailure(actionUrl, selector ?? textHint);
         return {
           content: [
             {
@@ -25970,9 +26107,9 @@ Current URL: ${activeTab.url}`;
   );
   server.tool(
     "save_flow",
-    `Persist the hard-won interaction steps chromeflow buffered for the current site as a reusable, named flow. chromeflow auto-buffers only NOTABLE resolutions (a click that needed a fallback, a verified submit, a field that needed real keystrokes) \u2014 so you just give the task a label and it commits whatever is buffered for the current origin. Next session, those steps are surfaced back as a known_flow hint so you skip the trial-and-error.
+    `Trust the hard-won interaction steps chromeflow buffered for the current site, immediately, as a named flow. chromeflow auto-buffers only NOTABLE resolutions (a click that needed a fallback, a verified submit, a field that needed real keystrokes), and AUTOSAVES them as a provisional flow when you leave the site \u2014 so memory works even if you never call this. Provisional flows are not recalled until they have been independently re-observed, or until you vouch for them here. Calling save_flow promotes the buffered steps to TRUSTED right away (an explicit "I confirm this worked"), so they are recalled next session instead of waiting to earn it.
 
-Call this when a response shows \`flow_capturable\`. Stored locally only (~/.chromeflow/flows.json), selectors/signals only \u2014 never typed text. Guidance, not autopilot: recalled steps are still verified on replay.`,
+Call this when a response shows \`flow_capturable\` and you are confident the task genuinely succeeded. Stored locally only (~/.chromeflow/flows.json), selectors/signals only \u2014 never typed text. Guidance, not autopilot: recalled steps are still verified on replay.`,
     {
       task_label: external_exports.string().describe('Short human label for what this flow accomplishes, e.g. "submit text post", "set flair and submit", "log report time".')
     },
@@ -26294,7 +26431,7 @@ ${lines.join("\n")}${shadowSection}` }] };
 }
 
 // packages/mcp-server/src/index.ts
-var PACKAGE_VERSION = true ? "0.11.1" : "dev";
+var PACKAGE_VERSION = true ? "0.12.2" : "dev";
 main().catch((err) => {
   console.error("[chromeflow] Fatal error:", err);
   process.exit(1);
@@ -26368,12 +26505,28 @@ ${tabList}`
   );
   const transport = new StdioServerTransport();
   await server.connect(transport);
+  let exited = false;
   const exitClean = (reason) => {
+    if (exited) return;
+    exited = true;
     console.error(`[chromeflow] host disconnected (${reason}), exiting.`);
+    try {
+      flowStore.flushAll();
+    } catch {
+    }
     process.exit(0);
   };
   process.stdin.on("end", () => exitClean("stdin end"));
   process.stdin.on("close", () => exitClean("stdin close"));
+  process.on("SIGTERM", () => exitClean("SIGTERM"));
+  process.on("SIGINT", () => exitClean("SIGINT"));
+  process.on("SIGHUP", () => exitClean("SIGHUP"));
+  process.on("beforeExit", () => {
+    try {
+      flowStore.flushAll();
+    } catch {
+    }
+  });
   const originalPpid = process.ppid;
   setInterval(() => {
     const ppid = process.ppid;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "chromeflow",
-  "version": "0.11.1",
-  "description": "MCP server for chromeflow — lets Claude Code or Codex CLI drive your real Chrome browser with sessions intact. Plugin install recommended; npx chromeflow for manual MCP wiring.",
+  "version": "0.12.2",
+  "description": "MCP server for chromeflow \u2014 lets Claude Code or Codex CLI drive your real Chrome browser with sessions intact. Plugin install recommended; npx chromeflow for manual MCP wiring.",
   "type": "module",
   "main": "./bin/chromeflow.mjs",
   "bin": {