@silbercue/chrome 0.2.0

package/build/index.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import { realpathSync } from "node:fs";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { startServer } from "./server.js";
+import { runLicenseCommand } from "./cli/license-commands.js";
+import { dispatchTopLevelCli } from "./cli/top-level-commands.js";
+export { startServer } from "./server.js";
+export { runLicenseCommand } from "./cli/license-commands.js";
+export { dispatchTopLevelCli } from "./cli/top-level-commands.js";
+// SEA-Detection (Phase 3b): In einem Single-Executable-Application-Bundle
+// liefert esbuild fuer `import.meta.url` ein leeres Objekt, wodurch
+// `fileURLToPath(import.meta.url)` wirft und die bisherige isMainModule-
+// Pruefung immer `false` lieferte — das Binary beendete sich dann still
+// mit Exit 0, weil weder dispatchTopLevelCli noch startServer aufgerufen
+// wurde.
+//
+// Loesung: `node:sea.isSea()` via createRequire(process.execPath) pruefen.
+// process.execPath ist in JEDEM Modus gesetzt (Source: `node`-Binary-Pfad,
+// SEA: das Binary selbst). createRequire akzeptiert jeden existierenden
+// Pfad und liefert eine Funktion, die Core-Module aufloesen kann. Damit
+// funktioniert der Check synchron in BEIDEN Modi (ESM-Source + CJS-SEA).
+const isSeaBuild = (() => {
+    try {
+        const req = createRequire(process.execPath);
+        const sea = req("node:sea");
+        if (sea && typeof sea.isSea === "function")
+            return sea.isSea();
+    }
+    catch {
+        /* fall through */
+    }
+    return false;
+})();
+const FREE_PACKAGE_NAME = "@silbercue/chrome";
+// Nur als CLI ausfuehren, wenn die Datei direkt gestartet wurde
+// (nicht wenn sie als Library importiert wird — z.B. vom Pro-Repo).
+// Robuste, symlink- und Windows-sichere Pruefung via realpath.
+const isMainModule = (() => {
+    if (isSeaBuild) {
+        // Im SEA-Bundle: Wenn ein Build-Time-Marker gesetzt ist, der NICHT auf
+        // das Free-Package zeigt (z.B. "@silbercue/chrome-pro"), dann sind
+        // wir nur eine ein-gebundelte Library — NICHT der Entry-Point.
+        if (typeof __SCC_NAME__ === "string" && __SCC_NAME__ !== "" && __SCC_NAME__ !== FREE_PACKAGE_NAME) {
+            return false;
+        }
+        // Sonst: das Binary IST der Free-Repo-Entry. `import.meta.url` ist leer
+        // und `fileURLToPath` wuerde werfen — also direkt true zurueckgeben.
+        return true;
+    }
+    if (!process.argv[1])
+        return false;
+    try {
+        const modulePath = fileURLToPath(import.meta.url);
+        const argv1Path = realpathSync(process.argv[1]);
+        return modulePath === argv1Path;
+    }
+    catch {
+        return false;
+    }
+})();
+if (isMainModule) {
+    const command = process.argv[2];
+    if (command === "license") {
+        // Bestehender `license <sub>`-Pfad — siehe src/cli/license-commands.ts
+        runLicenseCommand(process.argv.slice(3)).catch((err) => {
+            console.error(err.message);
+            process.exit(1);
+        });
+    }
+    else {
+        // Phase 2: Top-Level Subcommands (version/status/activate/deactivate/help).
+        // Wenn dispatchTopLevelCli einen Subcommand erkennt, beendet es den
+        // Prozess via process.exit(). Sonst → false zurueck → Server starten.
+        dispatchTopLevelCli(process.argv, import.meta.url)
+            .then((handled) => {
+            if (handled)
+                return;
+            return startServer();
+        })
+            .catch((err) => {
+            console.error("Fatal:", err);
+            process.exit(1);
+        });
+    }
+}

package/build/license/free-tier-config.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Free-Tier configuration.
+ * Story 9.1: Configurable limits for free-tier usage.
+ */
+export interface FreeTierConfig {
+    /** Maximum number of steps allowed in a single run_plan call (Free Tier) */
+    runPlanLimit: number;
+}
+export declare const DEFAULT_FREE_TIER_CONFIG: FreeTierConfig;
+/**
+ * Load FreeTierConfig from environment variables with fallback to defaults.
+ * Env: SILBERCUECHROME_FREE_TIER_RUN_PLAN_LIMIT (positive integer)
+ */
+export declare function loadFreeTierConfig(): FreeTierConfig;

package/build/license/free-tier-config.js

@@ -0,0 +1,18 @@
+export const DEFAULT_FREE_TIER_CONFIG = {
+    runPlanLimit: 3,
+};
+/**
+ * Load FreeTierConfig from environment variables with fallback to defaults.
+ * Env: SILBERCUECHROME_FREE_TIER_RUN_PLAN_LIMIT (positive integer)
+ */
+export function loadFreeTierConfig() {
+    const raw = process.env.SILBERCUECHROME_FREE_TIER_RUN_PLAN_LIMIT;
+    if (raw === undefined || raw === "") {
+        return { ...DEFAULT_FREE_TIER_CONFIG };
+    }
+    const parsed = parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return { ...DEFAULT_FREE_TIER_CONFIG };
+    }
+    return { runPlanLimit: parsed };
+}

package/build/license/index.d.ts

@@ -0,0 +1,4 @@
+export type { LicenseStatus } from "./license-status.js";
+export { FreeTierLicenseStatus } from "./license-status.js";
+export type { FreeTierConfig } from "./free-tier-config.js";
+export { loadFreeTierConfig, DEFAULT_FREE_TIER_CONFIG } from "./free-tier-config.js";

package/build/license/index.js

@@ -0,0 +1,2 @@
+export { FreeTierLicenseStatus } from "./license-status.js";
+export { loadFreeTierConfig, DEFAULT_FREE_TIER_CONFIG } from "./free-tier-config.js";

package/build/license/license-status.d.ts

@@ -0,0 +1,15 @@
+/**
+ * License status abstraction.
+ * Story 9.1: Minimal interface — Story 9.2 will provide the real implementation.
+ */
+export interface LicenseStatus {
+    /** Returns true when the user has an active Pro license */
+    isPro(): boolean;
+}
+/**
+ * Default implementation: always Free Tier.
+ * Replaced by a real validator in Story 9.2.
+ */
+export declare class FreeTierLicenseStatus implements LicenseStatus {
+    isPro(): boolean;
+}

package/build/license/license-status.js

@@ -0,0 +1,9 @@
+/**
+ * Default implementation: always Free Tier.
+ * Replaced by a real validator in Story 9.2.
+ */
+export class FreeTierLicenseStatus {
+    isPro() {
+        return false;
+    }
+}

package/build/overlay/session-overlay.d.ts

@@ -0,0 +1,22 @@
+import type { CdpClient } from "../cdp/cdp-client.js";
+export declare function setTierLabel(isPro: boolean): void;
+/** Set license details for the info panel. Call once after validation. */
+export declare function setLicenseInfo(key: string | undefined, lastCheck: string | undefined, customerName: string | undefined): void;
+/** Track token savings (call after each tool that saves tokens via ambient context) */
+export declare function addTokensSaved(tokens: number): void;
+/** Track last tool elapsed time */
+export declare function setLastElapsed(ms: number): void;
+export declare function injectOverlay(cdpClient: CdpClient, sessionId: string): Promise<void>;
+/**
+ * Update the overlay.
+ * Empty text = idle state (tier + metrics, logo shows image).
+ * Non-empty text = busy state (tier + metrics + action, logo = black dot).
+ */
+export declare function updateOverlayStatus(cdpClient: CdpClient, sessionId: string, text: string): Promise<void>;
+export declare function removeOverlay(cdpClient: CdpClient, sessionId: string): Promise<void>;
+/**
+ * Show an expanding, fading circle at the given viewport coordinates.
+ * Call after a click to visualize where the agent clicked.
+ */
+export declare function showClickIndicator(cdpClient: CdpClient, sessionId: string, x: number, y: number): Promise<void>;
+export declare function getToolLabel(toolName: string): string;

package/build/overlay/session-overlay.js

@@ -0,0 +1,372 @@
+// 48x48 Second Truth logo (PNG, base64)
+const LOGO_BASE64 = "iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAIAAADYYG7QAAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAAMKADAAQAAAABAAAAMAAAAADbN2wMAAADOElEQVRYCe1Xv0/qUBQWxOcPjFGJiiEMDBIdQAdC1BD4AzRENhcdWYG4MjCZGDZGVzaYddJIICESoy7CJkZNSICYoFHkh8L7YpM+Hu3tpbbd2oHcfuf0fB+n5557OjSkXmoG1AyoGRCVAY1GMzc3p9VqRT0l4Cw1ULfb3d3dnZycFOAQZZIqCGROp9Pj8YhiFXCWQZDBYPB6vQIcokwyCJqYmHA4HHq9XhQxyZkiiFqtcMC1srJis9lIHKJwiqCpqSmfz6fT6UhBR0ZGIGh0dHRra4vkIwqnCHp7ezOZTPF4HIXCG/fPzwXTzs7O+Pg4r4/MoNFovL+/Pzs7W1pa4oaG0NvbW2z+ZrO5urrKdVAE2d/fB+Xd3Z3b7e4jWFxczOfzsOIKh8N9VqVu0fcymQwoX19fDw4O0J1ZJovFgvz96Onmcrnp6WnWpOxie3v7/f0dxJ1OJxqNzszMMHzLy8vPz8+MIDhsbm4qq4ONjq10cnLCEOP39PTUarXCirqpVqssHggE2EcUX6CAPj8/WW68qY2NjbW1NexEFjw/Px8eHoYUdIqxsTFlNaF0YrEYy41FuVxOJBKNRoMFoRhdG6fbxcUF3qyyghDdbre/vLyw9NwFKuzy8rJSqcDUarX29vZcLhdaq1wHC88/PDw85OogIUjYx8fHw8PDwsICTyxZIIQulUokBbx4oVAgNXquJMrRwX0Ar+Po6IiLCyDFYrFWqwk4SDXNzs7e3NzwJoMXDIVCUimpz/v9ftQvL30f+P39jX1HDSjVAQc7Wk4fN+/t4+MjMjo4n+gaYkK32230w0FostnsgJ5MtF8KwiG6vr4+iCB0yK+vr0E8JQkym83z8/NUGnTRq6srqpsMDqihSCTCWzS94PX1tYyfbBTdOA2Oj4976blrnHSUKPKaMU8nk0muDhYJBoNiGX9Z1AwNjs9UKkWiRAfCnEmyknBJghAUIywpNMZ+DJMkKwmXJAhjpMAxjmkJoxKJmIRLEoSxEPufFBqCRHUgJg7xk5RE04tjhnx6esLeRhX34lgjeel0GkXWh1Nv/33QUF25DhCENoMhmlcQaqher3OfUhE1A2oG1Az8l4G/PP2PrT2y2dMAAAAASUVORK5CYII=";
+const OVERLAY_ID = "__sc_session_overlay__";
+function buildOverlayScript() {
+    // Static template — safe for shadow DOM injection, no user input.
+    const tmpl = `
+    <style>
+      :host { all: initial; }
+      * { box-sizing: border-box; }
+
+      @keyframes sc-fadeIn {
+        0% { opacity: 0; transform: translateY(8px); }
+        100% { opacity: 1; transform: translateY(0); }
+      }
+
+      :host {
+        --sc-font: 'SF Mono', 'Menlo', 'Monaco', 'Consolas', monospace;
+        --sc-font-size: 10px;
+        --sc-font-weight: 400;
+        --sc-letter-spacing: 0.5px;
+        --sc-color: rgba(255,255,255,0.65);
+        --sc-bar-height: 36px;
+        --sc-bar-bg: linear-gradient(0deg, rgba(0,0,0,0.65) 0%, rgba(0,0,0,0.35) 55%, transparent 100%);
+        --sc-gap: 10px;
+      }
+
+      .sc-bar {
+        position: fixed;
+        bottom: 0; left: 0; right: 0;
+        height: var(--sc-bar-height);
+        background: var(--sc-bar-bg);
+        pointer-events: none;
+        display: flex;
+        align-items: center;
+        padding: 0 14px;
+        gap: var(--sc-gap);
+        font-family: var(--sc-font);
+        font-size: var(--sc-font-size);
+        font-weight: var(--sc-font-weight);
+        letter-spacing: var(--sc-letter-spacing);
+        text-transform: uppercase;
+        color: var(--sc-color);
+        animation: sc-fadeIn 0.6s ease-out both;
+      }
+
+      .sc-logo {
+        width: 20px;
+        height: 20px;
+        border-radius: 50%;
+        background-color: #000;
+        background-size: cover;
+        background-position: center;
+        background-repeat: no-repeat;
+        flex-shrink: 0;
+        opacity: 0;
+        cursor: pointer;
+        pointer-events: auto;
+        animation: sc-fadeIn 0.5s ease-out 0.3s both;
+      }
+
+      .sc-logo.ready {
+        opacity: 0.85;
+      }
+
+      .sc-logo.busy {
+        background-image: none !important;
+      }
+
+      .sc-sep {
+        color: var(--sc-color);
+      }
+
+      .sc-text-area {
+        display: flex;
+        align-items: center;
+        gap: var(--sc-gap);
+        opacity: 0;
+        animation: sc-fadeIn 0.4s ease-out 0.5s both;
+      }
+
+      .sc-license {
+        display: none;
+        align-items: center;
+        gap: var(--sc-gap);
+      }
+
+      .sc-license.open {
+        display: flex;
+      }
+
+      .sc-license-key {
+        cursor: pointer;
+        pointer-events: auto;
+        text-decoration: underline;
+        text-decoration-color: rgba(255,255,255,0.3);
+        text-underline-offset: 2px;
+      }
+
+      .sc-license-key:hover {
+        text-decoration-color: rgba(255,255,255,0.7);
+      }
+
+      .sc-copied {
+        color: rgba(140,255,140,0.9);
+      }
+    </style>
+    <div class="sc-bar">
+      <div class="sc-logo"></div>
+      <span class="sc-text-area" id="sc-text-area"></span>
+      <span class="sc-license" id="sc-license"></span>
+    </div>`;
+    const escaped = tmpl.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
+    return `(() => {
+  if (document.getElementById('${OVERLAY_ID}')) return;
+  var LOGO = 'data:image/png;base64,` + LOGO_BASE64 + `';
+  var host = document.createElement('div');
+  host.id = '${OVERLAY_ID}';
+  host.style.cssText = 'position:fixed;bottom:0;left:0;right:0;height:0;z-index:2147483647;pointer-events:none;';
+  var sr = host.attachShadow({ mode: 'open' });
+  var t = document.createElement('template');
+  t.innerHTML = \`${escaped}\`;
+  sr.appendChild(t.content.cloneNode(true));
+  var logo = sr.querySelector('.sc-logo');
+  if (logo) {
+    logo.style.backgroundImage = 'url(' + LOGO + ')';
+    logo.addEventListener('click', function() {
+      var ta = sr.getElementById('sc-text-area');
+      var lp = sr.getElementById('sc-license');
+      var bar = sr.querySelector('.sc-bar');
+      if (!ta || !lp || !bar) return;
+      if (lp.classList.contains('open')) {
+        lp.classList.remove('open');
+        ta.style.display = 'flex';
+        bar.style.background = '';
+      } else {
+        ta.style.display = 'none';
+        lp.classList.add('open');
+        bar.style.background = 'linear-gradient(0deg, rgba(0,0,0,0.92) 0%, rgba(0,0,0,0.75) 55%, rgba(0,0,0,0.3) 85%, transparent 100%)';
+      }
+    });
+  }
+  document.documentElement.appendChild(host);
+})()`;
+}
+const OVERLAY_SCRIPT = buildOverlayScript();
+const OVERLAY_REMOVE_SCRIPT = `(() => {
+  var el = document.getElementById('${OVERLAY_ID}');
+  if (el) el.remove();
+})()`;
+let _scriptIdentifier;
+let _tierLabel = "FREE";
+let _isPro = false;
+// Cumulative token savings for Pro overlay display
+let _tokensSaved = 0;
+// Last tool elapsed time
+let _lastElapsedMs = 0;
+// License info for the panel
+let _licenseKey = "";
+let _licenseSince = "";
+let _licenseName = "";
+export function setTierLabel(isPro) {
+    _tierLabel = isPro ? "PRO" : "FREE";
+    _isPro = isPro;
+}
+/** Set license details for the info panel. Call once after validation. */
+export function setLicenseInfo(key, lastCheck, customerName) {
+    _licenseKey = key ?? "";
+    _licenseName = customerName ?? "";
+    if (lastCheck) {
+        try {
+            const d = new Date(lastCheck);
+            _licenseSince = d.toLocaleDateString("de-DE", { day: "2-digit", month: "2-digit", year: "numeric" });
+        }
+        catch {
+            _licenseSince = lastCheck;
+        }
+    }
+}
+/** Track token savings (call after each tool that saves tokens via ambient context) */
+export function addTokensSaved(tokens) {
+    _tokensSaved += tokens;
+}
+/** Track last tool elapsed time */
+export function setLastElapsed(ms) {
+    _lastElapsedMs = ms;
+}
+export async function injectOverlay(cdpClient, sessionId) {
+    try {
+        if (_scriptIdentifier) {
+            try {
+                await cdpClient.send("Page.removeScriptToEvaluateOnNewDocument", { identifier: _scriptIdentifier }, sessionId);
+            }
+            catch { /* ignore */ }
+        }
+        const { identifier } = await cdpClient.send("Page.addScriptToEvaluateOnNewDocument", { source: OVERLAY_SCRIPT }, sessionId);
+        _scriptIdentifier = identifier;
+        await cdpClient.send("Runtime.evaluate", { expression: OVERLAY_SCRIPT, awaitPromise: false }, sessionId);
+        await populateLicensePanel(cdpClient, sessionId);
+        await updateOverlayStatus(cdpClient, sessionId, "");
+    }
+    catch {
+        // Non-critical
+    }
+}
+/** Populate the license info panel. Called after inject and self-healing re-inject. */
+async function populateLicensePanel(cdpClient, sessionId) {
+    let panelHtml;
+    let copyScript = "";
+    if (_licenseKey) {
+        const masked = _licenseKey.slice(0, 8) + "\u2026" + _licenseKey.slice(-4);
+        const escapedMasked = masked.replace(/'/g, "\\'");
+        const fullKey = _licenseKey.replace(/'/g, "\\'");
+        const since = _licenseSince.replace(/'/g, "\\'");
+        const name = _licenseName.replace(/'/g, "\\'");
+        // Order: PRO | date | key (clickable) | name
+        panelHtml = `<span>${_tierLabel}</span>`;
+        if (since)
+            panelHtml += `<span class="sc-sep">|</span><span>${since}</span>`;
+        panelHtml += `<span class="sc-sep">|</span><span>License: <span class="sc-license-key" id="sc-lk">${escapedMasked}</span></span>`;
+        if (name)
+            panelHtml += `<span class="sc-sep">|</span><span>${name}</span>`;
+        panelHtml += `<span class="sc-copied" id="sc-copied" style="display:none">COPIED</span>`;
+        copyScript = `var lk = sr.getElementById('sc-lk');
+  if (lk) lk.addEventListener('click', function() {
+    navigator.clipboard.writeText('${fullKey}');
+    var cp = sr.getElementById('sc-copied');
+    if (cp) { cp.style.display = 'inline'; setTimeout(function() { cp.style.display = 'none'; }, 1500); }
+  });`;
+    }
+    else {
+        panelHtml = `<span>${_tierLabel}</span><span class="sc-sep">|</span><span>No license key</span>`;
+    }
+    const panelScript = `(() => {
+  var host = document.getElementById('${OVERLAY_ID}');
+  if (!host || !host.shadowRoot) return;
+  var sr = host.shadowRoot;
+  var lp = sr.getElementById('sc-license');
+  if (!lp) return;
+  lp.innerHTML = '${panelHtml.replace(/'/g, "\\'")}';
+  ${copyScript}
+})()`;
+    try {
+        await cdpClient.send("Runtime.evaluate", { expression: panelScript, awaitPromise: false }, sessionId);
+    }
+    catch { /* non-critical */ }
+}
+function formatMs(ms) {
+    return String(ms).padStart(4, "0") + "ms";
+}
+function formatSaved(tokens) {
+    if (tokens >= 1000)
+        return Math.round(tokens / 1000) + "k saved";
+    return tokens + " saved";
+}
+/**
+ * Update the overlay.
+ * Empty text = idle state (tier + metrics, logo shows image).
+ * Non-empty text = busy state (tier + metrics + action, logo = black dot).
+ */
+export async function updateOverlayStatus(cdpClient, sessionId, text) {
+    // Self-healing: re-inject overlay if it was removed (e.g. SPA rebuild, page reload)
+    try {
+        const { result } = await cdpClient.send("Runtime.evaluate", { expression: `!!document.getElementById('${OVERLAY_ID}')`, returnByValue: true }, sessionId);
+        if (!result.value) {
+            await cdpClient.send("Runtime.evaluate", { expression: OVERLAY_SCRIPT, awaitPromise: false }, sessionId);
+            // Set logo image after re-injection
+            await cdpClient.send("Runtime.evaluate", {
+                expression: `(() => { var h = document.getElementById('${OVERLAY_ID}'); if (h && h.shadowRoot) { var l = h.shadowRoot.querySelector('.sc-logo'); if (l) l.style.backgroundImage = 'url(data:image/png;base64,` + LOGO_BASE64 + `)'; } })()`,
+                awaitPromise: false,
+            }, sessionId);
+            // Re-populate license panel after self-healing
+            await populateLicensePanel(cdpClient, sessionId);
+        }
+    }
+    catch { /* non-critical */ }
+    const isIdle = text === "";
+    const tier = _tierLabel.replace(/'/g, "\\'");
+    const action = text.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+    const timeStr = _lastElapsedMs > 0 ? formatMs(_lastElapsedMs) : "";
+    const savedStr = _isPro && _tokensSaved > 0 ? formatSaved(_tokensSaved) : "";
+    // Build segments: tier is always shown, others conditional
+    const segments = [tier];
+    if (savedStr)
+        segments.push(savedStr);
+    if (timeStr)
+        segments.push(timeStr);
+    if (!isIdle && action)
+        segments.push(action);
+    // Join with " | " — rendered as separate spans so gap handles spacing
+    const segmentsJson = JSON.stringify(segments);
+    const script = `(() => {
+  var host = document.getElementById('${OVERLAY_ID}');
+  if (!host || !host.shadowRoot) return;
+  var sr = host.shadowRoot;
+  var logo = sr.querySelector('.sc-logo');
+  var textArea = sr.getElementById('sc-text-area');
+  if (!logo || !textArea) return;
+  logo.classList.add('ready');
+  ${isIdle ? "logo.classList.remove('busy');" : "logo.classList.add('busy');"}
+  var segs = ${segmentsJson};
+  var html = '';
+  for (var i = 0; i < segs.length; i++) {
+    if (i > 0) html += '<span class="sc-sep">|</span>';
+    html += '<span>' + segs[i] + '</span>';
+  }
+  textArea.innerHTML = html;
+})()`;
+    try {
+        await cdpClient.send("Runtime.evaluate", { expression: script, awaitPromise: false }, sessionId);
+    }
+    catch {
+        // Non-critical
+    }
+}
+export async function removeOverlay(cdpClient, sessionId) {
+    try {
+        if (_scriptIdentifier) {
+            await cdpClient.send("Page.removeScriptToEvaluateOnNewDocument", { identifier: _scriptIdentifier }, sessionId);
+            _scriptIdentifier = undefined;
+        }
+        await cdpClient.send("Runtime.evaluate", { expression: OVERLAY_REMOVE_SCRIPT, awaitPromise: false }, sessionId);
+    }
+    catch {
+        // Non-critical
+    }
+}
+/**
+ * Show an expanding, fading circle at the given viewport coordinates.
+ * Call after a click to visualize where the agent clicked.
+ */
+export async function showClickIndicator(cdpClient, sessionId, x, y) {
+    const script = `(() => {
+  var d = document.createElement('div');
+  d.style.cssText = 'position:fixed;left:${Math.round(x) - 6}px;top:${Math.round(y) - 6}px;width:12px;height:12px;border-radius:50%;background:#000;border:1px solid rgba(200,200,200,0.5);pointer-events:none;z-index:2147483646;opacity:0.8;transition:opacity 0.8s ease-out;';
+  document.documentElement.appendChild(d);
+  requestAnimationFrame(function() { d.style.opacity = '0'; });
+  setTimeout(function() { d.remove(); }, 900);
+})()`;
+    try {
+        await cdpClient.send("Runtime.evaluate", { expression: script, awaitPromise: false }, sessionId);
+    }
+    catch {
+        // Non-critical
+    }
+}
+const TOOL_LABELS = {
+    navigate: "Navigating\u2026",
+    read_page: "Reading page\u2026",
+    screenshot: "Taking screenshot\u2026",
+    click: "Clicking\u2026",
+    type: "Typing\u2026",
+    fill_form: "Filling form\u2026",
+    scroll: "Scrolling\u2026",
+    press_key: "Pressing key\u2026",
+    wait_for: "Waiting\u2026",
+    evaluate: "Evaluating JS\u2026",
+    observe: "Observing\u2026",
+    inspect_element: "Inspecting\u2026",
+    dom_snapshot: "Reading DOM\u2026",
+    file_upload: "Uploading file\u2026",
+    run_plan: "Running plan\u2026",
+    switch_tab: "Switching tab\u2026",
+    virtual_desk: "Listing tabs\u2026",
+    console_logs: "Reading console\u2026",
+    network_monitor: "Monitoring network\u2026",
+    configure_session: "Configuring\u2026",
+    handle_dialog: "Handling dialog\u2026",
+    tab_status: "Checking tab\u2026",
+};
+export function getToolLabel(toolName) {
+    return TOOL_LABELS[toolName] ?? "Working\u2026";
+}

package/build/plan/index.d.ts

@@ -0,0 +1,7 @@
+export { executePlan } from "./plan-executor.js";
+export type { PlanStep, StepResult, PlanOptions, ErrorStrategy, SuspendConfig, SuspendedPlanResponse, PlanExecutionResult } from "./plan-executor.js";
+export { substituteVars, extractResultValue } from "./plan-variables.js";
+export type { VarsMap } from "./plan-variables.js";
+export { evaluateCondition } from "./plan-conditions.js";
+export { PlanStateStore } from "./plan-state-store.js";
+export type { SuspendedPlanState } from "./plan-state-store.js";

package/build/plan/index.js

@@ -0,0 +1,4 @@
+export { executePlan } from "./plan-executor.js";
+export { substituteVars, extractResultValue } from "./plan-variables.js";
+export { evaluateCondition } from "./plan-conditions.js";
+export { PlanStateStore } from "./plan-state-store.js";

package/build/plan/plan-conditions.d.ts

@@ -0,0 +1,12 @@
+import type { VarsMap } from "./plan-variables.js";
+/**
+ * Evaluate a simple condition expression against the vars map.
+ * Supports: ==, ===, !=, !==, >, <, >=, <=, &&, ||, !
+ * Variables via $varName syntax.
+ * String literals via single or double quotes.
+ * Number literals, boolean literals (true/false), null.
+ *
+ * SECURITY: No dynamic code evaluation. Parser-based.
+ * Unknown variables evaluate to undefined.
+ */
+export declare function evaluateCondition(expression: string, vars: VarsMap): boolean;