@silbercue/chrome 0.2.0

package/build/plan/plan-variables.js

@@ -0,0 +1,71 @@
+const VAR_PATTERN = /\$(\w+)/g;
+const EXACT_VAR_PATTERN = /^\$(\w+)$/;
+/**
+ * Substitute $var references in a params object.
+ * Replaces string values matching "$varName" pattern with the value from vars.
+ * Supports nested objects and arrays.
+ * Unresolved $var references remain as-is (no error — the tool will handle invalid params).
+ */
+export function substituteVars(params, vars) {
+    return substituteObject(params, vars);
+}
+function substituteValue(value, vars) {
+    if (typeof value === "string") {
+        // Whole-string replacement: preserves type (number, boolean, object, etc.)
+        const exactMatch = value.match(EXACT_VAR_PATTERN);
+        if (exactMatch) {
+            const varName = exactMatch[1];
+            if (varName in vars) {
+                return vars[varName];
+            }
+            return value; // unresolved — keep as-is
+        }
+        // Inline replacement: string interpolation
+        if (VAR_PATTERN.test(value)) {
+            // Reset lastIndex since we used .test()
+            VAR_PATTERN.lastIndex = 0;
+            return value.replace(VAR_PATTERN, (match, varName) => {
+                if (varName in vars) {
+                    return String(vars[varName]);
+                }
+                return match; // unresolved — keep as-is
+            });
+        }
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => substituteValue(item, vars));
+    }
+    if (value !== null && typeof value === "object") {
+        return substituteObject(value, vars);
+    }
+    return value;
+}
+function substituteObject(obj, vars) {
+    const result = {};
+    for (const key of Object.keys(obj)) {
+        result[key] = substituteValue(obj[key], vars);
+    }
+    return result;
+}
+/**
+ * Extract the text content from a ToolResponse for saveAs.
+ * Concatenates all text content blocks into a single string.
+ * If the text is valid JSON, parse it and return the parsed value.
+ * Otherwise return the raw text string.
+ */
+export function extractResultValue(result) {
+    const textParts = result.content
+        .filter((c) => c.type === "text")
+        .map((c) => c.text);
+    if (textParts.length === 0) {
+        return "";
+    }
+    const text = textParts.join("\n");
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}

package/build/registry.d.ts

@@ -0,0 +1,124 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CdpClient } from "./cdp/cdp-client.js";
+import type { SessionManager } from "./cdp/session-manager.js";
+import type { DialogHandler } from "./cdp/dialog-handler.js";
+import type { TabStateCache } from "./cache/tab-state-cache.js";
+import type { ToolResponse, ConnectionStatus } from "./types.js";
+import type { ConsoleCollector } from "./cdp/console-collector.js";
+import type { NetworkCollector } from "./cdp/network-collector.js";
+import type { SessionDefaults } from "./cache/session-defaults.js";
+import { PlanStateStore } from "./plan/plan-state-store.js";
+import type { LicenseStatus } from "./license/license-status.js";
+import type { FreeTierConfig } from "./license/free-tier-config.js";
+import { z } from "zod";
+import { getProHooks } from "./hooks/pro-hooks.js";
+import type { ToolRegistryPublic } from "./hooks/pro-hooks.js";
+/**
+ * Story 16.4: Konvertiert ein JSON-Schema-Literal in eine Zod Raw Shape,
+ * damit der MCP-SDK `server.tool()` Aufruf den Schema-Check besteht.
+ *
+ * Unterstuetzte Typen:
+ * - `string` (inkl. `enum` → `z.enum`)
+ * - `boolean`
+ * - `number`
+ * - `integer` → `z.number().int()`
+ * - `array` (mit `items.type` string|number|boolean|object — verschachtelt)
+ * - `object` (rekursiv ueber `properties`/`required`)
+ * - Type-Arrays wie `["string", "null"]` → `z.union([...])`
+ * - Unbekannte Typen → `z.unknown()` als Fallback
+ *
+ * Default-Handling: Wenn ein Feld einen `default` hat, wird ausschliesslich
+ * `.default(value)` angewendet. Zod behandelt Felder mit Default in einem
+ * `z.object()` automatisch als optional (wenn der Input `undefined` ist,
+ * wird der Default eingesetzt). Erst wenn KEIN Default existiert UND das
+ * Feld nicht in `required` steht, wird `.optional()` angehaengt.
+ */
+export declare function jsonSchemaToZodShape(schema: Record<string, unknown>): Record<string, z.ZodTypeAny>;
+export declare class ToolRegistry implements ToolRegistryPublic {
+    private server;
+    cdpClient: CdpClient;
+    private _tabStateCache;
+    private _sessionId;
+    private _handlers;
+    readonly planStateStore: PlanStateStore;
+    /**
+     * Story 15.2: Delegate for `registerTool()` — set during `registerAll()`
+     * so it has access to the wrap() closure (dialog injection, response_bytes,
+     * session defaults). Pro-Repo calls `registerTool()` from within
+     * `registerProTools`, which runs inside `registerAll()` after this delegate
+     * is installed.
+     */
+    private _registerProToolDelegate;
+    /**
+     * Story 15.2: Public method exposed via `ToolRegistryPublic`. The Pro-Repo
+     * uses this from within the `registerProTools` hook to register extra
+     * MCP tools (e.g. inspect_element).
+     *
+     * Lifecycle: The delegate is installed at the start of `registerAll()`
+     * (before `registerProTools` is invoked) and cleared at the end of
+     * `registerAll()`. Calling `registerTool()` outside this window throws.
+     */
+    registerTool(name: string, description: string, schema: Record<string, unknown>, handler: (params: Record<string, unknown>, sessionIdOverride?: string) => Promise<ToolResponse>): void;
+    private _getConnectionStatus;
+    private _sessionManager;
+    private _dialogHandler;
+    private _licenseStatus;
+    private _freeTierConfig;
+    private _consoleCollector;
+    private _networkCollector;
+    private _sessionDefaults;
+    private _waitForAXChange;
+    private _contextChecked;
+    constructor(server: McpServer, cdpClient: CdpClient, sessionId: string, _tabStateCache: TabStateCache, getConnectionStatus?: () => ConnectionStatus, sessionManager?: SessionManager, dialogHandler?: DialogHandler, licenseStatus?: LicenseStatus, freeTierConfig?: FreeTierConfig, consoleCollector?: ConsoleCollector, networkCollector?: NetworkCollector, sessionDefaults?: SessionDefaults, waitForAXChange?: (timeoutMs: number) => Promise<boolean>);
+    get sessionId(): string;
+    /** Story 16.4: Public getter fuer OOPIF SessionManager (ToolRegistryPublic). */
+    get sessionManager(): SessionManager | undefined;
+    updateSession(sessionId: string): void;
+    /** Swap the CDP client and session after a successful reconnect */
+    updateClient(cdpClient: CdpClient, sessionId: string): void;
+    /** Get current connection status (connected, reconnecting, disconnected) */
+    get connectionStatus(): ConnectionStatus;
+    executeTool(name: string, params: Record<string, unknown>, sessionIdOverride?: string): Promise<ToolResponse>;
+    /**
+     * Story 15.3: Invokes the `onToolResult` Pro-Hook (if registered) to enrich
+     * the tool response with ambient context (DOM diffs, compact snapshots).
+     *
+     * The Free-Repo itself no longer contains any ambient-context orchestration —
+     * the 3-stage click analysis (classifyRef → waitForAXChange → diffSnapshots →
+     * formatDomDiff) now lives in the Pro-Repo hook implementation.
+     *
+     * Responsibilities that stay in the Free-Repo:
+     *  - FR-007: `a11yTree.reset()` on navigate — called BEFORE the hook so
+     *    stale refs never leak to the next tool call, even if the hook is
+     *    not registered.
+     *  - Error-guard: the hook is NOT invoked when `result.isError` is true,
+     *    preserving the pre-15.3 semantics.
+     *
+     * After the hook returns, the enhanced response is merged via
+     * `Object.assign(result, enhanced)` so the original `_meta` reference
+     * remains stable — later code-paths (response_bytes, estimated_tokens,
+     * suggestion injection) mutate `result._meta` in place. If the hook
+     * returns a new `_meta` object, the original reference is restored to
+     * prevent downstream mutations from writing to a detached object.
+     */
+    private _runOnToolResultHook;
+    /**
+     * Story 6.1: Inject pending dialog notifications into any tool response.
+     * Called from both executeTool() (run_plan path) and server.tool() callbacks (direct MCP path).
+     */
+    private _injectDialogNotifications;
+    /**
+     * Wrap a tool handler so dialog notifications are injected into its response.
+     * This ensures notifications reach the LLM regardless of whether the tool
+     * is called via the direct MCP path (server.tool) or via executeTool (run_plan).
+     */
+    private _wrapWithDialogInjection;
+    /**
+     * Story 9.5: Wrap a tool handler with a Pro feature gate check.
+     * If a featureGate hook is registered and returns { allowed: false },
+     * the tool is blocked with an isError response.
+     * When no hook is registered, the tool executes normally.
+     */
+    wrapWithGate<T>(toolName: string, fn: (params: T) => Promise<ToolResponse>, hooks: ReturnType<typeof getProHooks>): (params: T) => Promise<ToolResponse>;
+    registerAll(): void;
+}