@silbercue/chrome 0.2.0

package/build/cli/license-commands.js

@@ -0,0 +1,199 @@
+/**
+ * CLI commands for license management.
+ * Story 9.4: Thin CLI layer — reads/deletes cache directly.
+ * Story 15.5: LicenseValidator entfernt, activate gibt Pro-Feature-Hinweis.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+/** Grace period constant (7 days). */
+const GRACE_PERIOD_MS = 604_800_000;
+/** Default cache directory. */
+function getCacheDir() {
+    return path.join(os.homedir(), ".silbercuechrome");
+}
+/**
+ * Parses CLI args and dispatches to the correct subcommand.
+ * Exported for testability — `src/index.ts` calls this.
+ */
+export async function runLicenseCommand(args) {
+    const subcommand = args[0];
+    switch (subcommand) {
+        case "status":
+            return licenseStatus();
+        case "activate":
+            return licenseActivate(args[1]);
+        case "deactivate":
+            return licenseDeactivate();
+        default:
+            printUsage();
+            process.exit(1);
+    }
+}
+/**
+ * Parses CLI arguments and returns the parsed command.
+ * Pure function — exported for unit-testing the routing logic
+ * without side effects.
+ */
+export function parseLicenseCommand(argv) {
+    // argv is process.argv.slice(3), i.e. everything after "license"
+    const subcommand = argv[0];
+    const key = argv[1];
+    return { subcommand, key };
+}
+/**
+ * Masks a license key for display: first 4 + "..." + last 4.
+ * Keys shorter than 10 characters are fully masked.
+ */
+export function maskKey(key) {
+    if (!key || key.length < 10)
+        return "****";
+    return `${key.slice(0, 4)}...${key.slice(-4)}`;
+}
+// ---------------------------------------------------------------------------
+// Subcommands
+// ---------------------------------------------------------------------------
+/** `license status` — read-only, no remote call. */
+async function licenseStatus() {
+    const cacheDir = getCacheDir();
+    const cache = readCacheDirectly(cacheDir);
+    console.log("SilbercueChrome License Status");
+    console.log("===============================");
+    if (!cache) {
+        console.log("Tier:          Free");
+        console.log("License Key:   Nicht konfiguriert");
+        console.log("");
+        console.log("Um Pro zu aktivieren: silbercuechrome license activate <key>");
+        return;
+    }
+    if (cache.valid) {
+        console.log("Tier:          Pro");
+        console.log(`License Key:   ${maskKey(cache.key)}`);
+        console.log(`Last Check:    ${formatDate(cache.lastCheck)}`);
+        console.log(`Gueltig bis:   ${formatValidUntil(cache)}`);
+        const gracePeriodInfo = formatGracePeriod(cache.lastCheck);
+        if (gracePeriodInfo) {
+            console.log(`Grace Period:  ${gracePeriodInfo}`);
+        }
+        if (cache.features && cache.features.length > 0) {
+            console.log(`Features:      ${cache.features.join(", ")}`);
+        }
+    }
+    else {
+        console.log("Tier:          Free");
+        console.log(`License Key:   ${maskKey(cache.key)}`);
+        console.log("Status:        Key ungueltig");
+        console.log("");
+        console.log("Um Pro zu aktivieren: silbercuechrome license activate <key>");
+    }
+}
+/**
+ * `license activate <key>` — Pro-Feature: Hinweis auf SilbercueChrome Pro.
+ * Story 15.5: LicenseValidator ist im Pro-Repo, activate ist nur dort verfuegbar.
+ */
+async function licenseActivate(_key) {
+    console.log("License-Aktivierung ist ein Pro-Feature.");
+    console.log("Installiere SilbercueChrome Pro fuer License-Key-Validierung:");
+    console.log("  npm install silbercuechrome-pro");
+    console.log("");
+    console.log("Mehr Infos: https://silbercuechrome.com/pro");
+    process.exit(1);
+}
+/** `license deactivate` — deletes cache file. */
+function licenseDeactivate() {
+    const cacheDir = getCacheDir();
+    const cachePath = path.join(cacheDir, "license-cache.json");
+    try {
+        fs.unlinkSync(cachePath);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== "ENOENT") {
+            console.log(`Fehler beim Loeschen der Cache-Datei: ${err.message}`);
+            process.exit(1);
+            return;
+        }
+        // ENOENT — file doesn't exist, that's fine (idempotent)
+    }
+    console.log("License deaktiviert — Server laeuft im Free-Tier.");
+    console.log("Um Pro wieder zu aktivieren: silbercuechrome license activate <key>");
+    process.exit(0);
+}
+/** Prints usage help for unknown subcommands. */
+function printUsage() {
+    console.log("SilbercueChrome License Management");
+    console.log("");
+    console.log("Usage:");
+    console.log("  silbercuechrome license status              Lizenz-Status anzeigen");
+    console.log("  silbercuechrome license activate <key>      License-Key aktivieren");
+    console.log("  silbercuechrome license deactivate          License-Key deaktivieren");
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Reads the cache file directly (no remote call). */
+function readCacheDirectly(cacheDir) {
+    try {
+        const raw = fs.readFileSync(path.join(cacheDir, "license-cache.json"), "utf-8");
+        const parsed = JSON.parse(raw);
+        // Runtime validation — reject structurally invalid cache
+        if (typeof parsed.valid !== "boolean" ||
+            typeof parsed.lastCheck !== "string" ||
+            typeof parsed.key !== "string") {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/** Formats an ISO date string for human-readable display. */
+function formatDate(isoString) {
+    const ts = Date.parse(isoString);
+    if (Number.isNaN(ts))
+        return "Unbekannt";
+    const d = new Date(ts);
+    const yyyy = d.getUTCFullYear();
+    const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
+    const dd = String(d.getUTCDate()).padStart(2, "0");
+    const hh = String(d.getUTCHours()).padStart(2, "0");
+    const min = String(d.getUTCMinutes()).padStart(2, "0");
+    return `${yyyy}-${mm}-${dd} ${hh}:${min} UTC`;
+}
+/**
+ * Formats the grace-period status for display.
+ * Returns null if lastCheck is invalid or not applicable.
+ */
+function formatGracePeriod(lastCheck) {
+    const ts = Date.parse(lastCheck);
+    if (Number.isNaN(ts))
+        return null;
+    const age = Date.now() - ts;
+    if (age < 0)
+        return "Unbekannt (Systemzeit-Problem)";
+    const remaining = GRACE_PERIOD_MS - age;
+    if (remaining <= 0)
+        return "Abgelaufen";
+    const days = Math.floor(remaining / (24 * 60 * 60 * 1000));
+    const hours = Math.floor((remaining % (24 * 60 * 60 * 1000)) / (60 * 60 * 1000));
+    if (days > 0) {
+        return `${days} Tag${days !== 1 ? "e" : ""} ${hours} Stunde${hours !== 1 ? "n" : ""} verbleibend`;
+    }
+    return `${hours} Stunde${hours !== 1 ? "n" : ""} verbleibend`;
+}
+/**
+ * Formats the "valid until" date from cache.
+ * If validUntil is present in the cache, uses that directly.
+ * Otherwise falls back to lastCheck + 7 days (grace period).
+ */
+function formatValidUntil(cache) {
+    if (cache.validUntil) {
+        return formatDate(cache.validUntil);
+    }
+    // Fallback: lastCheck + grace period (7 days)
+    const ts = Date.parse(cache.lastCheck);
+    if (Number.isNaN(ts))
+        return "Unbekannt";
+    return formatDate(new Date(ts + GRACE_PERIOD_MS).toISOString());
+}

package/build/cli/top-level-commands.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Anzahl Tools die der Free-Tier MCP-Server registriert.
+ *
+ * WICHTIG: Diese Konstante MUSS aktuell gehalten werden, wenn Tools im
+ * Registry hinzugefuegt oder entfernt werden. Quelle der Wahrheit ist der
+ * smoke-test (`test-hardest/smoke-test.mjs`) — bei Aenderungen muss die
+ * Zahl hier nachgezogen werden.
+ *
+ * Stand 2026-04-07 (nach Phase 1): 21 Free-Tools (3 Tools sind Pro-gated:
+ * dom_snapshot, switch_tab, virtual_desk → werden ueber featureGate
+ * geblockt aber trotzdem in tools/list angezeigt).
+ *
+ * Free-User sehen also 21 nutzbare + 3 gated = 22 Tools insgesamt.
+ * Pro-Zaehlung in der Pro-Variante: 22 + inspect_element = 23.
+ */
+export declare const FREE_TIER_TOOL_COUNT = 21;
+/**
+ * URL fuer Pro-Upgrade. Wird in `status`-Output und Aktivierungs-Hinweisen
+ * gezeigt.
+ */
+export declare const UPGRADE_URL = "https://polar.sh/silbercuechrome/silbercuechrome-pro";
+/**
+ * Liest die Version aus `package.json` relativ zur kompilierten JS-Datei.
+ *
+ * Robustness: Sucht von `import.meta.url` ausgehend nach oben — funktioniert
+ * sowohl im `build/`-Layout als auch im `src/`-Layout (Tests via vitest).
+ *
+ * SEA-Path (Phase 3b): In einem Single-Executable-Application-Bundle gibt es
+ * keinen filesystem-Pfad zur `package.json`. Stattdessen injiziert das
+ * Build-Skript Name + Version als esbuild `--define`-Konstanten. Diese werden
+ * via `typeof`-Guard erkannt — im Source-Mode bleibt die Konstante undefined
+ * und wir fallen auf den fs-Pfad zurueck.
+ */
+export declare function readPackageVersion(currentFileUrl: string): {
+    name: string;
+    version: string;
+};
+/**
+ * Pruft das erste CLI-Argument und dispatcht zu einem Subcommand.
+ * Returns:
+ *   - `true`  → Subcommand wurde erkannt und ausgefuehrt (Caller MUSS exit-en).
+ *   - `false` → Kein Subcommand erkannt, normaler Server-Start ist erlaubt.
+ *
+ * Side-effects: ruft `process.exit()` direkt am Ende eines Subcommands
+ * (zur Klarheit + um Server-Start zu verhindern).
+ */
+export declare function dispatchTopLevelCli(argv: string[], currentFileUrl: string): Promise<boolean>;
+/** Internal helper for tests — exposes the known subcommand list. */
+export declare function getKnownSubcommands(): readonly string[];

package/build/cli/top-level-commands.js

@@ -0,0 +1,222 @@
+/**
+ * Top-Level CLI Subcommands fuer SilbercueChrome (Free Tier).
+ *
+ * Phase 2 (Distribution-Setup): analog zum SilbercueSwift main.swift Pattern.
+ * Wird VOR `startServer()` in `src/index.ts` aufgerufen. Bei Match:
+ * Subcommand ausfuehren + `process.exit(0|1)`. Sonst: false zurueckgeben,
+ * damit der MCP-Server normal startet.
+ *
+ * Verfuegbare Subcommands (Free):
+ *   silbercuechrome version              — Version anzeigen
+ *   silbercuechrome status               — Free Tier Status + Tool-Anzahl
+ *   silbercuechrome activate <KEY>       — Pro-Feature-Hinweis (nur in Pro verfuegbar)
+ *   silbercuechrome deactivate           — Pro-Feature-Hinweis (nur in Pro verfuegbar)
+ *   silbercuechrome --help / -h          — Help-Text
+ *
+ * Diese Datei enthaelt KEINE Pro-Code-Imports — der Free-Repo darf NIEMALS
+ * vom Pro-Repo abhaengen (Story 15.x Constraint).
+ */
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { fileURLToPath } from "node:url";
+/**
+ * Anzahl Tools die der Free-Tier MCP-Server registriert.
+ *
+ * WICHTIG: Diese Konstante MUSS aktuell gehalten werden, wenn Tools im
+ * Registry hinzugefuegt oder entfernt werden. Quelle der Wahrheit ist der
+ * smoke-test (`test-hardest/smoke-test.mjs`) — bei Aenderungen muss die
+ * Zahl hier nachgezogen werden.
+ *
+ * Stand 2026-04-07 (nach Phase 1): 21 Free-Tools (3 Tools sind Pro-gated:
+ * dom_snapshot, switch_tab, virtual_desk → werden ueber featureGate
+ * geblockt aber trotzdem in tools/list angezeigt).
+ *
+ * Free-User sehen also 21 nutzbare + 3 gated = 22 Tools insgesamt.
+ * Pro-Zaehlung in der Pro-Variante: 22 + inspect_element = 23.
+ */
+export const FREE_TIER_TOOL_COUNT = 21;
+/**
+ * URL fuer Pro-Upgrade. Wird in `status`-Output und Aktivierungs-Hinweisen
+ * gezeigt.
+ */
+export const UPGRADE_URL = "https://polar.sh/silbercuechrome/silbercuechrome-pro";
+/** Liste der bekannten Free-Subcommands fuer Dispatch + Help. */
+const KNOWN_SUBCOMMANDS = [
+    "version",
+    "--version",
+    "-v",
+    "status",
+    "activate",
+    "deactivate",
+    "license", // bestehender Subcommand (siehe license-commands.ts)
+    "help",
+    "--help",
+    "-h",
+];
+/**
+ * Liest die Version aus `package.json` relativ zur kompilierten JS-Datei.
+ *
+ * Robustness: Sucht von `import.meta.url` ausgehend nach oben — funktioniert
+ * sowohl im `build/`-Layout als auch im `src/`-Layout (Tests via vitest).
+ *
+ * SEA-Path (Phase 3b): In einem Single-Executable-Application-Bundle gibt es
+ * keinen filesystem-Pfad zur `package.json`. Stattdessen injiziert das
+ * Build-Skript Name + Version als esbuild `--define`-Konstanten. Diese werden
+ * via `typeof`-Guard erkannt — im Source-Mode bleibt die Konstante undefined
+ * und wir fallen auf den fs-Pfad zurueck.
+ */
+export function readPackageVersion(currentFileUrl) {
+    // Build-time constants (SEA / bundled mode)
+    if (typeof __SCC_VERSION__ === "string" &&
+        __SCC_VERSION__ !== "" &&
+        typeof __SCC_NAME__ === "string" &&
+        __SCC_NAME__ !== "") {
+        return { name: __SCC_NAME__, version: __SCC_VERSION__ };
+    }
+    try {
+        const here = fileURLToPath(currentFileUrl);
+        let dir = path.dirname(here);
+        // Hoch-Suche nach package.json (max 6 Ebenen, um Endlosschleifen
+        // bei symlink-Loops zu verhindern).
+        for (let i = 0; i < 6; i++) {
+            const candidate = path.join(dir, "package.json");
+            if (fs.existsSync(candidate)) {
+                const raw = fs.readFileSync(candidate, "utf-8");
+                const pkg = JSON.parse(raw);
+                return {
+                    name: pkg.name ?? "@silbercue/chrome",
+                    version: pkg.version ?? "0.0.0",
+                };
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        // Fall through to fallback below.
+    }
+    return { name: "@silbercue/chrome", version: "0.0.0" };
+}
+/** Liest Cache-Datei direkt — kein Remote-Call. */
+function readLicenseCache() {
+    try {
+        const cachePath = path.join(os.homedir(), ".silbercuechrome", "license-cache.json");
+        const raw = fs.readFileSync(cachePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.valid !== "boolean" ||
+            typeof parsed.lastCheck !== "string" ||
+            typeof parsed.key !== "string") {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Pruft das erste CLI-Argument und dispatcht zu einem Subcommand.
+ * Returns:
+ *   - `true`  → Subcommand wurde erkannt und ausgefuehrt (Caller MUSS exit-en).
+ *   - `false` → Kein Subcommand erkannt, normaler Server-Start ist erlaubt.
+ *
+ * Side-effects: ruft `process.exit()` direkt am Ende eines Subcommands
+ * (zur Klarheit + um Server-Start zu verhindern).
+ */
+export async function dispatchTopLevelCli(argv, currentFileUrl) {
+    const command = argv[2];
+    if (!command)
+        return false;
+    // Sub-Subcommand "license <...>" wird vom existierenden license-commands.ts
+    // Pfad in src/index.ts behandelt — hier NICHT abfangen.
+    if (command === "license")
+        return false;
+    switch (command) {
+        case "version":
+        case "--version":
+        case "-v": {
+            const { name, version } = readPackageVersion(currentFileUrl);
+            console.log(`${name} ${version}`);
+            process.exit(0);
+            // unreachable but keeps tsc happy in mocked-exit tests
+            return true;
+        }
+        case "status": {
+            const { name, version } = readPackageVersion(currentFileUrl);
+            const cache = readLicenseCache();
+            console.log(`${name} ${version}`);
+            console.log("");
+            // Free-Repo sieht IMMER Free-Tier (auch wenn ein Pro-Cache existiert,
+            // weil der Validator im Pro-Repo lebt). Wir zeigen aber, ob ein Cache
+            // existiert, damit der User Bescheid weiss.
+            console.log(`Tier:   Free`);
+            console.log(`Tools:  ${FREE_TIER_TOOL_COUNT} available`);
+            if (cache && cache.valid) {
+                console.log("");
+                console.log("A license cache was found, but license validation requires");
+                console.log("the Pro tier. Install @silbercue/chrome-pro to activate.");
+            }
+            console.log("");
+            console.log(`Upgrade to Pro: ${UPGRADE_URL}`);
+            process.exit(0);
+            return true;
+        }
+        case "activate": {
+            console.log("License activation requires the Pro tier.");
+            console.log("");
+            console.log("Install SilbercueChrome Pro to validate license keys:");
+            console.log("  npm install -g @silbercue/chrome-pro");
+            console.log("");
+            console.log(`More info: ${UPGRADE_URL}`);
+            process.exit(1);
+            return true;
+        }
+        case "deactivate": {
+            console.log("License deactivation requires the Pro tier.");
+            console.log("");
+            console.log("Install SilbercueChrome Pro to manage license keys:");
+            console.log("  npm install -g @silbercue/chrome-pro");
+            console.log("");
+            console.log(`More info: ${UPGRADE_URL}`);
+            process.exit(1);
+            return true;
+        }
+        case "help":
+        case "--help":
+        case "-h": {
+            printHelp();
+            process.exit(0);
+            return true;
+        }
+        default:
+            // Unbekannter Subcommand → Server-Start erlauben (z.B. fuer
+            // zukuenftige Subcommands oder MCP-Stdio-Modus ohne argv).
+            return false;
+    }
+}
+/** Druckt den Free-Tier Help-Text. */
+function printHelp() {
+    console.log("SilbercueChrome MCP Server (Free Tier)");
+    console.log("");
+    console.log("Usage:");
+    console.log("  silbercuechrome [command]");
+    console.log("");
+    console.log("Commands:");
+    console.log("  version                Show version information");
+    console.log("  status                 Show current tier and tool count");
+    console.log("  activate <KEY>         Activate Pro license (requires Pro tier)");
+    console.log("  deactivate             Deactivate Pro license (requires Pro tier)");
+    console.log("  license <subcommand>   License management (status/activate/deactivate)");
+    console.log("  help                   Show this help text");
+    console.log("");
+    console.log("Without a command, starts the MCP server on stdio.");
+    console.log("");
+    console.log(`Upgrade to Pro: ${UPGRADE_URL}`);
+}
+/** Internal helper for tests — exposes the known subcommand list. */
+export function getKnownSubcommands() {
+    return KNOWN_SUBCOMMANDS;
+}

package/build/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export type { ProHooks, ToolRegistryPublic, A11yTreePublic, A11yTreeDiffs, } from "./pro-hooks.js";
+export { registerProHooks, getProHooks, proFeatureError } from "./pro-hooks.js";

package/build/hooks/index.js

@@ -0,0 +1 @@
+export { registerProHooks, getProHooks, proFeatureError } from "./pro-hooks.js";

package/build/hooks/pro-hooks.d.ts

@@ -0,0 +1,126 @@
+import type { ToolResponse } from "../types.js";
+import type { LicenseStatus } from "../license/license-status.js";
+import type { PlanStep, ErrorStrategy } from "../plan/plan-executor.js";
+import type { VarsMap } from "../plan/plan-variables.js";
+import type { CdpClient } from "../cdp/cdp-client.js";
+import type { SessionManager } from "../cdp/session-manager.js";
+import type { ElementClassification, SnapshotMap, DOMChange } from "../cache/a11y-tree.js";
+/**
+ * Story 15.2: Minimales Public-Interface, das das Pro-Repo verwendet,
+ * um zusaetzliche MCP-Tools zu registrieren. Dependency Inversion — das
+ * Pro-Repo muss nicht die volle `ToolRegistry`-Klasse kennen.
+ */
+export interface ToolRegistryPublic {
+    /**
+     * Registriert ein neues MCP-Tool in der Free-Repo-Registry.
+     * Wird vom Pro-Repo ueber den `registerProTools`-Hook aufgerufen.
+     */
+    registerTool(name: string, description: string, schema: Record<string, unknown>, handler: (params: Record<string, unknown>, sessionIdOverride?: string) => Promise<ToolResponse>): void;
+    /** Story 16.4: CDP-Client fuer Pro-Tool-Handler (z.B. inspect_element). */
+    readonly cdpClient: CdpClient;
+    /** Story 16.4: Aktuelle SessionId — aendert sich bei Tab-Wechsel/Reconnect. */
+    readonly sessionId: string;
+    /** Story 16.4: SessionManager fuer OOPIF-Support (optional). */
+    readonly sessionManager?: SessionManager;
+}
+/**
+ * Story 15.3: Public-Interface fuer den a11yTree-Cache.
+ * Das Pro-Repo verwendet diese Methoden im onToolResult-Hook fuer die
+ * 3-Stufen-Klick-Analyse (classifyRef → waitForAXChange → diffSnapshots → formatDomDiff).
+ *
+ * `diffSnapshots` und `formatDomDiff` sind logisch Static-Methoden des
+ * Tree-Processors, werden aber ZUSAETZLICH hier exponiert, damit das Pro-Repo
+ * die gesamte 3-Stufen-Analyse ueber ein einziges `context.a11yTree`-Objekt
+ * fahren kann (siehe AC #5).
+ */
+export interface A11yTreePublic {
+    /** Klassifiziert ein Ref (widget-state/clickable/disabled/static). 0 CDP-Calls. */
+    classifyRef(ref: string): ElementClassification;
+    /** Leichtgewichtiger Snapshot fuer DOM-Diff. 0 CDP-Calls. */
+    getSnapshotMap(): SnapshotMap;
+    /** Compact Snapshot mit Headings/Alerts/Interaktiven Elementen. 0 CDP-Calls. */
+    getCompactSnapshot(maxTokens?: number): string | null;
+    /** Haelt den Tree frisch — liest via CDP Accessibility.getFullAXTree. */
+    refreshPrecomputed(client: CdpClient, sessionId: string, manager?: SessionManager): Promise<void>;
+    /** Setzt den Cache zurueck (bei Navigate oder SPA-Route-Wechsel). */
+    reset(): void;
+    /** Aktuelle URL des letzten Refreshs — fuer Diff-Header. */
+    readonly currentUrl: string;
+    /** Berechnet den Diff zweier Snapshots (delegiert an A11yTreeProcessor). */
+    diffSnapshots(before: SnapshotMap, after: SnapshotMap): DOMChange[];
+    /** Formatiert einen Diff als LLM-taugliche Kontextzeile. */
+    formatDomDiff(changes: DOMChange[], url?: string): string | null;
+}
+/**
+ * Story 15.3: Public-Interface fuer die Static-Methoden des Tree-Processors.
+ * `diffSnapshots` und `formatDomDiff` sind Static-Methoden auf `A11yTreeProcessor`;
+ * sie werden als separates Objekt im Hook-Context uebergeben, um die Instance-API
+ * (`A11yTreePublic`) sauber getrennt zu halten.
+ *
+ * Hinweis: Die gleichen Methoden sind auch direkt auf `A11yTreePublic`
+ * verfuegbar — `A11yTreeDiffs` bleibt als Backward-Compat-Alias erhalten.
+ */
+export interface A11yTreeDiffs {
+    diffSnapshots(before: SnapshotMap, after: SnapshotMap): DOMChange[];
+    formatDomDiff(changes: DOMChange[], url?: string): string | null;
+}
+/** Erweiterungspunkte fuer Pro-Features. */
+export interface ProHooks {
+    /** Prueft ob ein Tool im aktuellen Lizenz-Tier ausfuehrbar ist. */
+    featureGate?: (toolName: string) => {
+        allowed: boolean;
+        message?: string;
+    };
+    /** Modifiziert Tool-Parameter vor der Ausfuehrung. Null = keine Aenderung. */
+    enhanceTool?: (toolName: string, params: Record<string, unknown>) => Record<string, unknown> | null;
+    /**
+     * Story 15.3: Modifiziert die Tool-Response nach der Ausfuehrung —
+     * zentrales Ambient-Context-Enrichment-Hook. Async + Context-Parameter.
+     *
+     * Breaking Change gegenueber der alten Sync-Signatur `(name, result) => ToolResponse`.
+     * Der Pro-Repo implementiert hier die 3-Stufen-Klick-Analyse
+     * (classifyRef → waitForAXChange → diffSnapshots → formatDomDiff).
+     */
+    onToolResult?: (toolName: string, result: ToolResponse, context: {
+        a11yTree: A11yTreePublic;
+        a11yTreeDiffs: A11yTreeDiffs;
+        waitForAXChange?: (timeoutMs: number) => Promise<boolean>;
+        cdpClient: CdpClient;
+        sessionId: string;
+        sessionManager?: SessionManager;
+    }) => Promise<ToolResponse>;
+    /** Liefert den LicenseStatus — Pro-Repo injiziert hier den LicenseValidator. */
+    provideLicenseStatus?: () => Promise<LicenseStatus>;
+    /** Pro-Repo registriert hier die Multi-Tab-Parallel-Engine (Story 15.4). */
+    executeParallel?: (groups: Array<{
+        tab: string;
+        steps: PlanStep[];
+    }>, registryFactory: (tabTargetId: string) => Promise<{
+        executeTool: (name: string, params: Record<string, unknown>) => Promise<ToolResponse>;
+    }>, options?: {
+        vars?: VarsMap;
+        errorStrategy?: ErrorStrategy;
+        concurrencyLimit?: number;
+    }) => Promise<ToolResponse>;
+    /**
+     * Story 15.2: Pro-Repo registriert hier zusaetzliche MCP-Tools
+     * (z.B. inspect_element). Wird einmalig waehrend
+     * `ToolRegistry.registerAll()` aufgerufen.
+     */
+    registerProTools?: (registry: ToolRegistryPublic) => void;
+    /**
+     * Story 15.2: Pro-Repo modifiziert das evaluate-Result fuer
+     * Visual Feedback (Geometry-Diff + Clip-Screenshot). Wird nur
+     * fuer erfolgreiche Eval-Calls aufgerufen.
+     */
+    enhanceEvaluateResult?: (expression: string, result: ToolResponse, context: {
+        cdpClient: CdpClient;
+        sessionId?: string;
+    }) => Promise<ToolResponse>;
+}
+/** Registriert Pro-Hook-Implementierungen. Aufgerufen vom Pro-Repo vor startServer(). */
+export declare function registerProHooks(hooks: ProHooks): void;
+/** Gibt die aktuell registrierten Hooks zurueck. */
+export declare function getProHooks(): ProHooks;
+/** Einheitliche Pro-Feature Error-Response. */
+export declare function proFeatureError(toolName: string): ToolResponse;

package/build/hooks/pro-hooks.js

@@ -0,0 +1,17 @@
+let _hooks = {};
+/** Registriert Pro-Hook-Implementierungen. Aufgerufen vom Pro-Repo vor startServer(). */
+export function registerProHooks(hooks) {
+    _hooks = hooks;
+}
+/** Gibt die aktuell registrierten Hooks zurueck. */
+export function getProHooks() {
+    return _hooks;
+}
+/** Einheitliche Pro-Feature Error-Response. */
+export function proFeatureError(toolName) {
+    return {
+        content: [{ type: "text", text: `${toolName} ist ein Pro-Feature — aktiviere mit 'silbercuechrome license activate <key>'` }],
+        isError: true,
+        _meta: { elapsedMs: 0, method: toolName },
+    };
+}

package/build/index.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+export { startServer } from "./server.js";
+export { runLicenseCommand } from "./cli/license-commands.js";
+export { dispatchTopLevelCli } from "./cli/top-level-commands.js";