@weavetab/mcp 2.5.0-beta.1 → 2.5.0-beta.4

package/dist/cli/updater.d.ts

@@ -1 +1 @@
-export declare function checkForUpdates(): Promise<void>;
+export declare function checkForUpdates(force?: boolean): Promise<void>;

package/dist/cli/updater.js

@@ -1,19 +1,33 @@
 import fs from "node:fs";
 import path from "node:path";
+import os from "node:os";
 import { fileURLToPath } from "node:url";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-export async function checkForUpdates() {
+const UPDATE_CACHE_FILE = path.join(os.homedir(), ".weavetab-system", "cache", "update_check.json");
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+export async function checkForUpdates(force = false) {
     try {
+        const now = Date.now();
+        // Check cache unless forced
+        if (!force && fs.existsSync(UPDATE_CACHE_FILE)) {
+            try {
+                const cached = JSON.parse(fs.readFileSync(UPDATE_CACHE_FILE, "utf-8"));
+                if (cached.lastChecked && now - cached.lastChecked < CHECK_INTERVAL_MS) {
+                    return;
+                }
+            }
+            catch { /* malformed cache */ }
+        }
         // Read local package.json to get current version
         const packageJsonPath = path.resolve(__dirname, "../../package.json");
         if (!fs.existsSync(packageJsonPath))
             return;
         const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
         const currentVersion = pkg.version;
-        // Fast, non-blocking fetch with 2-second timeout
+        // Fast, non-blocking fetch with 1.5-second timeout
         const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), 2000);
+        const timeoutId = setTimeout(() => controller.abort(), 1500);
         const res = await fetch("https://registry.npmjs.org/@weavetab/mcp/latest", {
             signal: controller.signal,
         });
@@ -22,12 +36,18 @@ export async function checkForUpdates() {
             return;
         const data = await res.json();
         const latestVersion = data.version;
-        // Simple version comparison (assumes semver format like x.y.z)
+        // Save timestamp to cache
+        try {
+            fs.mkdirSync(path.dirname(UPDATE_CACHE_FILE), { recursive: true });
+            fs.writeFileSync(UPDATE_CACHE_FILE, JSON.stringify({ lastChecked: now, latestVersion }), "utf-8");
+        }
+        catch { /* non-fatal */ }
+        // Simple version comparison
         if (isNewerVersion(currentVersion, latestVersion)) {
             await printUpdateBox(currentVersion, latestVersion);
         }
     }
-    catch (err) {
+    catch {
         // Silently fail if offline or npm is down
     }
 }
@@ -52,7 +72,7 @@ async function printUpdateBox(current, latest) {
             chalk.bold(`Update available! `) + chalk.dim(current) + chalk.reset(` → `) + chalk.green(latest),
             `Run ${chalk.cyan("npm i -g @weavetab/mcp")} to update.`,
             ``,
-            `Changelog: ${chalk.blue(`https://weavetab.dev/changelog/v${latest}`)}`
+            `Changelog: ${chalk.blue(`https://github.com/weavetab/mcp/releases/tag/v${latest}`)}`
         ].join("\n");
         const box = boxen(msg, {
             padding: 1,
@@ -67,6 +87,6 @@ async function printUpdateBox(current, latest) {
         // Fallback if formatting fails
         console.error(`\n[Weavetab MCP] Update available: ${current} -> ${latest}`);
         console.error(`Run "npm i -g @weavetab/mcp" to update.`);
-        console.error(`Changelog: https://weavetab.dev/changelog/v${latest}\n`);
+        console.error(`Changelog: https://github.com/weavetab/mcp/releases/tag/v${latest}\n`);
     }
 }

package/dist/config/loader.d.ts

@@ -6,6 +6,13 @@ export interface PolicyEntry {
     pattern: string;
     mode: PolicyMode;
 }
+export interface ElectronAppConfig {
+    path?: string;
+    port?: number;
+    url?: string;
+    args?: string[];
+    profileDir?: string;
+}
 export interface Config {
     mode: "session" | "attach";
     session: string;
@@ -15,13 +22,13 @@ export interface Config {
     browserPath: string;
     browserType: BrowserEngine;
     headless: boolean;
-    visuals: boolean;
-    darkMode: boolean;
-    disableExtensions: boolean;
+    extension: boolean;
     browserFlags: string[];
     profileDir: string;
     cookies: boolean;
     syncDataAcrossBrowsers: boolean;
+    apps?: Record<string, ElectronAppConfig>;
+    electron?: Record<string, ElectronAppConfig>;
     role: Role;
     block: string[];
     allow: string[];
@@ -48,6 +55,11 @@ export declare const GLOBAL_CONFIG_PATH: string;
 export declare const DEFAULT_CONFIG: Config;
 export type OnConfigChange = (newConfig: Config) => void;
 export declare function onConfigChange(cb: OnConfigChange): void;
+/**
+ * Migrates old sectioned config to new simplified flat format.
+ */
+export declare function migrateToSimple(sectioned: any): Config;
+export declare function validateConfigInternal(raw: Record<string, unknown>): Config;
 /**
  * Priority: Global (user) → Built-in defaults
  *
@@ -87,9 +99,7 @@ export declare function getConfigTelemetry(config: Config): boolean;
 export declare function getConfigBrowserPath(config: Config): string;
 export declare function getConfigBrowserType(config: Config): BrowserEngine;
 export declare function getConfigHeadless(config: Config): boolean;
-export declare function getConfigVisuals(config: Config): boolean;
-export declare function getConfigDarkMode(config: Config): boolean;
-export declare function getConfigDisableExtensions(config: Config): boolean;
+export declare function getConfigExtension(config: Config): boolean;
 export declare function getConfigBrowserFlags(config: Config): string[];
 export declare function getConfigProfileDir(config: Config): string;
 export declare function getConfigCookies(config: Config): boolean;
@@ -108,13 +118,30 @@ export declare function getConfigActionabilityTimeoutMs(config: Config): number;
 export declare function getConfigGithubCacheTtl(config: Config): number;
 export declare function getConfigRefCacheTtl(config: Config): number;
 export declare function getConfigDevMode(config: Config): boolean;
+export declare function getConfigApps(config: Config): Record<string, ElectronAppConfig> | undefined;
+export declare function getConfigElectron(config: Config): Record<string, ElectronAppConfig> | undefined;
+export declare function getAppConfig(appName: string, config?: Config): ElectronAppConfig | null;
+export declare function getElectronAppConfig(appName: string, config?: Config): ElectronAppConfig | null;
+export declare function getAppNames(config?: Config): string[];
+export declare function getElectronAppNames(config?: Config): string[];
+export declare function getApps(config?: Config): Record<string, ElectronAppConfig>;
+export declare function getElectronApps(config?: Config): Record<string, ElectronAppConfig>;
 export declare function getConfigNavigationTimeoutMs(config: Config): number;
 export declare function getConfigGithubCacheTtlMs(config: Config): number;
 export declare function getConfigRefCacheTtlMs(config: Config): number;
 export declare function getSystemDir(subdir: string): string;
+export declare function getSystemAppDir(appName: string): string;
 /**
  * Returns a directory inside the global ~/.weavetab-system/ folder.
  * Alias for consistency — identical to getSystemDir.
  */
 export declare function getGlobalSystemDir(subdir: string): string;
+/**
+ * Returns the canonical directory for persistent site profiles and learned workflow patterns.
+ * Lives in ~/.weavetab-system/memory/sites/ — strictly machine-managed, never user-authored.
+ * Separated from the legacy selector-memory dir (~/.weavetab-system/memory/) so existing
+ * per-domain selector caches are not disrupted.
+ */
+export declare function getSystemMemorySitesDir(): string;
 export declare function saveConfig(config: Config): void;
+export declare function stopConfigWatcher(): void;

package/dist/config/loader.js

@@ -30,13 +30,13 @@ export const DEFAULT_CONFIG = {
     browserPath: "auto",
     browserType: "chromium",
     headless: false,
-    visuals: true,
-    darkMode: true,
-    disableExtensions: false,
+    extension: true,
     browserFlags: [],
     profileDir: "",
     cookies: false,
     syncDataAcrossBrowsers: false,
+    apps: undefined,
+    electron: undefined,
     role: "admin",
     block: ["*.bank.*", "paypal.com"],
     allow: [],
@@ -44,7 +44,7 @@ export const DEFAULT_CONFIG = {
     sessionTimeout: 3600,
     navigationTimeout: 30000,
     idleTimeout: 60000,
-    actionabilityTimeoutMs: 15000,
+    actionabilityTimeoutMs: 300,
     maxTabs: 10,
     maxActionsPerMinute: 60,
     githubCacheTtlMs: 30 * 60 * 1000,
@@ -77,7 +77,7 @@ function isSectionedConfig(raw) {
 /**
  * Migrates old sectioned config to new simplified flat format.
  */
-function migrateToSimple(sectioned) {
+export function migrateToSimple(sectioned) {
     return {
         mode: sectioned.general?.mode || "session",
         session: sectioned.general?.session || "default",
@@ -87,12 +87,12 @@ function migrateToSimple(sectioned) {
         browserPath: sectioned.browser?.path || "auto",
         browserType: sectioned.browser?.type || "chromium",
         headless: sectioned.browser?.headless ?? false,
-        visuals: sectioned.browser?.visuals ?? true,
-        darkMode: sectioned.browser?.darkMode ?? true,
-        disableExtensions: sectioned.browser?.disableExtensions || false,
+        extension: sectioned.browser?.extension ?? sectioned.browser?.visuals ?? true,
         browserFlags: sectioned.browser?.flags || [],
         profileDir: sectioned.browser?.profileDir || "",
         cookies: sectioned.browser?.cookies || false,
+        apps: sectioned.apps || sectioned.electron || undefined,
+        electron: sectioned.apps || sectioned.electron || undefined,
         role: sectioned.security?.role || "admin",
         block: sectioned.security?.block || ["*.bank.*", "paypal.com"],
         allow: sectioned.security?.allow || [],
@@ -149,7 +149,7 @@ function validateConfig(raw) {
     // Validate simplified config
     return validateConfigInternal(raw);
 }
-function validateConfigInternal(raw) {
+export function validateConfigInternal(raw) {
     const d = DEFAULT_CONFIG;
     const VALID_MODES = ["session", "attach"];
     const VALID_ENGINES = ["chromium", "firefox", "webkit"];
@@ -205,6 +205,83 @@ function validateConfigInternal(raw) {
         logDebug(`[Weavetab Config] [WARN] Proxy contains literal credentials (://user:pass@). This is a security risk. Use an environment variable instead. Ignoring proxy.`);
         proxy = undefined;
     }
+    // Validate apps / electron apps mapping
+    let electron = undefined;
+    const rawApps = raw.apps || raw.electron;
+    if (rawApps && typeof rawApps === "object" && !Array.isArray(rawApps)) {
+        const rawMap = rawApps;
+        const validatedMap = {};
+        for (const [rawKey, rawVal] of Object.entries(rawMap)) {
+            const sanitizedKey = rawKey.trim();
+            if (!/^[a-zA-Z0-9_-]+$/.test(sanitizedKey)) {
+                logDebug(`[Weavetab Config] [WARN] Invalid app name "${rawKey}". Must be alphanumeric, dashes, or underscores.`);
+                continue;
+            }
+            if (typeof rawVal === "string") {
+                const strVal = rawVal.trim();
+                if (/^\d+$/.test(strVal)) {
+                    const portNum = parseInt(strVal, 10);
+                    if (portNum > 0 && portNum <= 65535) {
+                        validatedMap[sanitizedKey] = { port: portNum };
+                    }
+                }
+                else if (strVal.startsWith("http://") || strVal.startsWith("https://") || strVal.startsWith("ws://") || strVal.startsWith("wss://")) {
+                    const cfg = { url: strVal };
+                    try {
+                        const parsedUrl = new URL(strVal);
+                        if (parsedUrl.port) {
+                            const p = parseInt(parsedUrl.port, 10);
+                            if (p > 0 && p <= 65535)
+                                cfg.port = p;
+                        }
+                    }
+                    catch { /* ignore */ }
+                    validatedMap[sanitizedKey] = cfg;
+                }
+                else {
+                    const safePath = safePathField(`apps.${sanitizedKey}`, strVal);
+                    if (safePath) {
+                        validatedMap[sanitizedKey] = { path: safePath };
+                    }
+                }
+            }
+            else if (typeof rawVal === "number" && Number.isFinite(rawVal) && rawVal > 0 && rawVal <= 65535) {
+                validatedMap[sanitizedKey] = { port: rawVal };
+            }
+            else if (typeof rawVal === "object" && rawVal !== null && !Array.isArray(rawVal)) {
+                const objVal = rawVal;
+                const appCfg = {};
+                if (typeof objVal.path === "string" && objVal.path.trim()) {
+                    const safePath = safePathField(`apps.${sanitizedKey}.path`, objVal.path);
+                    if (safePath)
+                        appCfg.path = safePath;
+                }
+                if (typeof objVal.port === "number" && Number.isFinite(objVal.port) && objVal.port > 0 && objVal.port <= 65535) {
+                    appCfg.port = objVal.port;
+                }
+                else if (typeof objVal.port === "string" && /^\d+$/.test(objVal.port.trim())) {
+                    const p = parseInt(objVal.port.trim(), 10);
+                    if (p > 0 && p <= 65535)
+                        appCfg.port = p;
+                }
+                if (typeof objVal.url === "string" && objVal.url.trim()) {
+                    appCfg.url = objVal.url.trim();
+                }
+                if (Array.isArray(objVal.args)) {
+                    appCfg.args = objVal.args.filter(isStr);
+                }
+                if (typeof objVal.profileDir === "string" && objVal.profileDir.trim()) {
+                    appCfg.profileDir = safePathField(`apps.${sanitizedKey}.profileDir`, objVal.profileDir);
+                }
+                if (appCfg.path || appCfg.port || appCfg.url) {
+                    validatedMap[sanitizedKey] = appCfg;
+                }
+            }
+        }
+        if (Object.keys(validatedMap).length > 0) {
+            electron = validatedMap;
+        }
+    }
     return {
         mode,
         session: validateField("session", raw.session, isStr, d.session),
@@ -214,12 +291,12 @@ function validateConfigInternal(raw) {
         browserPath,
         browserType: validateField("browserType", raw.browserType, isStr, d.browserType, v => VALID_ENGINES.includes(v)),
         headless: validateField("headless", raw.headless, isBool, d.headless),
-        visuals: validateField("visuals", raw.visuals, isBool, d.visuals),
-        darkMode: validateField("darkMode", raw.darkMode, isBool, d.darkMode),
-        disableExtensions: validateField("disableExtensions", raw.disableExtensions, isBool, d.disableExtensions),
+        extension: validateField("extension", raw.extension, isBool, d.extension),
         browserFlags: isArr(raw.browserFlags) ? raw.browserFlags.filter(isStr) : d.browserFlags,
         profileDir,
         cookies: validateField("cookies", raw.cookies, isBool, d.cookies),
+        apps: electron,
+        electron,
         role: validateField("role", raw.role, isStr, d.role, v => VALID_ROLES.includes(v)),
         block: isArr(raw.block) ? raw.block.filter(isStr) : d.block,
         allow: isArr(raw.allow) ? raw.allow.filter(isStr) : d.allow,
@@ -345,7 +422,7 @@ function resolveConfigMerge() {
         logDebug(`[Weavetab Config] [OK] Active directory: ${activeDir}`);
     }
     else {
-        logDebug(`[Weavetab Config] [WARN] No config found — using built-in defaults. Run: wt config`);
+        logDebug(`[Weavetab Config] [WARN] No config found — using built-in defaults. Run: weavetab config`);
         logDebug(`[Weavetab Config] [OK] Active directory: ${activeDir}`);
         // Write a starter global config so user isn't surprised
         ensureConfigDir(globalDir);
@@ -551,14 +628,8 @@ export function getConfigBrowserType(config) {
 export function getConfigHeadless(config) {
     return config.headless;
 }
-export function getConfigVisuals(config) {
-    return config.visuals;
-}
-export function getConfigDarkMode(config) {
-    return config.darkMode;
-}
-export function getConfigDisableExtensions(config) {
-    return config.disableExtensions;
+export function getConfigExtension(config) {
+    return config.extension !== false;
 }
 export function getConfigBrowserFlags(config) {
     return config.browserFlags;
@@ -614,6 +685,40 @@ export function getConfigRefCacheTtl(config) {
 export function getConfigDevMode(config) {
     return config.devMode;
 }
+export function getConfigApps(config) {
+    return config.apps || config.electron;
+}
+export function getConfigElectron(config) {
+    return config.apps || config.electron;
+}
+export function getAppConfig(appName, config) {
+    const cfg = config ?? getCachedConfig();
+    const map = cfg.apps || cfg.electron;
+    if (!map)
+        return null;
+    const sanitized = appName.trim();
+    return map[sanitized] || null;
+}
+export function getElectronAppConfig(appName, config) {
+    return getAppConfig(appName, config);
+}
+export function getAppNames(config) {
+    const cfg = config ?? getCachedConfig();
+    const map = cfg.apps || cfg.electron;
+    if (!map)
+        return [];
+    return Object.keys(map);
+}
+export function getElectronAppNames(config) {
+    return getAppNames(config);
+}
+export function getApps(config) {
+    const cfg = config ?? getCachedConfig();
+    return cfg.apps || cfg.electron || {};
+}
+export function getElectronApps(config) {
+    return getApps(config);
+}
 // ─── Additional Helper Functions for Code Compatibility ─────────────────────────
 export function getConfigNavigationTimeoutMs(config) {
     return config.navigationTimeout;
@@ -637,6 +742,14 @@ export function getSystemDir(subdir) {
     }
     return dir;
 }
+export function getSystemAppDir(appName) {
+    const sanitized = appName.trim().replace(/[^a-zA-Z0-9_-]/g, "_");
+    const dir = path.join(GLOBAL_SYSTEM_DIR, "apps", sanitized);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
 /**
  * Returns a directory inside the global ~/.weavetab-system/ folder.
  * Alias for consistency — identical to getSystemDir.
@@ -648,6 +761,19 @@ export function getGlobalSystemDir(subdir) {
     }
     return dir;
 }
+/**
+ * Returns the canonical directory for persistent site profiles and learned workflow patterns.
+ * Lives in ~/.weavetab-system/memory/sites/ — strictly machine-managed, never user-authored.
+ * Separated from the legacy selector-memory dir (~/.weavetab-system/memory/) so existing
+ * per-domain selector caches are not disrupted.
+ */
+export function getSystemMemorySitesDir() {
+    const dir = path.join(GLOBAL_SYSTEM_DIR, "memory", "sites");
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
 export function saveConfig(config) {
     const { dir, file } = getActiveConfigPath();
     ensureConfigDir(dir);
@@ -676,11 +802,18 @@ export function saveConfig(config) {
 }
 // ─── Live-reload watcher ───────────────────────────────────────────────────────
 let watchTimeout = null;
+let _configWatcher = null;
 function startWatcher(dir) {
     try {
         if (!fs.existsSync(dir))
             return;
-        fs.watch(dir, (eventType, filename) => {
+        if (_configWatcher) {
+            try {
+                _configWatcher.close();
+            }
+            catch { /* ignore */ }
+        }
+        _configWatcher = fs.watch(dir, (eventType, filename) => {
             if (filename === "config.json" && eventType === "change") {
                 if (watchTimeout)
                     clearTimeout(watchTimeout);
@@ -693,12 +826,31 @@ function startWatcher(dir) {
                         logDebug("[Weavetab] Failed to reload config", e);
                     }
                 }, 150);
+                if (watchTimeout && typeof watchTimeout.unref === "function") {
+                    watchTimeout.unref();
+                }
             }
         });
+        if (_configWatcher && typeof _configWatcher.unref === "function") {
+            _configWatcher.unref();
+        }
     }
     catch {
         // Ignore watch errors on some OS/network mounts
     }
 }
+export function stopConfigWatcher() {
+    if (watchTimeout) {
+        clearTimeout(watchTimeout);
+        watchTimeout = null;
+    }
+    if (_configWatcher) {
+        try {
+            _configWatcher.close();
+        }
+        catch { /* ignore */ }
+        _configWatcher = null;
+    }
+}
 // Watch global location so changes are picked up
 startWatcher(GLOBAL_CONFIG_DIR);

package/dist/desktop/discovery.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Weavetab — desktop/discovery.ts
+ * Auto-discovery scanner for running Electron desktop applications.
+ *
+ * Detects:
+ *   1. Active Electron instances with open CDP remote debugging ports
+ *      (Slack, Discord, VS Code, Notion, Obsidian, Linear, Cursor, etc.).
+ *   2. Running Electron processes without remote debugging enabled,
+ *      providing actionable launch flags.
+ *
+ * Weavetab by fy2ne
+ */
+export interface DiscoveredElectronApp {
+    name: string;
+    port?: number;
+    status: "debug_port_open" | "process_running_no_debug_port";
+    title?: string;
+    webSocketDebuggerUrl?: string;
+    browserVersion?: string;
+    pid?: number;
+    recommendation?: string;
+}
+export declare const COMMON_DEBUG_PORTS: number[];
+/**
+ * Fast probe of a potential CDP debug port on 127.0.0.1.
+ * Resolves with version/target metadata if open, or null if unreachable.
+ */
+export declare function probeDebugPort(port: number, timeoutMs?: number): Promise<{
+    versionInfo: any;
+    targets: any[];
+} | null>;
+export declare function fetchTargets(port: number, timeoutMs?: number): Promise<any[]>;
+/**
+ * Infers an application name from CDP version and target metadata.
+ */
+export declare function identifyElectronAppName(versionInfo: any, targets: any[]): string;
+/**
+ * Discovers running Electron apps on the host machine.
+ * 1. Probes common and provided debug ports for open CDP listeners.
+ * 2. Checks OS process list for running Electron apps lacking debug ports.
+ */
+export declare function discoverElectronApps(customPorts?: number[]): Promise<DiscoveredElectronApp[]>;
+export declare function isValidElectronExecutablePath(execPath: string): boolean;
+export declare function resolveElectronExecutablePath(appName: string, configuredPath?: string): string | null;