@weavetab/mcp 2.5.0-beta.0

package/dist/tools/cookies.js

@@ -0,0 +1,121 @@
+export async function browserCookies(session, args, _config) {
+    if (args.action === "get") {
+        // Get current page URL for scoping
+        const { frameTree } = await session.Page.getFrameTree();
+        const pageUrl = args.url ?? frameTree.frame.url;
+        const { cookies } = await session.Network.getCookies({ urls: [pageUrl] });
+        let mapped = cookies.map(c => ({
+            name: c.name,
+            value: c.value,
+            domain: c.domain,
+            path: c.path,
+            expires: c.expires,
+            httpOnly: c.httpOnly,
+            secure: c.secure,
+            sameSite: c.sameSite,
+        }));
+        // Honor the name filter
+        let found;
+        let message;
+        if (args.name) {
+            mapped = mapped.filter(c => c.name === args.name);
+            found = mapped.length > 0;
+            if (!found) {
+                message = `Cookie with name '${args.name}' was not found for the given URL.`;
+            }
+        }
+        return {
+            success: true,
+            action: "get",
+            cookies: mapped,
+            count: mapped.length,
+            ...(found !== undefined ? { found } : {}),
+            ...(message ? { message } : {})
+        };
+    }
+    if (args.action === "set") {
+        if (!args.name)
+            throw new Error("browser_cookies set: 'name' is required");
+        if (args.value === undefined)
+            throw new Error("browser_cookies set: 'value' is required");
+        // Resolve domain from current page if not provided
+        let domain = args.domain;
+        let pageUrl = args.url;
+        if (!domain || args.secure === undefined) {
+            const { frameTree } = await session.Page.getFrameTree();
+            pageUrl = pageUrl ?? frameTree.frame.url;
+            try {
+                const u = new URL(pageUrl);
+                if (!domain)
+                    domain = u.hostname;
+                // Default secure to true for https pages
+                if (args.secure === undefined && u.protocol === "https:") {
+                    args.secure = true;
+                }
+            }
+            catch {
+                if (!domain)
+                    throw new Error("browser_cookies set: could not determine domain — provide 'domain' explicitly.");
+            }
+        }
+        await session.Network.setCookie({
+            name: args.name,
+            value: args.value,
+            domain,
+            path: args.path ?? "/",
+            expires: args.expires,
+            httpOnly: args.httpOnly ?? false,
+            secure: args.secure ?? false,
+            sameSite: args.sameSite,
+        });
+        return { success: true, action: "set", name: args.name };
+    }
+    if (args.action === "delete") {
+        if (!args.name)
+            throw new Error("browser_cookies delete: 'name' is required");
+        // Resolve the URL to scope the cookie lookup
+        let pageUrl = args.url;
+        if (!pageUrl) {
+            const { frameTree } = await session.Page.getFrameTree();
+            pageUrl = frameTree.frame.url;
+        }
+        if (args.domain) {
+            await session.Network.deleteCookies({
+                name: args.name,
+                domain: args.domain,
+                path: args.path ?? "/",
+            });
+            return { success: true, action: "delete", name: args.name };
+        }
+        // deleteCookies requires the domain to match exactly how the cookie was
+        // stored (e.g. ".github.com" with a leading dot). Fetch all matching 
+        // cookies and delete each using its exact stored domain and path.
+        try {
+            const { cookies: existing } = await session.Network.getCookies({ urls: [pageUrl] });
+            const matches = existing.filter(c => c.name === args.name);
+            if (matches.length > 0) {
+                for (const cookie of matches) {
+                    await session.Network.deleteCookies({
+                        name: cookie.name,
+                        domain: cookie.domain,
+                        path: cookie.path,
+                    });
+                }
+            }
+            else {
+                // Fallback: derive hostname; won't work for subdomain cookies but attempts a best-effort deletion.
+                const domain = new URL(pageUrl).hostname;
+                await session.Network.deleteCookies({
+                    name: args.name,
+                    domain,
+                    path: args.path ?? "/",
+                });
+            }
+        }
+        catch {
+            throw new Error("browser_cookies delete: could not determine domain — provide 'domain' explicitly.");
+        }
+        return { success: true, action: "delete", name: args.name };
+    }
+    throw new Error(`browser_cookies: unknown action "${args.action}"`);
+}

package/dist/tools/design_extract.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Weavetab — tools/design_extract.ts
+ * browser_extract_design: Extract design tokens, typography, color palette,
+ * clean semantic HTML, and CSS from the current page into structured files
+ * and a compact LLM design blueprint.
+ *
+ * Saves to configured designDir (e.g. ~/.weavetab/designs/ or custom workspace directory).
+ *
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface ExtractDesignOptions {
+    /** CSS selector of the container to extract (default: 'main', falls back to 'body') */
+    selector?: string;
+    /** Format preset: 'tailwind' generates tailwind.theme.json, 'vanilla_css' generates scoped styles, 'tokens_only' extracts design tokens */
+    format?: "tailwind" | "vanilla_css" | "tokens_only";
+    /** Optional custom folder path to write extracted files into. If omitted, uses configured designDir */
+    outputDir?: string;
+    /** Optional custom name for the design bundle folder (e.g. 'resend-hero') */
+    name?: string;
+    /** Whether to capture SVG icons and image asset references (default: true) */
+    includeAssets?: boolean;
+    /** If false, keeps Weavetab overlay visible during capture (default: true -> hidden) */
+    hideOverlay?: boolean;
+}
+export interface DesignTokens {
+    meta: {
+        url: string;
+        title: string;
+        extractedAt: string;
+        selector: string;
+        viewport: {
+            width: number;
+            height: number;
+        };
+        isDarkMode: boolean;
+    };
+    cssVariables: Record<string, string>;
+    palette: {
+        backgrounds: string[];
+        text: string[];
+        borders: string[];
+        accents: string[];
+    };
+    typography: {
+        fontFamilies: string[];
+        headings: Record<string, {
+            fontFamily: string;
+            fontSize: string;
+            fontWeight: string;
+            lineHeight: string;
+            letterSpacing: string;
+            color: string;
+        }>;
+        body: {
+            fontFamily: string;
+            fontSize: string;
+            fontWeight: string;
+            lineHeight: string;
+            color: string;
+        };
+    };
+    effects: {
+        shadows: string[];
+        radii: string[];
+        backdropBlurs: string[];
+    };
+    layout: {
+        displayTypes: string[];
+        gapValues: string[];
+        paddingValues: string[];
+    };
+}
+/**
+ * Pretty-print and format raw HTML with clean 2-space indentation and semantic readability.
+ */
+export declare function beautifyHtml(rawHtml: string): string;
+export declare function browserExtractDesign(session: CDP.Client, options: ExtractDesignOptions | undefined, config: Config): Promise<{
+    success: boolean;
+    data: {
+        outputDirectory: string;
+        files: {
+            tokens: string;
+            html?: string;
+            css?: string;
+            tailwind?: string;
+            readme: string;
+        };
+        tokensSummary: {
+            colors: {
+                backgrounds: string[];
+                text: string[];
+                accents: string[];
+                borders: string[];
+            };
+            fonts: string[];
+            radii: string[];
+            shadows: string[];
+            cssVariablesCount: number;
+        };
+        htmlMetrics?: {
+            nodeCount: number;
+            svgCount: number;
+            htmlBytes: number;
+        };
+    };
+    message: string;
+}>;