@weavetab/mcp 2.5.0-beta.0

package/dist/tools/find.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Weavetab — tools/find.ts
+ * browser_find: DEPRECATED — prefer browser_click with action:'find' which uses the same
+ * resolution chain but with memory-intercept and URC cache for 10x faster results.
+ * This shim is kept for backward compatibility only.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface FindOptions {
+    query: string;
+    role?: string;
+    fuzzy?: boolean;
+    matchPlaceholder?: boolean;
+    matchTitle?: boolean;
+}
+export interface FindResult {
+    success: boolean;
+    found: boolean;
+    rect?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    nodeId?: number;
+    selector?: string;
+    label?: string;
+}
+export declare function browserFind(session: CDP.Client, options: FindOptions, _config: Config): Promise<FindResult>;

package/dist/tools/find.js

@@ -0,0 +1,60 @@
+export async function browserFind(session, options, _config) {
+    const { query, role, fuzzy = true, matchPlaceholder = true, matchTitle = true } = options;
+    if (!query)
+        throw new Error("browser_find requires a query string");
+    // Find tool must search ALL elements, not just interactive ones.
+    const { result } = await session.Runtime.evaluate({
+        expression: `(function(q) {
+      function norm(s) { return (s || '').toLowerCase().replace(/[.\\u2026\\s]+/g, ' ').trim(); }
+      var qLow = norm(q);
+      var walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT, null, false);
+      var matches = [];
+      while (walker.nextNode()) {
+        var node = walker.currentNode;
+        if (node.nodeType === Node.TEXT_NODE) {
+          var t = norm(node.textContent);
+          if (t && t.includes(qLow)) {
+            matches.push(node.parentElement);
+          }
+        } else if (node.nodeType === Node.ELEMENT_NODE) {
+          var el = node;
+          var aria = norm(el.getAttribute('aria-label') || el.getAttribute('title') || el.getAttribute('placeholder') || '');
+          if (aria && aria.includes(qLow)) {
+            matches.push(el);
+          }
+        }
+      }
+      if (matches.length === 0) return null;
+      var match = matches[0];
+      var r = match.getBoundingClientRect();
+      var sel = '';
+      if (match.id) {
+        sel = '#' + CSS.escape(match.id);
+      } else {
+        var tmp = 'wt-tmp-' + Math.random().toString(36).slice(2,8);
+        match.setAttribute('data-wt-id', tmp);
+        sel = '[data-wt-id="' + tmp + '"]';
+      }
+      return {
+        label: match.getAttribute('aria-label') || (match.textContent||'').trim().slice(0,80) || q,
+        x: Math.round(r.left),
+        y: Math.round(r.top),
+        width: Math.round(r.width),
+        height: Math.round(r.height),
+        selector: sel
+      };
+    })(${JSON.stringify(query)})`,
+        returnByValue: true
+    }).catch(() => ({ result: { value: null } }));
+    if (result && result.value) {
+        const val = result.value;
+        return {
+            success: true,
+            found: true,
+            rect: { x: val.x, y: val.y, width: val.width, height: val.height },
+            selector: val.selector,
+            label: val.label
+        };
+    }
+    return { success: true, found: false };
+}

package/dist/tools/geo.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Weavetab — tools/geo.ts
+ * browser_geo: Override geolocation and timezone.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface GeoOptions {
+    action: "set" | "clear";
+    latitude?: number;
+    longitude?: number;
+    accuracy?: number;
+    timezoneId?: string;
+}
+export declare function browserGeo(session: CDP.Client, options: GeoOptions, _config: Config): Promise<{
+    success: boolean;
+    message: string;
+}>;
+//# sourceMappingURL=geo.d.ts.map

package/dist/tools/geo.js

@@ -0,0 +1,29 @@
+export async function browserGeo(session, options, _config) {
+    const { action, latitude, longitude, accuracy = 100, timezoneId } = options;
+    if (action === "clear") {
+        await session.Emulation.clearGeolocationOverride();
+        await session.Emulation.setTimezoneOverride({ timezoneId: "" });
+        return { success: true, message: "Cleared geolocation and timezone overrides" };
+    }
+    if (action === "set") {
+        let msg = "";
+        if (latitude !== undefined && longitude !== undefined) {
+            await session.Emulation.setGeolocationOverride({
+                latitude,
+                longitude,
+                accuracy
+            });
+            msg += `Geolocation set to ${latitude}, ${longitude}. `;
+        }
+        if (timezoneId) {
+            await session.Emulation.setTimezoneOverride({ timezoneId });
+            msg += `Timezone set to ${timezoneId}.`;
+        }
+        if (!msg) {
+            throw new Error("Must provide latitude/longitude or timezoneId to set");
+        }
+        return { success: true, message: msg.trim() };
+    }
+    throw new Error("Unknown action");
+}
+//# sourceMappingURL=geo.js.map

package/dist/tools/github/analyze.d.ts

@@ -0,0 +1,4 @@
+import CDP from "chrome-remote-interface";
+import type { Config } from "../../config/loader.js";
+import { GithubRepoCache } from "./cache.js";
+export declare function githubAnalyze(session: CDP.Client, config: Config, repoSlug?: string): Promise<import("./repoContext.js").GithubToolError | GithubRepoCache>;

package/dist/tools/github/analyze.js

@@ -0,0 +1,113 @@
+import { getRepoContext, isGithubError } from "./repoContext.js";
+import { loadRepoCache, saveRepoCache } from "./cache.js";
+import { canMakeApiCall, handleApiResponse } from "./rateLimiter.js";
+export async function githubAnalyze(session, config, repoSlug) {
+    const context = await getRepoContext(session, repoSlug);
+    if (isGithubError(context))
+        return context;
+    const { owner, repo } = context;
+    // Check cache
+    const cached = await loadRepoCache(owner, repo, config);
+    if (cached) {
+        return cached;
+    }
+    // Check rate limit before proceeding
+    const rateLimitCheck = canMakeApiCall();
+    if (isGithubError(rateLimitCheck))
+        return rateLimitCheck;
+    // 1. Fetch repo metadata
+    const repoUrl = `https://api.github.com/repos/${owner}/${repo}`;
+    const repoRes = await fetch(repoUrl, {
+        headers: {
+            "Accept": "application/vnd.github.v3+json",
+            "User-Agent": "Weavetab-MCP"
+        }
+    });
+    const handledRepoRes = handleApiResponse(repoRes);
+    if (isGithubError(handledRepoRes))
+        return handledRepoRes;
+    if (repoRes.status === 404) {
+        return {
+            error: "REPO_NOT_FOUND",
+            message: "Repository not found or not accessible. Note: Only public repositories are supported."
+        };
+    }
+    if (!repoRes.ok) {
+        return {
+            error: "API_ERROR",
+            message: `GitHub API error: ${repoRes.statusText}`
+        };
+    }
+    const repoData = await repoRes.json();
+    const default_branch = repoData.default_branch || "main";
+    const description = repoData.description || null;
+    const language = repoData.language || null;
+    // Check rate limit again just in case
+    const rateLimitCheck2 = canMakeApiCall();
+    if (isGithubError(rateLimitCheck2))
+        return rateLimitCheck2;
+    // 2. Fetch file tree
+    const treeUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${default_branch}?recursive=1`;
+    const treeRes = await fetch(treeUrl, {
+        headers: {
+            "Accept": "application/vnd.github.v3+json",
+            "User-Agent": "Weavetab-MCP"
+        }
+    });
+    const handledTreeRes = handleApiResponse(treeRes);
+    if (isGithubError(handledTreeRes))
+        return handledTreeRes;
+    let file_tree = [];
+    if (treeRes.ok) {
+        const treeData = await treeRes.json();
+        if (treeData.tree && Array.isArray(treeData.tree)) {
+            // Pick flat structure - it's more compact and easy to grep
+            file_tree = treeData.tree.map((t) => ({
+                path: t.path,
+                mode: t.mode,
+                type: t.type,
+                sha: t.sha,
+                size: t.size,
+                url: t.url
+            }));
+        }
+    }
+    // 3. Fetch README (raw)
+    let readme_snippet = "";
+    // Check common README paths
+    const possibleReadmes = ["README.md", "README", "readme.md", "Readme.md", "README.txt"];
+    const readmeEntry = file_tree.find(f => possibleReadmes.includes(f.path));
+    if (readmeEntry) {
+        const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${default_branch}/${readmeEntry.path}`;
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 10000);
+            const rawRes = await fetch(rawUrl, { signal: controller.signal });
+            clearTimeout(timeout);
+            if (rawRes.ok) {
+                const fullReadme = await rawRes.text();
+                // Truncate snippet to first 100 lines
+                const lines = fullReadme.split('\n');
+                readme_snippet = lines.slice(0, 100).join('\n');
+                if (lines.length > 100) {
+                    readme_snippet += "\n\n... (truncated)";
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    const cacheData = {
+        owner,
+        repo,
+        default_branch,
+        description,
+        language,
+        file_tree,
+        readme_snippet,
+        analyzed_at: Date.now()
+    };
+    await saveRepoCache(cacheData);
+    return cacheData;
+}

package/dist/tools/github/cache.d.ts

@@ -0,0 +1,21 @@
+import type { Config } from "../../config/loader.js";
+export interface TreeEntry {
+    path: string;
+    mode: string;
+    type: string;
+    sha: string;
+    size?: number;
+    url: string;
+}
+export interface GithubRepoCache {
+    owner: string;
+    repo: string;
+    default_branch: string;
+    description: string | null;
+    language: string | null;
+    file_tree: TreeEntry[];
+    readme_snippet: string;
+    analyzed_at: number;
+}
+export declare function loadRepoCache(owner: string, repo: string, config: Config): Promise<GithubRepoCache | null>;
+export declare function saveRepoCache(data: GithubRepoCache): Promise<void>;

package/dist/tools/github/cache.js

@@ -0,0 +1,28 @@
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import { getConfigGithubCacheTtlMs } from "../../config/loader.js";
+const CACHE_DIR = join(homedir(), ".weavetab-system", "github_cache");
+function getCacheFile(owner, repo) {
+    const safeOwner = owner.replace(/[^a-zA-Z0-9.-]/g, "_");
+    const safeRepo = repo.replace(/[^a-zA-Z0-9.-]/g, "_");
+    return join(CACHE_DIR, `${safeOwner}_${safeRepo}.json`);
+}
+export async function loadRepoCache(owner, repo, config) {
+    try {
+        const content = await readFile(getCacheFile(owner, repo), "utf-8");
+        const data = JSON.parse(content);
+        const ttl = getConfigGithubCacheTtlMs(config) ?? (30 * 60 * 1000);
+        if (Date.now() - data.analyzed_at > ttl) {
+            return null; // Stale cache
+        }
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveRepoCache(data) {
+    await mkdir(CACHE_DIR, { recursive: true });
+    await writeFile(getCacheFile(data.owner, data.repo), JSON.stringify(data), "utf-8");
+}

package/dist/tools/github/index.d.ts

@@ -0,0 +1,4 @@
+export { githubAnalyze } from "./analyze.js";
+export { githubRead } from "./read.js";
+export { githubIssues } from "./issues.js";
+export { githubGetPr } from "./pr.js";

package/dist/tools/github/index.js

@@ -0,0 +1,4 @@
+export { githubAnalyze } from "./analyze.js";
+export { githubRead } from "./read.js";
+export { githubIssues } from "./issues.js";
+export { githubGetPr } from "./pr.js";

package/dist/tools/github/issues.d.ts

@@ -0,0 +1,9 @@
+import CDP from "chrome-remote-interface";
+export declare function githubIssues(session: CDP.Client, args: {
+    repo?: string;
+    search?: string;
+    number?: number;
+    labels?: string[];
+    state?: 'open' | 'closed' | 'all';
+    limit?: number;
+}): Promise<any>;

package/dist/tools/github/issues.js

@@ -0,0 +1,88 @@
+import { getRepoContext, isGithubError } from "./repoContext.js";
+import { canMakeApiCall, handleApiResponse } from "./rateLimiter.js";
+export async function githubIssues(session, args) {
+    const context = await getRepoContext(session, args.repo);
+    if (isGithubError(context))
+        return context;
+    const { owner, repo } = context;
+    const rateLimitCheck = canMakeApiCall();
+    if (isGithubError(rateLimitCheck))
+        return rateLimitCheck;
+    const headers = {
+        "Accept": "application/vnd.github.v3+json",
+        "User-Agent": "Weavetab-MCP"
+    };
+    // If number is provided, fetch specific issue + comments
+    if (args.number) {
+        const issueUrl = `https://api.github.com/repos/${owner}/${repo}/issues/${args.number}`;
+        const issueRes = await fetch(issueUrl, { headers });
+        const handledIssueRes = handleApiResponse(issueRes);
+        if (isGithubError(handledIssueRes))
+            return handledIssueRes;
+        if (!issueRes.ok) {
+            return { error: "FETCH_FAILED", status: issueRes.status, message: `Failed to fetch issue #${args.number}` };
+        }
+        const issueData = await issueRes.json();
+        let comments = [];
+        if (issueData.comments > 0) {
+            const rateLimitCheck2 = canMakeApiCall();
+            if (!isGithubError(rateLimitCheck2)) {
+                const commentsUrl = `https://api.github.com/repos/${owner}/${repo}/issues/${args.number}/comments`;
+                const commentsRes = await fetch(commentsUrl, { headers });
+                const handledCommentsRes = handleApiResponse(commentsRes);
+                if (!isGithubError(handledCommentsRes) && commentsRes.ok) {
+                    const commentsData = await commentsRes.json();
+                    comments = commentsData.map((c) => ({
+                        id: c.id,
+                        user: c.user?.login,
+                        body: c.body,
+                        created_at: c.created_at
+                    }));
+                }
+            }
+        }
+        return {
+            number: issueData.number,
+            title: issueData.title,
+            state: issueData.state,
+            user: issueData.user?.login,
+            body: issueData.body,
+            created_at: issueData.created_at,
+            labels: issueData.labels?.map((l) => l.name),
+            comments
+        };
+    }
+    // Else list issues
+    let urlStr = `https://api.github.com/repos/${owner}/${repo}/issues?per_page=${args.limit || 5}`;
+    if (args.state)
+        urlStr += `&state=${args.state}`;
+    if (args.labels && args.labels.length > 0)
+        urlStr += `&labels=${args.labels.join(',')}`;
+    // GitHub Search API is different from Issues API. If search is provided, we should use search API.
+    if (args.search) {
+        let q = `repo:${owner}/${repo} is:issue ${args.search}`;
+        if (args.state && args.state !== 'all')
+            q += ` is:${args.state}`;
+        if (args.labels)
+            args.labels.forEach(l => q += ` label:"${l}"`);
+        urlStr = `https://api.github.com/search/issues?q=${encodeURIComponent(q)}&per_page=${args.limit || 5}`;
+    }
+    const listRes = await fetch(urlStr, { headers });
+    const handledListRes = handleApiResponse(listRes);
+    if (isGithubError(handledListRes))
+        return handledListRes;
+    if (!listRes.ok) {
+        return { error: "FETCH_FAILED", status: listRes.status, message: "Failed to list/search issues" };
+    }
+    const listData = await listRes.json();
+    const items = args.search ? listData.items : listData;
+    return items.map((i) => ({
+        number: i.number,
+        title: i.title,
+        state: i.state,
+        user: i.user?.login,
+        labels: i.labels?.map((l) => l.name),
+        created_at: i.created_at,
+        comments_count: i.comments
+    }));
+}

package/dist/tools/github/pr.d.ts

@@ -0,0 +1,5 @@
+import CDP from "chrome-remote-interface";
+export declare function githubGetPr(session: CDP.Client, args: {
+    repo?: string;
+    number?: number;
+}): Promise<any>;

package/dist/tools/github/pr.js

@@ -0,0 +1,88 @@
+import { getRepoContext, isGithubError } from "./repoContext.js";
+import { canMakeApiCall, handleApiResponse } from "./rateLimiter.js";
+export async function githubGetPr(session, args) {
+    const context = await getRepoContext(session, args.repo);
+    if (isGithubError(context))
+        return context;
+    const { owner, repo } = context;
+    const rateLimitCheck = canMakeApiCall();
+    if (isGithubError(rateLimitCheck))
+        return rateLimitCheck;
+    const headers = {
+        "Accept": "application/vnd.github.v3+json",
+        "User-Agent": "Weavetab-MCP"
+    };
+    if (args.number) {
+        const prUrl = `https://api.github.com/repos/${owner}/${repo}/pulls/${args.number}`;
+        const prRes = await fetch(prUrl, { headers });
+        const handledPrRes = handleApiResponse(prRes);
+        if (isGithubError(handledPrRes))
+            return handledPrRes;
+        if (!prRes.ok) {
+            return { error: "FETCH_FAILED", status: prRes.status, message: `Failed to fetch PR #${args.number}` };
+        }
+        const prData = await prRes.json();
+        let files_changed = [];
+        const rateLimitCheck2 = canMakeApiCall();
+        if (!isGithubError(rateLimitCheck2)) {
+            const filesUrl = `https://api.github.com/repos/${owner}/${repo}/pulls/${args.number}/files`;
+            const filesRes = await fetch(filesUrl, { headers });
+            const handledFilesRes = handleApiResponse(filesRes);
+            if (!isGithubError(handledFilesRes) && filesRes.ok) {
+                const filesData = await filesRes.json();
+                files_changed = filesData.map((f) => f.filename);
+            }
+        }
+        let comments = [];
+        if (prData.comments > 0) {
+            const rateLimitCheck3 = canMakeApiCall();
+            if (!isGithubError(rateLimitCheck3)) {
+                const commentsUrl = `https://api.github.com/repos/${owner}/${repo}/issues/${args.number}/comments`;
+                const commentsRes = await fetch(commentsUrl, { headers });
+                const handledCommentsRes = handleApiResponse(commentsRes);
+                if (!isGithubError(handledCommentsRes) && commentsRes.ok) {
+                    const commentsData = await commentsRes.json();
+                    comments = commentsData.map((c) => ({
+                        id: c.id,
+                        user: c.user?.login,
+                        body: c.body,
+                        created_at: c.created_at
+                    }));
+                }
+            }
+        }
+        return {
+            number: prData.number,
+            title: prData.title,
+            state: prData.state,
+            user: prData.user?.login,
+            body: prData.body,
+            created_at: prData.created_at,
+            merged: prData.merged,
+            mergeable: prData.mergeable,
+            additions: prData.additions,
+            deletions: prData.deletions,
+            changed_files: prData.changed_files,
+            files: files_changed,
+            comments
+        };
+    }
+    // Else list recent PRs
+    const listUrl = `https://api.github.com/repos/${owner}/${repo}/pulls?state=all&per_page=10`;
+    const listRes = await fetch(listUrl, { headers });
+    const handledListRes = handleApiResponse(listRes);
+    if (isGithubError(handledListRes))
+        return handledListRes;
+    if (!listRes.ok) {
+        return { error: "FETCH_FAILED", status: listRes.status, message: "Failed to list PRs" };
+    }
+    const listData = await listRes.json();
+    return listData.map((pr) => ({
+        number: pr.number,
+        title: pr.title,
+        state: pr.state,
+        user: pr.user?.login,
+        created_at: pr.created_at,
+        updated_at: pr.updated_at
+    }));
+}

package/dist/tools/github/rateLimiter.d.ts

@@ -0,0 +1,4 @@
+import type { GithubToolError } from "./repoContext.js";
+export declare function canMakeApiCall(): true | GithubToolError;
+export declare function recordApiCall(headers: Headers): void;
+export declare function handleApiResponse(response: Response): Response | GithubToolError;

package/dist/tools/github/rateLimiter.js

@@ -0,0 +1,46 @@
+let state = {
+    remaining: 60,
+    resetAt: null,
+};
+const SAFETY_THRESHOLD = 5;
+export function canMakeApiCall() {
+    const nowSec = Math.floor(Date.now() / 1000);
+    if (state.resetAt && nowSec >= state.resetAt) {
+        // We've passed the reset window, assume we have quota again
+        state.remaining = 60;
+        state.resetAt = null;
+    }
+    if (state.remaining < SAFETY_THRESHOLD) {
+        const resetTime = state.resetAt ? new Date(state.resetAt * 1000).toISOString() : "unknown";
+        return {
+            error: "RATE_LIMIT_LOW",
+            message: `GitHub API hourly rate limit is too low (remaining: ${state.remaining}). Please wait until ${resetTime} before making more API calls. Note: github_read does NOT consume API calls.`,
+            remaining: state.remaining,
+            reset_at: state.resetAt
+        };
+    }
+    return true;
+}
+export function recordApiCall(headers) {
+    const remainingStr = headers.get("x-ratelimit-remaining");
+    const resetStr = headers.get("x-ratelimit-reset");
+    if (remainingStr) {
+        state.remaining = parseInt(remainingStr, 10) || state.remaining;
+    }
+    if (resetStr) {
+        state.resetAt = parseInt(resetStr, 10) || state.resetAt;
+    }
+}
+export function handleApiResponse(response) {
+    recordApiCall(response.headers);
+    if (response.status === 403 || response.status === 429) {
+        const resetTime = state.resetAt ? new Date(state.resetAt * 1000).toISOString() : "unknown";
+        return {
+            error: "RATE_LIMIT_EXCEEDED",
+            message: `GitHub API rate limit exceeded. Please wait until ${resetTime}.`,
+            remaining: state.remaining,
+            reset_at: state.resetAt
+        };
+    }
+    return response;
+}

package/dist/tools/github/read.d.ts

@@ -0,0 +1,34 @@
+import CDP from "chrome-remote-interface";
+import type { Config } from "../../config/loader.js";
+export declare function githubRead(session: CDP.Client, args: {
+    repo?: string;
+    paths: string[];
+    line_range?: [number, number];
+}, config: Config): Promise<import("./repoContext.js").GithubToolError | {
+    warnings: string[] | undefined;
+    files: ({
+        path: string;
+        error: string;
+        status: number;
+        message: string;
+        total_lines?: undefined;
+        truncated?: undefined;
+        content?: undefined;
+    } | {
+        path: string;
+        total_lines: number;
+        truncated: boolean;
+        content: string;
+        error?: undefined;
+        status?: undefined;
+        message?: undefined;
+    } | {
+        path: string;
+        error: string;
+        message: any;
+        status?: undefined;
+        total_lines?: undefined;
+        truncated?: undefined;
+        content?: undefined;
+    })[];
+}>;