@greatlhd/ailo-desktop 1.0.0

package/dist/qq-ws.js

@@ -0,0 +1,178 @@
+import WebSocket from "ws";
+import { OP_DISPATCH, OP_HEARTBEAT, OP_IDENTIFY, OP_RESUME, OP_RECONNECT, OP_INVALID_SESSION, OP_HELLO, OP_HEARTBEAT_ACK, INTENT_PUBLIC_GUILD_MESSAGES, INTENT_DIRECT_MESSAGE, INTENT_GROUP_AND_C2C, DEFAULT_API_BASE, TOKEN_URL, RECONNECT_DELAYS, MAX_RECONNECT_ATTEMPTS, } from "./qq-types.js";
+export class QQGatewayClient {
+    config;
+    ws = null;
+    heartbeatTimer = null;
+    lastSeq = null;
+    sessionId = null;
+    reconnectAttempts = 0;
+    closed = false;
+    accessToken = "";
+    tokenExpiresAt = 0;
+    onDispatch;
+    log;
+    constructor(config, onDispatch, log) {
+        this.config = config;
+        this.onDispatch = onDispatch;
+        this.log = log ?? ((level, msg, data) => console.log(`[qq-ws] [${level}] ${msg}`, data ?? ""));
+    }
+    get apiBase() {
+        return (this.config.apiBase ?? DEFAULT_API_BASE).replace(/\/$/, "");
+    }
+    async refreshToken() {
+        if (this.accessToken && Date.now() < this.tokenExpiresAt - 30_000) {
+            return this.accessToken;
+        }
+        const res = await fetch(TOKEN_URL, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ appId: this.config.appId, clientSecret: this.config.appSecret }),
+        });
+        if (!res.ok)
+            throw new Error(`QQ token refresh failed: HTTP ${res.status}`);
+        const body = (await res.json());
+        this.accessToken = body.access_token;
+        this.tokenExpiresAt = Date.now() + body.expires_in * 1000;
+        this.log("info", "access token refreshed", { expires_in: body.expires_in });
+        return this.accessToken;
+    }
+    getAccessToken() {
+        return this.accessToken;
+    }
+    async connect() {
+        this.closed = false;
+        await this.refreshToken();
+        const gatewayUrl = await this.fetchGatewayUrl();
+        this.log("info", `connecting to gateway: ${gatewayUrl}`);
+        this.createConnection(gatewayUrl);
+    }
+    async fetchGatewayUrl() {
+        const token = await this.refreshToken();
+        const res = await fetch(`${this.apiBase}/gateway`, {
+            headers: { Authorization: `QQBot ${token}` },
+        });
+        if (!res.ok)
+            throw new Error(`QQ gateway fetch failed: HTTP ${res.status}`);
+        const body = (await res.json());
+        return body.url;
+    }
+    createConnection(url) {
+        const ws = new WebSocket(url);
+        this.ws = ws;
+        ws.on("open", () => {
+            this.log("info", "WebSocket connected");
+            this.reconnectAttempts = 0;
+        });
+        ws.on("message", (raw) => {
+            try {
+                const payload = JSON.parse(raw.toString("utf-8"));
+                this.handlePayload(payload);
+            }
+            catch (err) {
+                this.log("error", "failed to parse WS message", { err: String(err) });
+            }
+        });
+        ws.on("close", (code, reason) => {
+            this.log("warn", `WebSocket closed: ${code} ${reason.toString("utf-8")}`);
+            this.stopHeartbeat();
+            if (!this.closed)
+                this.scheduleReconnect();
+        });
+        ws.on("error", (err) => {
+            this.log("error", "WebSocket error", { err: err.message });
+        });
+    }
+    handlePayload(payload) {
+        if (payload.s != null)
+            this.lastSeq = payload.s;
+        switch (payload.op) {
+            case OP_HELLO:
+                this.startHeartbeat(payload.d?.heartbeat_interval ?? 41250);
+                if (this.sessionId) {
+                    this.sendResume();
+                }
+                else {
+                    this.sendIdentify();
+                }
+                break;
+            case OP_DISPATCH:
+                if (payload.t === "READY") {
+                    this.sessionId = payload.d?.session_id ?? null;
+                    this.log("info", "READY", { session_id: this.sessionId });
+                }
+                if (payload.t) {
+                    this.onDispatch(payload.t, payload.d);
+                }
+                break;
+            case OP_HEARTBEAT_ACK:
+                break;
+            case OP_RECONNECT:
+                this.log("info", "server requested reconnect");
+                this.ws?.close(4000, "reconnect");
+                break;
+            case OP_INVALID_SESSION:
+                this.log("warn", "invalid session, re-identifying");
+                this.sessionId = null;
+                this.lastSeq = null;
+                setTimeout(() => this.sendIdentify(), 2000);
+                break;
+            default:
+                this.log("debug", `unhandled op: ${payload.op}`, { d: payload.d });
+        }
+    }
+    sendIdentify() {
+        const intents = INTENT_PUBLIC_GUILD_MESSAGES | INTENT_DIRECT_MESSAGE | INTENT_GROUP_AND_C2C;
+        this.send({
+            op: OP_IDENTIFY,
+            d: { token: `QQBot ${this.accessToken}`, intents, shard: [0, 1] },
+        });
+        this.log("debug", "sent IDENTIFY");
+    }
+    sendResume() {
+        this.send({
+            op: OP_RESUME,
+            d: { token: `QQBot ${this.accessToken}`, session_id: this.sessionId, seq: this.lastSeq },
+        });
+        this.log("debug", "sent RESUME");
+    }
+    startHeartbeat(intervalMs) {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            this.send({ op: OP_HEARTBEAT, d: this.lastSeq });
+        }, intervalMs);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    send(payload) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(payload));
+        }
+    }
+    scheduleReconnect() {
+        if (this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+            this.log("error", "max reconnect attempts reached, giving up");
+            return;
+        }
+        const delay = RECONNECT_DELAYS[Math.min(this.reconnectAttempts, RECONNECT_DELAYS.length - 1)] * 1000;
+        this.reconnectAttempts++;
+        this.log("info", `reconnecting in ${delay / 1000}s (attempt ${this.reconnectAttempts})`);
+        setTimeout(() => {
+            if (!this.closed) {
+                this.connect().catch((err) => this.log("error", "reconnect failed", { err: String(err) }));
+            }
+        }, delay);
+    }
+    close() {
+        this.closed = true;
+        this.stopHeartbeat();
+        if (this.ws) {
+            this.ws.close(1000, "shutdown");
+            this.ws = null;
+        }
+    }
+}

package/dist/screenshot.js

@@ -0,0 +1,271 @@
+import { randomUUID } from "crypto";
+import { spawnSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+function ok(message, observation) {
+    return [
+        {
+            type: "text",
+            text: JSON.stringify({
+                ok: true,
+                message,
+                observation: {
+                    observation_id: observation.id,
+                    timestamp: observation.timestamp,
+                    scope: observation.scope,
+                    coordinate_space: observation.coordinateSpace,
+                    image_width: observation.imageWidth,
+                    image_height: observation.imageHeight,
+                    image_path: observation.image.path,
+                },
+            }, null, 2),
+        },
+        {
+            type: "image",
+            media: {
+                type: "image",
+                path: observation.image.path,
+                mime: observation.image.mime,
+                name: observation.image.name,
+            },
+        },
+    ];
+}
+function fail(error) {
+    return {
+        parts: [{ type: "text", text: JSON.stringify({ ok: false, error }, null, 2) }],
+    };
+}
+export function getScreenInfo() {
+    const platform = os.platform();
+    if (platform === "win32") {
+        const ps = [
+            "Add-Type -AssemblyName System.Windows.Forms",
+            "$screens=[System.Windows.Forms.Screen]::AllScreens",
+            "$primary=[System.Windows.Forms.Screen]::PrimaryScreen",
+            "$vs=[System.Windows.Forms.SystemInformation]::VirtualScreen",
+            "$r=@()",
+            "for($i=0;$i -lt $screens.Count;$i++){",
+            "  $b=$screens[$i].Bounds",
+            "  $r+=@{index=$i;x=$b.X;y=$b.Y;width=$b.Width;height=$b.Height;primary=($screens[$i] -eq $primary)}",
+            "}",
+            "Write-Output (@{count=$screens.Count;screens=$r;virtualBounds=@{x=$vs.X;y=$vs.Y;width=$vs.Width;height=$vs.Height}}|ConvertTo-Json -Compress)",
+        ].join("; ");
+        const r = spawnSync("powershell", ["-Command", ps], { encoding: "utf-8", timeout: 5000 });
+        try {
+            const j = JSON.parse((r.stdout ?? "").trim());
+            return {
+                count: j.count ?? 1,
+                screens: (j.screens ?? []).map((s) => ({
+                    index: s.index,
+                    x: s.x ?? 0,
+                    y: s.y ?? 0,
+                    width: s.width,
+                    height: s.height,
+                    primary: !!s.primary,
+                })),
+                virtualBounds: {
+                    x: j.virtualBounds?.x ?? 0,
+                    y: j.virtualBounds?.y ?? 0,
+                    width: j.virtualBounds?.width ?? 1920,
+                    height: j.virtualBounds?.height ?? 1080,
+                },
+            };
+        }
+        catch {
+            return {
+                count: 1,
+                screens: [{ index: 0, x: 0, y: 0, width: 1920, height: 1080, primary: true }],
+                virtualBounds: { x: 0, y: 0, width: 1920, height: 1080 },
+            };
+        }
+    }
+    else if (platform === "darwin") {
+        const r = spawnSync("system_profiler", ["SPDisplaysDataType", "-json"], { encoding: "utf-8", timeout: 5000 });
+        try {
+            const j = JSON.parse((r.stdout ?? "").trim());
+            const displays = (j?.SPDisplaysDataType ?? []).flatMap((d) => d.spdisplays_ndrvs ?? [d]);
+            const screens = displays
+                .filter((d) => d.spdisplays_resolution)
+                .map((d, i) => {
+                const m = String(d.spdisplays_resolution ?? "").match(/(\d+)\s*x\s*(\d+)/);
+                return {
+                    index: i,
+                    x: 0,
+                    y: 0,
+                    width: m ? Number(m[1]) : 1920,
+                    height: m ? Number(m[2]) : 1080,
+                    primary: i === 0,
+                };
+            });
+            const primary = screens[0] ?? { index: 0, x: 0, y: 0, width: 1920, height: 1080, primary: true };
+            return { count: screens.length || 1, screens: screens.length ? screens : [primary], virtualBounds: { x: 0, y: 0, width: primary.width, height: primary.height } };
+        }
+        catch {
+            return {
+                count: 1,
+                screens: [{ index: 0, x: 0, y: 0, width: 1920, height: 1080, primary: true }],
+                virtualBounds: { x: 0, y: 0, width: 1920, height: 1080 },
+            };
+        }
+    }
+    else {
+        const r = spawnSync("xdpyinfo", [], { encoding: "utf-8", timeout: 5000 });
+        const m = (r.stdout ?? "").match(/dimensions:\s*(\d+)x(\d+)/);
+        const width = m ? Number(m[1]) : 1920;
+        const height = m ? Number(m[2]) : 1080;
+        return {
+            count: 1,
+            screens: [{ index: 0, x: 0, y: 0, width, height, primary: true }],
+            virtualBounds: { x: 0, y: 0, width, height },
+        };
+    }
+}
+function buildObservation(args) {
+    const { imagePath, imageWidth, imageHeight, captureWindow, screenOpt } = args;
+    const screenInfo = getScreenInfo();
+    let scope;
+    let coordinateSpace;
+    if (captureWindow) {
+        scope = {
+            kind: "window",
+            bounds: { x: 0, y: 0, width: imageWidth, height: imageHeight },
+        };
+        coordinateSpace = "window_local";
+    }
+    else if (typeof screenOpt === "number") {
+        const screen = screenInfo.screens.find((item) => item.index === screenOpt) ?? screenInfo.screens[0];
+        scope = {
+            kind: "screen",
+            screenIndex: screen.index,
+            bounds: { x: screen.x, y: screen.y, width: screen.width, height: screen.height },
+        };
+        coordinateSpace = "screen_local";
+    }
+    else {
+        scope = {
+            kind: "virtual_screen",
+            bounds: screenInfo.virtualBounds,
+        };
+        coordinateSpace = "virtual_screen";
+    }
+    return {
+        id: `obs_${randomUUID()}`,
+        timestamp: Date.now(),
+        scope,
+        coordinateSpace,
+        imageWidth,
+        imageHeight,
+        image: {
+            path: imagePath,
+            mime: "image/png",
+            name: "screenshot.png",
+        },
+    };
+}
+export async function captureDesktopObservation(opts = false) {
+    const captureWindow = typeof opts === "boolean" ? opts : !!opts.capture_window;
+    const screenOpt = typeof opts === "boolean" ? undefined : opts?.screen;
+    const tmpPath = path.join(os.tmpdir(), `ailo_screenshot_${Date.now()}.png`);
+    const platform = os.platform();
+    if (platform === "darwin") {
+        if (captureWindow) {
+            spawnSync("screencapture", ["-w", tmpPath]);
+        }
+        else if (typeof screenOpt === "number") {
+            spawnSync("screencapture", ["-x", "-D", String(screenOpt + 1), tmpPath]);
+        }
+        else {
+            spawnSync("screencapture", ["-x", tmpPath]);
+        }
+    }
+    else if (platform === "win32") {
+        const escaped = tmpPath.replace(/'/g, "''").replace(/\\/g, "\\\\");
+        let ps;
+        if (typeof screenOpt === "number") {
+            ps = [
+                "Add-Type -AssemblyName System.Windows.Forms",
+                "Add-Type -AssemblyName System.Drawing",
+                "$screens=[System.Windows.Forms.Screen]::AllScreens",
+                `$idx=${screenOpt}`,
+                "if($idx -ge $screens.Count){ $idx=0 }",
+                "$screen=$screens[$idx].Bounds",
+                "$bmp=New-Object System.Drawing.Bitmap($screen.Width,$screen.Height)",
+                "$g=[System.Drawing.Graphics]::FromImage($bmp)",
+                "$g.CopyFromScreen($screen.Location,[System.Drawing.Point]::Empty,$screen.Size)",
+                `$bmp.Save('${escaped}')`,
+            ].join("; ");
+        }
+        else {
+            ps = [
+                "Add-Type -AssemblyName System.Windows.Forms",
+                "Add-Type -AssemblyName System.Drawing",
+                "$vs=[System.Windows.Forms.SystemInformation]::VirtualScreen",
+                "$bmp=New-Object System.Drawing.Bitmap($vs.Width,$vs.Height)",
+                "$g=[System.Drawing.Graphics]::FromImage($bmp)",
+                "$g.CopyFromScreen($vs.X,$vs.Y,0,0,[System.Drawing.Size]::new($vs.Width,$vs.Height))",
+                `$bmp.Save('${escaped}')`,
+            ].join("; ");
+        }
+        spawnSync("powershell", ["-Command", ps]);
+    }
+    else {
+        const r = spawnSync("scrot", [tmpPath]);
+        if (r.status !== 0)
+            spawnSync("import", ["-window", "root", tmpPath]);
+    }
+    if (!fs.existsSync(tmpPath))
+        return fail("截图失败：未能生成截图文件");
+    let imageWidth = 0;
+    let imageHeight = 0;
+    try {
+        const screenInfo = getScreenInfo();
+        if (typeof screenOpt === "number") {
+            const screen = screenInfo.screens.find((item) => item.index === screenOpt) ?? screenInfo.screens[0];
+            imageWidth = screen.width;
+            imageHeight = screen.height;
+        }
+        else {
+            imageWidth = screenInfo.virtualBounds.width;
+            imageHeight = screenInfo.virtualBounds.height;
+        }
+    }
+    catch {
+        imageWidth = 1920;
+        imageHeight = 1080;
+    }
+    const observation = buildObservation({
+        imagePath: tmpPath,
+        imageWidth,
+        imageHeight,
+        captureWindow,
+        screenOpt,
+    });
+    let message;
+    if (captureWindow) {
+        message = "窗口截图完成";
+    }
+    else {
+        const screenInfo = getScreenInfo();
+        if (screenInfo.count > 1) {
+            if (typeof screenOpt === "number") {
+                message = `截图完成（第 ${screenOpt + 1} 块/共 ${screenInfo.count} 块屏。可用 screen=0～${screenInfo.count - 1} 分别截取其他屏）`;
+            }
+            else {
+                message = `截图完成（共 ${screenInfo.count} 块屏，已截取全部。可用 screen=0～${screenInfo.count - 1} 分别截取单块）`;
+            }
+        }
+        else {
+            message = typeof screenOpt === "number" ? `显示器 ${screenOpt} 截图完成` : "截图完成";
+        }
+    }
+    return {
+        parts: ok(message, observation),
+        observation,
+    };
+}
+export async function takeScreenshot(opts = false) {
+    const result = await captureDesktopObservation(opts);
+    return result.parts;
+}

package/dist/skills_hub.js

@@ -0,0 +1,212 @@
+/**
+ * Skills Hub client — compatible with skills.sh, clawhub.ai, skillsmp.com, GitHub.
+ * Downloads SKILL.md + references/ + scripts/ bundles from any supported marketplace URL.
+ */
+import { mkdir, writeFile } from "fs/promises";
+import { join, dirname } from "path";
+import { readConfig } from "@lmcl/ailo-endpoint-sdk";
+import { CONFIG_FILENAME } from "./constants.js";
+function loadLocalConfig() {
+    return readConfig(join(process.cwd(), CONFIG_FILENAME));
+}
+function detectSource(url) {
+    const u = new URL(url);
+    const host = u.hostname.replace("www.", "");
+    if (host === "skills.sh")
+        return "skills_sh";
+    if (host === "clawhub.ai")
+        return "clawhub";
+    if (host === "skillsmp.com")
+        return "skillsmp";
+    if (host === "github.com")
+        return "github";
+    return null;
+}
+export async function installFromUrl(url, targetDir) {
+    const source = detectSource(url);
+    if (!source)
+        throw new Error(`Unsupported URL: ${url}. Supported: skills.sh, clawhub.ai, skillsmp.com, github.com`);
+    let bundle;
+    switch (source) {
+        case "skills_sh":
+            bundle = await fetchSkillsSh(url);
+            break;
+        case "clawhub":
+            bundle = await fetchClawhub(url);
+            break;
+        case "skillsmp":
+            bundle = await fetchSkillsmp(url);
+            break;
+        case "github":
+            bundle = await fetchGitHub(url);
+            break;
+    }
+    const skillDir = join(targetDir, bundle.name);
+    await mkdir(skillDir, { recursive: true });
+    await writeFile(join(skillDir, "SKILL.md"), bundle.skillMd, "utf-8");
+    for (const [relPath, content] of bundle.files) {
+        const fullPath = join(skillDir, relPath);
+        await mkdir(dirname(fullPath), { recursive: true });
+        await writeFile(fullPath, content, "utf-8");
+    }
+    return bundle;
+}
+// --- skills.sh ---
+// Format: https://skills.sh/{owner}/{repo}/{skill}
+async function fetchSkillsSh(url) {
+    const u = new URL(url);
+    const parts = u.pathname.split("/").filter(Boolean);
+    if (parts.length < 3)
+        throw new Error("skills.sh URL must be: skills.sh/{owner}/{repo}/{skill}");
+    const [owner, repo, skill] = parts;
+    const dirs = [`skills/${skill}`, skill];
+    for (const dir of dirs) {
+        try {
+            return await fetchGitHubDir(owner, repo, "main", dir, skill);
+        }
+        catch {
+            try {
+                return await fetchGitHubDir(owner, repo, "master", dir, skill);
+            }
+            catch { }
+        }
+    }
+    throw new Error(`Skill not found in ${owner}/${repo}: tried ${dirs.join(", ")}`);
+}
+// --- clawhub.ai ---
+// Format: https://clawhub.ai/{slug}
+async function fetchClawhub(url) {
+    const u = new URL(url);
+    const slug = u.pathname.split("/").filter(Boolean).pop();
+    if (!slug)
+        throw new Error("clawhub URL must contain a slug");
+    const cfg = loadLocalConfig();
+    const hubBase = cfg.skillsHubBaseUrl ?? "https://clawhub.ai";
+    const meta = await httpJson(`${hubBase}/api/v1/skills/${slug}`);
+    const repoUrl = meta.repo_url ?? meta.github_url;
+    if (!repoUrl)
+        throw new Error(`No repo_url found for skill ${slug}`);
+    return fetchGitHub(repoUrl);
+}
+// --- skillsmp.com ---
+// Format: https://skillsmp.com/{slug}
+// Slug: openclaw-openclaw-skills-himalaya-skill-md → owner/repo/skill_hint
+async function fetchSkillsmp(url) {
+    const u = new URL(url);
+    const slug = u.pathname.split("/").filter(Boolean).pop();
+    if (!slug)
+        throw new Error("skillsmp URL must contain a slug");
+    const parts = slug.split("-");
+    if (parts.length < 3)
+        throw new Error(`Cannot parse skillsmp slug: ${slug}`);
+    const owner = parts[0];
+    const repo = parts.slice(1, 3).join("-");
+    const skillHint = parts.slice(3).join("-").replace(/-skill-md$/, "");
+    const dirs = [skillHint, `skills/${skillHint}`];
+    for (const dir of dirs) {
+        try {
+            return await fetchGitHubDir(owner, repo, "main", dir, skillHint);
+        }
+        catch { }
+        try {
+            return await fetchGitHubDir(owner, repo, "master", dir, skillHint);
+        }
+        catch { }
+    }
+    throw new Error(`Skill not found: ${owner}/${repo} hint=${skillHint}`);
+}
+// --- GitHub ---
+// Format: https://github.com/{owner}/{repo}/tree/{branch}/{path}
+// or: https://github.com/{owner}/{repo}/blob/{branch}/{path}/SKILL.md
+async function fetchGitHub(url) {
+    const u = new URL(url);
+    const parts = u.pathname.split("/").filter(Boolean);
+    if (parts.length < 2)
+        throw new Error("GitHub URL must be: github.com/{owner}/{repo}/...");
+    const owner = parts[0];
+    const repo = parts[1];
+    if (parts.length >= 4 && (parts[2] === "tree" || parts[2] === "blob")) {
+        const branch = parts[3];
+        let dirPath = parts.slice(4).join("/");
+        if (dirPath.endsWith("/SKILL.md") || dirPath.endsWith("SKILL.md")) {
+            dirPath = dirPath.replace(/\/?SKILL\.md$/, "");
+        }
+        const name = dirPath.split("/").pop() || repo;
+        return fetchGitHubDir(owner, repo, branch, dirPath, name);
+    }
+    return fetchGitHubDir(owner, repo, "main", "", repo);
+}
+// --- Core GitHub fetcher ---
+async function fetchGitHubDir(owner, repo, branch, dirPath, name) {
+    const prefix = dirPath ? `${dirPath}/` : "";
+    const apiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${dirPath}?ref=${branch}`;
+    const entries = await httpJson(apiUrl);
+    if (!Array.isArray(entries)) {
+        if (entries.name === "SKILL.md") {
+            const content = await httpText(entries.download_url);
+            return { name, skillMd: content, files: new Map() };
+        }
+        throw new Error(`Not a directory: ${dirPath}`);
+    }
+    const skillEntry = entries.find((e) => e.name === "SKILL.md");
+    if (!skillEntry)
+        throw new Error(`SKILL.md not found in ${owner}/${repo}/${dirPath}`);
+    const skillMd = await httpText(skillEntry.download_url);
+    const files = new Map();
+    for (const entry of entries) {
+        if (entry.name === "SKILL.md")
+            continue;
+        if (entry.type === "file") {
+            const relPath = entry.path.replace(prefix, "");
+            try {
+                const content = await httpText(entry.download_url);
+                files.set(relPath, content);
+            }
+            catch { }
+        }
+        else if (entry.type === "dir") {
+            await fetchGitHubDirRecursive(owner, repo, branch, entry.path, prefix, files);
+        }
+    }
+    return { name, skillMd, files };
+}
+async function fetchGitHubDirRecursive(owner, repo, branch, dirPath, rootPrefix, files) {
+    const apiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${dirPath}?ref=${branch}`;
+    try {
+        const entries = await httpJson(apiUrl);
+        if (!Array.isArray(entries))
+            return;
+        for (const entry of entries) {
+            const relPath = entry.path.replace(rootPrefix, "");
+            if (entry.type === "file") {
+                try {
+                    const content = await httpText(entry.download_url);
+                    files.set(relPath, content);
+                }
+                catch { }
+            }
+            else if (entry.type === "dir") {
+                await fetchGitHubDirRecursive(owner, repo, branch, entry.path, rootPrefix, files);
+            }
+        }
+    }
+    catch { }
+}
+// --- HTTP helpers ---
+function httpJson(url) {
+    return httpText(url).then((t) => JSON.parse(t));
+}
+async function httpText(url) {
+    const headers = { "User-Agent": "ailo-desktop/1.0" };
+    try {
+        const cfg = loadLocalConfig();
+        const ghToken = cfg.githubToken || "";
+        if (ghToken && url.includes("api.github.com"))
+            headers.Authorization = `token ${ghToken}`;
+    }
+    catch { /* config not available, proceed without token */ }
+    const res = await fetch(url, { headers, redirect: "follow" });
+    if (!res.ok)
+        throw new Error(`HTTP ${res.status} for ${url}`);
+    return res.text();
+}