auvrynt 1.0.2 → 1.0.5

package/dist/integrations/agent-reach/agent-reach-tools.js

@@ -0,0 +1,196 @@
+import * as z from "zod/v4";
+import { registerAppTool } from "../../server/mcp-tool-registrar.js";
+import { findOnPath, nativeDoctor, readUrl, searchPlatform, } from "./native-channels.js";
+const READ_ONLY = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+};
+const PROCESS_HINT = {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+};
+/** Upstream project inspiration: https://github.com/Panniantong/Agent-Reach */
+export const AGENT_REACH_REPO = "https://github.com/Panniantong/Agent-Reach";
+export const AGENT_REACH_INSTALL_GUIDE = "https://raw.githubusercontent.com/Panniantong/agent-reach/main/docs/install.md";
+export const AGENT_REACH_UPDATE_GUIDE = "https://raw.githubusercontent.com/Panniantong/agent-reach/main/docs/update.md";
+const PLATFORM_ENUM = z.enum([
+    "auto",
+    "web",
+    "rss",
+    "v2ex",
+    "youtube",
+    "github",
+    "bilibili",
+    "reddit",
+    "twitter",
+    "xiaohongshu",
+    "facebook",
+    "instagram",
+    "linkedin",
+    "xueqiu",
+    "exa",
+]);
+function text(payload, isError = false) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: typeof payload === "string" ? payload : JSON.stringify(payload, null, 2),
+            },
+        ],
+        ...(isError ? { isError: true } : {}),
+    };
+}
+export function registerAgentReachTools(server) {
+    registerAppTool(server, "agent_reach_status", {
+        title: "Agent Reach status",
+        description: "Report native Auvrynt Reach capability status (built-in web/RSS/V2EX/Bilibili plus optional upstream CLIs). " +
+            "Does not require the external agent-reach package.",
+        inputSchema: {},
+        annotations: READ_ONLY,
+        _meta: {},
+    }, async () => {
+        try {
+            const [agentReach, ytdlp, gh, opencli, rdt, twitter, mcporter] = await Promise.all([
+                findOnPath("agent-reach"),
+                findOnPath("yt-dlp"),
+                findOnPath("gh"),
+                findOnPath("opencli"),
+                findOnPath("rdt"),
+                findOnPath("twitter"),
+                findOnPath("mcporter"),
+            ]);
+            return text({
+                mode: "auvrynt-native",
+                nativeChannels: ["web", "rss", "v2ex", "bilibili"],
+                optionalCli: {
+                    "agent-reach": agentReach ?? null,
+                    "yt-dlp": ytdlp ?? null,
+                    gh: gh ?? null,
+                    opencli: opencli ?? null,
+                    rdt: rdt ?? null,
+                    twitter: twitter ?? null,
+                    mcporter: mcporter ?? null,
+                },
+                tools: ["agent_reach_status", "agent_reach_doctor", "agent_reach_guide", "agent_reach_read", "agent_reach_search"],
+                repoInspiration: AGENT_REACH_REPO,
+            });
+        }
+        catch (error) {
+            return text(error instanceof Error ? error.message : String(error), true);
+        }
+    });
+    registerAppTool(server, "agent_reach_doctor", {
+        title: "Agent Reach doctor",
+        description: "Probe which internet channels work from this machine (native Auvrynt checks + optional upstream CLIs).",
+        inputSchema: {
+            json: z.boolean().optional().describe("If true, return structured JSON only. Defaults to true."),
+        },
+        annotations: PROCESS_HINT,
+        _meta: {},
+    }, async ({ json }) => {
+        try {
+            const channels = await nativeDoctor();
+            const ok = channels.filter((c) => c.status === "ok").length;
+            const partial = channels.filter((c) => c.status === "partial").length;
+            const missing = channels.filter((c) => c.status === "missing").length;
+            const report = {
+                ok: true,
+                mode: "auvrynt-native",
+                summary: { ok, partial, missing, total: channels.length },
+                channels,
+            };
+            if (json === false) {
+                const lines = [
+                    "Auvrynt Reach doctor",
+                    "====================",
+                    ...channels.map((c) => {
+                        const mark = c.status === "ok" ? "OK" : c.status === "partial" ? "!" : "X";
+                        return `[${mark}] ${c.name} — ${c.detail}`;
+                    }),
+                    `Summary: ${ok} ok / ${partial} partial / ${missing} missing`,
+                ];
+                return text({ ok: true, output: lines.join("\n") });
+            }
+            return text(report);
+        }
+        catch (error) {
+            return text(error instanceof Error ? error.message : String(error), true);
+        }
+    });
+    registerAppTool(server, "agent_reach_guide", {
+        title: "Agent Reach guide",
+        description: "Usage notes for Auvrynt-native Reach tools and optional upstream CLIs.",
+        inputSchema: {},
+        annotations: READ_ONLY,
+        _meta: {},
+    }, async () => text({
+        mode: "auvrynt-native",
+        tools: {
+            agent_reach_read: "Read a URL (auto-detect platform or force platform).",
+            agent_reach_search: "Search a platform (web/exa, github, youtube, bilibili, reddit, ...).",
+            agent_reach_doctor: "Channel health probe.",
+            agent_reach_status: "Installed CLI + native capability summary.",
+        },
+        zeroConfig: ["web", "rss", "v2ex", "bilibili-search"],
+        needsCli: {
+            youtube: "yt-dlp",
+            github: "gh",
+            exa: "mcporter + exa config",
+            reddit: "opencli or rdt-cli + login",
+            twitter: "twitter-cli cookies or opencli",
+            xiaohongshu_facebook_instagram: "opencli + Chrome session",
+        },
+        optionalExternalPackage: {
+            repo: AGENT_REACH_REPO,
+            installGuide: AGENT_REACH_INSTALL_GUIDE,
+            updateGuide: AGENT_REACH_UPDATE_GUIDE,
+            note: "Optional. Auvrynt Reach no longer requires agent-reach CLI for core tools.",
+        },
+    }));
+    registerAppTool(server, "agent_reach_read", {
+        title: "Agent Reach read",
+        description: "Read internet content by URL. Native backends for web (Jina), RSS, V2EX, Bilibili; " +
+            "uses yt-dlp/gh/opencli/twitter when installed for other platforms.",
+        inputSchema: {
+            url: z.string().url().describe("URL to read."),
+            platform: PLATFORM_ENUM.optional().describe("Force platform. Default: auto-detect from URL."),
+        },
+        annotations: READ_ONLY,
+        _meta: {},
+    }, async ({ url, platform }) => {
+        try {
+            const result = await readUrl(url, (platform ?? "auto"));
+            return text(result, !result.ok);
+        }
+        catch (error) {
+            return text(error instanceof Error ? error.message : String(error), true);
+        }
+    });
+    registerAppTool(server, "agent_reach_search", {
+        title: "Agent Reach search",
+        description: "Search a platform. Supports web/exa, github, youtube, bilibili, v2ex, reddit, twitter, and OpenCLI platforms when available.",
+        inputSchema: {
+            platform: PLATFORM_ENUM.describe("Platform to search."),
+            query: z.string().min(1).describe("Search query."),
+            limit: z.number().int().min(1).max(50).optional().describe("Max results (default 10)."),
+        },
+        annotations: READ_ONLY,
+        _meta: {},
+    }, async ({ platform, query, limit }) => {
+        try {
+            if (platform === "auto") {
+                return text({ ok: false, error: "Pick an explicit platform for search (e.g. web, github, reddit)." }, true);
+            }
+            const result = await searchPlatform(platform, query, limit ?? 10);
+            return text(result, !result.ok);
+        }
+        catch (error) {
+            return text(error instanceof Error ? error.message : String(error), true);
+        }
+    });
+}

package/dist/integrations/agent-reach/native-channels.js

@@ -0,0 +1,468 @@
+import { existsSync } from "node:fs";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const execFileAsync = promisify(execFile);
+async function findOnPath(command) {
+    const exes = process.platform === "win32" ? [`${command}.exe`, command] : [command];
+    const searchDirs = [
+        join(homedir(), ".local", "bin"),
+        join(homedir(), ".auvrynt", "bin"),
+        join(homedir(), "AppData", "Local", "Programs", "Python", "Python313", "Scripts"),
+        join(homedir(), "AppData", "Roaming", "Python", "Scripts"),
+        join(homedir(), ".agent-reach-venv", "Scripts"),
+        join(homedir(), ".agent-reach-venv", "bin"),
+    ];
+    for (const dir of searchDirs) {
+        for (const exe of exes) {
+            const full = join(dir, exe);
+            if (existsSync(full))
+                return full;
+        }
+    }
+    try {
+        const whichCmd = process.platform === "win32" ? "where.exe" : "which";
+        const { stdout } = await execFileAsync(whichCmd, [command], {
+            timeout: 5_000,
+            windowsHide: true,
+        });
+        return stdout
+            .split(/\r?\n/)
+            .map((l) => l.trim())
+            .find(Boolean);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function runCli(command, args, timeoutMs = 60_000) {
+    const executable = await findOnPath(command);
+    if (!executable) {
+        return { stdout: "", stderr: `${command} not found on PATH`, code: 127 };
+    }
+    try {
+        const { stdout, stderr } = await execFileAsync(executable, args, {
+            timeout: timeoutMs,
+            windowsHide: true,
+            maxBuffer: 4 * 1024 * 1024,
+            env: process.env,
+        });
+        return { stdout: stdout ?? "", stderr: stderr ?? "", code: 0, executable };
+    }
+    catch (error) {
+        const err = error;
+        return {
+            stdout: err.stdout ?? "",
+            stderr: err.stderr ?? err.message ?? String(error),
+            code: typeof err.code === "number" ? err.code : 1,
+            executable,
+        };
+    }
+}
+async function fetchText(url, timeoutMs = 30_000) {
+    const response = await fetch(url, {
+        headers: {
+            "User-Agent": "Auvrynt-Reach/1.0",
+            Accept: "text/plain, text/html, application/json, application/xml, */*",
+        },
+        signal: AbortSignal.timeout(timeoutMs),
+        redirect: "follow",
+    });
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status} for ${url}`);
+    }
+    return response.text();
+}
+async function fetchJson(url, timeoutMs = 30_000) {
+    const text = await fetchText(url, timeoutMs);
+    return JSON.parse(text);
+}
+function detectPlatform(url) {
+    const u = url.toLowerCase();
+    if (/reddit\.com|redd\.it/.test(u))
+        return "reddit";
+    if (/twitter\.com|x\.com/.test(u))
+        return "twitter";
+    if (/youtube\.com|youtu\.be/.test(u))
+        return "youtube";
+    if (/github\.com/.test(u))
+        return "github";
+    if (/bilibili\.com|b23\.tv/.test(u))
+        return "bilibili";
+    if (/xiaohongshu\.com|xhslink\.com/.test(u))
+        return "xiaohongshu";
+    if (/facebook\.com|fb\.com/.test(u))
+        return "facebook";
+    if (/instagram\.com/.test(u))
+        return "instagram";
+    if (/linkedin\.com/.test(u))
+        return "linkedin";
+    if (/xueqiu\.com/.test(u))
+        return "xueqiu";
+    if (/v2ex\.com/.test(u))
+        return "v2ex";
+    if (/\.(rss|xml|atom)(\?|$)/.test(u) || /\/feed\/?(\?|$)/.test(u) || /\/rss\/?(\?|$)/.test(u)) {
+        return "rss";
+    }
+    return "web";
+}
+function stripHtml(html) {
+    return html
+        .replace(/<script[\s\S]*?<\/script>/gi, "")
+        .replace(/<style[\s\S]*?<\/style>/gi, "")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&nbsp;/g, " ")
+        .replace(/&/g, "&")
+        .replace(/</g, "<")
+        .replace(/>/g, ">")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function parseRssItems(xml, limit = 20) {
+    const items = [];
+    const blocks = xml.match(/<item[\s\S]*?<\/item>|<entry[\s\S]*?<\/entry>/gi) ?? [];
+    for (const block of blocks.slice(0, limit)) {
+        const title = block.match(/<title[^>]*>(?:<!\[CDATA\[)?([\s\S]*?)(?:\]\]>)?<\/title>/i)?.[1]?.trim();
+        const link = block.match(/<link[^>]*href=["']([^"']+)["']/i)?.[1] ||
+            block.match(/<link[^>]*>(?:<!\[CDATA\[)?([\s\S]*?)(?:\]\]>)?<\/link>/i)?.[1]?.trim();
+        const summary = block.match(/<description[^>]*>(?:<!\[CDATA\[)?([\s\S]*?)(?:\]\]>)?<\/description>/i)?.[1] ||
+            block.match(/<summary[^>]*>(?:<!\[CDATA\[)?([\s\S]*?)(?:\]\]>)?<\/summary>/i)?.[1];
+        items.push({
+            title: title ? stripHtml(title) : undefined,
+            link: link ? stripHtml(link) : undefined,
+            summary: summary ? stripHtml(summary).slice(0, 500) : undefined,
+        });
+    }
+    return items;
+}
+export async function readUrl(url, platform = "auto") {
+    const resolved = platform === "auto" || platform === "exa" ? detectPlatform(url) : platform;
+    try {
+        switch (resolved) {
+            case "web": {
+                const text = await fetchText(`https://r.jina.ai/${url}`);
+                return { platform: "web", backend: "jina-reader", ok: true, data: { url, content: text.slice(0, 80_000) } };
+            }
+            case "rss": {
+                const xml = await fetchText(url);
+                return {
+                    platform: "rss",
+                    backend: "native-rss",
+                    ok: true,
+                    data: { url, items: parseRssItems(xml) },
+                };
+            }
+            case "v2ex": {
+                const match = url.match(/\/t\/(\d+)/);
+                if (match) {
+                    const data = await fetchJson(`https://www.v2ex.com/api/topics/show.json?id=${match[1]}`);
+                    return { platform: "v2ex", backend: "v2ex-api", ok: true, data };
+                }
+                const hot = await fetchJson("https://www.v2ex.com/api/topics/hot.json");
+                return { platform: "v2ex", backend: "v2ex-api", ok: true, data: hot };
+            }
+            case "youtube": {
+                const ytdlp = await runCli("yt-dlp", ["--dump-json", "--skip-download", url], 90_000);
+                if (ytdlp.code !== 0) {
+                    return {
+                        platform: "youtube",
+                        backend: "yt-dlp",
+                        ok: false,
+                        error: ytdlp.stderr || "yt-dlp failed",
+                    };
+                }
+                try {
+                    return { platform: "youtube", backend: "yt-dlp", ok: true, data: JSON.parse(ytdlp.stdout) };
+                }
+                catch {
+                    return { platform: "youtube", backend: "yt-dlp", ok: true, data: ytdlp.stdout };
+                }
+            }
+            case "github": {
+                const path = url.replace(/^https?:\/\/github\.com\//i, "");
+                const gh = await runCli("gh", ["api", `repos/${path.split("/").slice(0, 2).join("/")}`], 30_000);
+                if (gh.code === 0) {
+                    try {
+                        return { platform: "github", backend: "gh", ok: true, data: JSON.parse(gh.stdout) };
+                    }
+                    catch {
+                        return { platform: "github", backend: "gh", ok: true, data: gh.stdout };
+                    }
+                }
+                const text = await fetchText(`https://r.jina.ai/${url}`);
+                return { platform: "github", backend: "jina-reader", ok: true, data: { url, content: text.slice(0, 80_000) } };
+            }
+            case "bilibili": {
+                const bv = url.match(/BV[\w]+/i)?.[0];
+                if (bv) {
+                    const data = await fetchJson(`https://api.bilibili.com/x/web-interface/view?bvid=${bv}`);
+                    return { platform: "bilibili", backend: "bilibili-api", ok: true, data };
+                }
+                const text = await fetchText(`https://r.jina.ai/${url}`);
+                return { platform: "bilibili", backend: "jina-reader", ok: true, data: { url, content: text.slice(0, 80_000) } };
+            }
+            case "reddit": {
+                const opencli = await runCli("opencli", ["reddit", "read", url, "-f", "yaml"], 60_000);
+                if (opencli.code === 0) {
+                    return { platform: "reddit", backend: "opencli", ok: true, data: opencli.stdout };
+                }
+                const rdt = await runCli("rdt", ["read", url], 60_000);
+                if (rdt.code === 0) {
+                    return { platform: "reddit", backend: "rdt-cli", ok: true, data: rdt.stdout };
+                }
+                return {
+                    platform: "reddit",
+                    backend: "none",
+                    ok: false,
+                    error: "Reddit requires login. Install OpenCLI (desktop + Chrome extension) or rdt-cli, then log in.",
+                };
+            }
+            case "twitter": {
+                const twitter = await runCli("twitter", ["read", url], 60_000);
+                if (twitter.code === 0) {
+                    return { platform: "twitter", backend: "twitter-cli", ok: true, data: twitter.stdout };
+                }
+                const opencli = await runCli("opencli", ["twitter", "read", url, "-f", "yaml"], 60_000);
+                if (opencli.code === 0) {
+                    return { platform: "twitter", backend: "opencli", ok: true, data: opencli.stdout };
+                }
+                return {
+                    platform: "twitter",
+                    backend: "none",
+                    ok: false,
+                    error: "Twitter needs twitter-cli cookies (TWITTER_AUTH_TOKEN/TWITTER_CT0) or OpenCLI session.",
+                };
+            }
+            case "xiaohongshu":
+            case "facebook":
+            case "instagram": {
+                const opencli = await runCli("opencli", [resolved, "read", url, "-f", "yaml"], 60_000);
+                if (opencli.code === 0) {
+                    return { platform: resolved, backend: "opencli", ok: true, data: opencli.stdout };
+                }
+                return {
+                    platform: resolved,
+                    backend: "none",
+                    ok: false,
+                    error: `${resolved} requires OpenCLI + Chrome logged-in session.`,
+                };
+            }
+            case "linkedin":
+            case "xueqiu": {
+                const text = await fetchText(`https://r.jina.ai/${url}`);
+                return {
+                    platform: resolved,
+                    backend: "jina-reader",
+                    ok: true,
+                    data: { url, content: text.slice(0, 80_000), note: "Public page only; authenticated features need extra setup." },
+                };
+            }
+            default:
+                return { platform: String(resolved), backend: "none", ok: false, error: `Unsupported platform: ${resolved}` };
+        }
+    }
+    catch (error) {
+        return {
+            platform: resolved,
+            backend: "error",
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export async function searchPlatform(platform, query, limit = 10) {
+    const q = query.trim();
+    if (!q)
+        return { platform, backend: "none", ok: false, error: "query is required" };
+    try {
+        switch (platform) {
+            case "web":
+            case "exa": {
+                const mcp = await runCli("mcporter", ["call", "exa.web_search_exa", `query=${q}`, `numResults=${limit}`], 60_000);
+                if (mcp.code === 0) {
+                    return { platform: "exa", backend: "mcporter-exa", ok: true, data: mcp.stdout };
+                }
+                const text = await fetchText(`https://r.jina.ai/https://duckduckgo.com/html/?q=${encodeURIComponent(q)}`);
+                return {
+                    platform: "web",
+                    backend: "jina-ddg",
+                    ok: true,
+                    data: { query: q, content: text.slice(0, 40_000), note: mcp.stderr || "Exa unavailable; used DDG via Jina." },
+                };
+            }
+            case "v2ex": {
+                const data = await fetchJson(`https://www.v2ex.com/api/topics/hot.json`);
+                const list = Array.isArray(data) ? data : [];
+                const filtered = list
+                    .filter((item) => JSON.stringify(item).toLowerCase().includes(q.toLowerCase()))
+                    .slice(0, limit);
+                return {
+                    platform: "v2ex",
+                    backend: "v2ex-api",
+                    ok: true,
+                    data: filtered.length > 0 ? filtered : list.slice(0, limit),
+                };
+            }
+            case "bilibili": {
+                const data = await fetchJson(`https://api.bilibili.com/x/web-interface/search/type?search_type=video&keyword=${encodeURIComponent(q)}&page=1`);
+                return { platform: "bilibili", backend: "bilibili-api", ok: true, data };
+            }
+            case "github": {
+                const gh = await runCli("gh", ["search", "repos", q, "--limit", String(limit), "--json", "fullName,description,url,stargazersCount"], 30_000);
+                if (gh.code === 0) {
+                    try {
+                        return { platform: "github", backend: "gh", ok: true, data: JSON.parse(gh.stdout) };
+                    }
+                    catch {
+                        return { platform: "github", backend: "gh", ok: true, data: gh.stdout };
+                    }
+                }
+                return { platform: "github", backend: "gh", ok: false, error: gh.stderr || "gh search failed" };
+            }
+            case "youtube": {
+                const ytdlp = await runCli("yt-dlp", [`ytsearch${limit}:${q}`, "--dump-json", "--flat-playlist", "--skip-download"], 90_000);
+                if (ytdlp.code !== 0) {
+                    return { platform: "youtube", backend: "yt-dlp", ok: false, error: ytdlp.stderr || "yt-dlp search failed" };
+                }
+                const lines = ytdlp.stdout
+                    .split(/\r?\n/)
+                    .map((l) => l.trim())
+                    .filter(Boolean)
+                    .map((line) => {
+                    try {
+                        return JSON.parse(line);
+                    }
+                    catch {
+                        return line;
+                    }
+                });
+                return { platform: "youtube", backend: "yt-dlp", ok: true, data: lines };
+            }
+            case "reddit": {
+                const opencli = await runCli("opencli", ["reddit", "search", q, "-f", "yaml"], 60_000);
+                if (opencli.code === 0)
+                    return { platform: "reddit", backend: "opencli", ok: true, data: opencli.stdout };
+                const rdt = await runCli("rdt", ["search", q], 60_000);
+                if (rdt.code === 0)
+                    return { platform: "reddit", backend: "rdt-cli", ok: true, data: rdt.stdout };
+                return {
+                    platform: "reddit",
+                    backend: "none",
+                    ok: false,
+                    error: "Reddit search needs OpenCLI or rdt-cli with login.",
+                };
+            }
+            case "twitter": {
+                const twitter = await runCli("twitter", ["search", q, "-n", String(limit)], 60_000);
+                if (twitter.code === 0)
+                    return { platform: "twitter", backend: "twitter-cli", ok: true, data: twitter.stdout };
+                return {
+                    platform: "twitter",
+                    backend: "none",
+                    ok: false,
+                    error: "Twitter search needs twitter-cli + TWITTER_AUTH_TOKEN/TWITTER_CT0.",
+                };
+            }
+            case "xiaohongshu":
+            case "facebook":
+            case "instagram": {
+                const opencli = await runCli("opencli", [platform, "search", q, "-f", "yaml"], 60_000);
+                if (opencli.code === 0)
+                    return { platform, backend: "opencli", ok: true, data: opencli.stdout };
+                return {
+                    platform,
+                    backend: "none",
+                    ok: false,
+                    error: `${platform} search requires OpenCLI + logged-in Chrome session.`,
+                };
+            }
+            default:
+                return {
+                    platform: String(platform),
+                    backend: "none",
+                    ok: false,
+                    error: `Search not implemented for platform: ${platform}`,
+                };
+        }
+    }
+    catch (error) {
+        return {
+            platform: String(platform),
+            backend: "error",
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export async function nativeDoctor() {
+    const channels = [];
+    const push = (c) => channels.push(c);
+    try {
+        await fetchText("https://r.jina.ai/https://example.com", 15_000);
+        push({ id: "web", name: "Web (Jina Reader)", status: "ok", backend: "jina", detail: "Readable" });
+    }
+    catch (e) {
+        push({
+            id: "web",
+            name: "Web (Jina Reader)",
+            status: "missing",
+            detail: e instanceof Error ? e.message : String(e),
+        });
+    }
+    try {
+        await fetchJson("https://www.v2ex.com/api/topics/hot.json", 15_000);
+        push({ id: "v2ex", name: "V2EX", status: "ok", backend: "v2ex-api", detail: "Public API reachable" });
+    }
+    catch (e) {
+        push({ id: "v2ex", name: "V2EX", status: "missing", detail: e instanceof Error ? e.message : String(e) });
+    }
+    push({ id: "rss", name: "RSS/Atom", status: "ok", backend: "native-rss", detail: "Parser available" });
+    const ytdlp = await findOnPath("yt-dlp");
+    push(ytdlp
+        ? { id: "youtube", name: "YouTube", status: "ok", backend: "yt-dlp", detail: ytdlp }
+        : { id: "youtube", name: "YouTube", status: "missing", detail: "yt-dlp not installed" });
+    const gh = await findOnPath("gh");
+    push(gh
+        ? { id: "github", name: "GitHub", status: "partial", backend: "gh", detail: `${gh} (auth not verified)` }
+        : { id: "github", name: "GitHub", status: "missing", detail: "gh CLI not installed" });
+    try {
+        await fetchJson("https://api.bilibili.com/x/web-interface/search/type?search_type=video&keyword=test&page=1", 15_000);
+        push({ id: "bilibili", name: "Bilibili", status: "ok", backend: "bilibili-api", detail: "Search API reachable" });
+    }
+    catch (e) {
+        push({ id: "bilibili", name: "Bilibili", status: "missing", detail: e instanceof Error ? e.message : String(e) });
+    }
+    const mcporter = await findOnPath("mcporter");
+    push(mcporter
+        ? { id: "exa", name: "Exa search", status: "partial", backend: "mcporter", detail: `${mcporter} (remote not probed)` }
+        : { id: "exa", name: "Exa search", status: "missing", detail: "mcporter not installed" });
+    const opencli = await findOnPath("opencli");
+    const rdt = await findOnPath("rdt");
+    const twitter = await findOnPath("twitter");
+    push(opencli || rdt
+        ? {
+            id: "reddit",
+            name: "Reddit",
+            status: "partial",
+            backend: opencli ? "opencli" : "rdt-cli",
+            detail: "CLI present; login required",
+        }
+        : { id: "reddit", name: "Reddit", status: "missing", detail: "Need OpenCLI or rdt-cli + login" });
+    push(twitter || opencli
+        ? {
+            id: "twitter",
+            name: "Twitter/X",
+            status: "partial",
+            backend: twitter ? "twitter-cli" : "opencli",
+            detail: "CLI present; cookies/session required",
+        }
+        : { id: "twitter", name: "Twitter/X", status: "missing", detail: "Need twitter-cli or OpenCLI" });
+    for (const id of ["xiaohongshu", "facebook", "instagram"]) {
+        push(opencli
+            ? { id, name: id, status: "partial", backend: "opencli", detail: "OpenCLI present; Chrome session required" }
+            : { id, name: id, status: "missing", detail: "OpenCLI required" });
+    }
+    return channels;
+}
+export { findOnPath, runCli };