pi-maestro-mobile 0.1.2

package/dist/server/mobile-host-server.js

@@ -0,0 +1,715 @@
+import { createServer } from "node:http";
+import { URL } from "node:url";
+import { WebSocketServer } from "ws";
+import { readFile, open, stat } from "node:fs/promises";
+import { realpath } from "node:fs/promises";
+import { isAbsolute, normalize } from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { projectMonitorState } from "../monitor-projection.js";
+import { readSettingsOverview, updateSettingsJson } from "../maestro-settings.js";
+import { validateClientCommand } from "../vendor/shared/index.js";
+/**
+ * MobileHostServer — 移动端直连服务器（HTTP REST + WebSocket）
+ *
+ * 直连模式：同一局域网/同机，无 relay。
+ * - WS: /ws 实时事件流 + 客户端命令
+ * - HTTP: /api/health, /api/status, /api/sessions, /api/maestro
+ *
+ * 安全：token 可选（Bearer header 或 ?token=）
+ */
+export class MobileHostServer {
+    controller;
+    options;
+    server;
+    webSocketServer = new WebSocketServer({ noServer: true, maxPayload: 8 * 1024 * 1024 });
+    clients = new Set();
+    /** 单客户端并发命令上限：超过则拒绝，防命令洪泛（DoS） */
+    static MAX_CONNECTIONS = 32;
+    static MAX_CONCURRENT_COMMANDS = 8;
+    unsubscribeController;
+    boundHost = "0.0.0.0";
+    constructor(controller, options = {}) {
+        this.controller = controller;
+        this.options = options;
+        this.server = createServer((request, response) => {
+            void this.handleHttp(request, response);
+        });
+        this.server.on("upgrade", (request, socket, head) => {
+            this.handleUpgrade(request, socket, head);
+        });
+        this.webSocketServer.on("connection", (ws) => {
+            if (this.clients.size >= MobileHostServer.MAX_CONNECTIONS) {
+                ws.close(1013, "too many connections");
+                return;
+            }
+            const client = { id: crypto.randomUUID(), ws, inflight: 0 };
+            this.clients.add(client);
+            // P2-1：host_status 契约是 status: string；HostStatus 对象走独立的 host_info 事件
+            ws.send(JSON.stringify({ type: "host_status", status: "connected", seq: 0 }));
+            ws.send(JSON.stringify({ type: "host_info", info: this.controller.getStatus(), seq: 0 }));
+            ws.on("message", (data) => {
+                if (client.inflight >= MobileHostServer.MAX_CONCURRENT_COMMANDS) {
+                    this.sendError(client, "too_many_commands", "");
+                    return;
+                }
+                client.inflight++;
+                void this.handleClientMessage(client, data).finally(() => {
+                    client.inflight--;
+                });
+            });
+            ws.on("close", () => {
+                this.clients.delete(client);
+            });
+        });
+        this.unsubscribeController = this.controller.onEvent((event) => {
+            const payload = JSON.stringify(event);
+            for (const client of this.clients) {
+                if (client.ws.readyState === client.ws.OPEN) {
+                    client.ws.send(payload);
+                }
+            }
+        });
+    }
+    listen(port, hostname = "0.0.0.0") {
+        this.boundHost = hostname;
+        return new Promise((resolve) => {
+            this.server.listen(port, hostname, () => resolve());
+        });
+    }
+    address() {
+        const address = this.server.address();
+        if (!address || typeof address === "string") {
+            throw new Error("Server is not listening on a TCP port");
+        }
+        return { port: address.port };
+    }
+    async close() {
+        this.unsubscribeController?.();
+        for (const client of this.clients) {
+            client.ws.close();
+        }
+        this.clients.clear();
+        this.webSocketServer.close();
+        await new Promise((resolve, reject) => {
+            this.server.close((error) => (error ? reject(error) : resolve()));
+        });
+    }
+    // ── HTTP ──────────────────────────────────────────────────────────────────
+    async handleHttp(request, response) {
+        try {
+            const url = new URL(request.url ?? "/", `http://${request.headers.host ?? "localhost"}`);
+            applyCorsHeaders(response, this.options.corsOrigin);
+            if (request.method === "OPTIONS") {
+                response.statusCode = 204;
+                response.end();
+                return;
+            }
+            if (!this.authorized(request, url)) {
+                writeJson(response, 401, { error: "Unauthorized" });
+                return;
+            }
+            if (request.method === "GET" && url.pathname === "/api/health") {
+                writeJson(response, 200, { ok: true });
+                return;
+            }
+            if (request.method === "GET" && url.pathname === "/api/status") {
+                const status = this.controller.getStatus();
+                writeJson(response, 200, status);
+                return;
+            }
+            if (request.method === "GET" && url.pathname === "/api/sessions") {
+                const cwd = url.searchParams.get("cwd") ?? undefined;
+                const sessions = await this.controller.listSessions(cwd);
+                const list = await toSessionSummaryList(sessions);
+                writeJson(response, 200, list);
+                return;
+            }
+            if (request.method === "GET" && url.pathname === "/api/maestro") {
+                const state = await this.controller.readMaestroStateNow();
+                writeJson(response, 200, state);
+                return;
+            }
+            if (request.method === "GET" && url.pathname === "/api/maestro-settings") {
+                const overview = await readSettingsOverview();
+                writeJson(response, 200, overview);
+                return;
+            }
+            if (request.method === "GET" && url.pathname === "/api/workspace-telemetry") {
+                const telemetry = await this.controller.readTelemetry();
+                writeJson(response, 200, telemetry);
+                return;
+            }
+            if (request.method === "GET" && url.pathname === "/api/live-sessions") {
+                const list = await this.controller.listLiveSessions();
+                writeJson(response, 200, list);
+                return;
+            }
+            // 图片/文件只读预览：绝对路径 + 图片扩展名 + 大小限制
+            if (request.method === "GET" && url.pathname === "/api/file") {
+                const filePath = url.searchParams.get("path") ?? "";
+                const result = await serveImageFile(filePath);
+                if (!result) {
+                    writeJson(response, 400, { error: "Invalid or unsupported file path" });
+                    return;
+                }
+                const { data, mime } = result;
+                response.writeHead(200, {
+                    "Content-Type": mime,
+                    "Content-Length": data.length,
+                    "Cache-Control": "private, max-age=300",
+                });
+                response.end(data);
+                return;
+            }
+            if (request.method === "GET" && url.pathname === "/api/extension-ui/pending") {
+                writeJson(response, 200, { pending: 0 });
+                return;
+            }
+            writeJson(response, 404, { error: `No route for ${request.method} ${url.pathname}` });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            writeJson(response, 500, { error: message });
+        }
+    }
+    authorized(request, url) {
+        const token = this.options.token;
+        if (!token)
+            return true;
+        const header = request.headers.authorization;
+        if (header && header.startsWith("Bearer ")) {
+            return header.slice("Bearer ".length).trim() === token;
+        }
+        return url.searchParams.get("token") === token;
+    }
+    handleUpgrade(request, socket, head) {
+        const url = new URL(request.url ?? "/", `http://${request.headers.host ?? "localhost"}`);
+        if (url.pathname !== "/ws") {
+            socket.destroy();
+            return;
+        }
+        // P0-1：浏览器发起的 WS（带 Origin）必须来自白名单，防恶意网页 drive-by 连接；
+        // 非浏览器客户端（RN fetch/ws）通常无 Origin，放行后仍由 token 鉴权把关。
+        if (!this.isOriginAllowed(request.headers.origin)) {
+            socket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
+            socket.destroy();
+            return;
+        }
+        if (!this.authorized(request, url)) {
+            socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+            socket.destroy();
+            return;
+        }
+        this.webSocketServer.handleUpgrade(request, socket, head, (ws) => {
+            this.webSocketServer.emit("connection", ws, request);
+        });
+    }
+    /** WS 握手 Origin 白名单：loopback 变体 + 绑定 host（非 0.0.0.0 时）+ 显式配置 */
+    isOriginAllowed(origin) {
+        if (!origin)
+            return true; // 非浏览器客户端
+        let parsed;
+        try {
+            parsed = new URL(origin);
+        }
+        catch {
+            return false;
+        }
+        const hostname = parsed.hostname.toLowerCase();
+        if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]") {
+            return true;
+        }
+        const bound = this.boundHost.toLowerCase();
+        if (bound !== "0.0.0.0" && bound !== "::" && hostname === bound) {
+            return true;
+        }
+        const allowed = this.options.allowedOrigins ?? [];
+        return allowed.some((o) => {
+            try {
+                return new URL(o).hostname.toLowerCase() === hostname;
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    // ── WS 命令 ───────────────────────────────────────────────────────────────
+    async handleClientMessage(client, data) {
+        let command;
+        try {
+            command = JSON.parse(data.toString());
+        }
+        catch {
+            client.ws.send(JSON.stringify({ type: "error", code: "invalid_json", message: "Invalid JSON" }));
+            return;
+        }
+        // P3-2：分发前真正走 shared 校验（激活 validation 模块，拦截缺 type 的任意载荷）
+        try {
+            command = validateClientCommand(command);
+        }
+        catch {
+            client.ws.send(JSON.stringify({ type: "error", code: "invalid_command", message: "Invalid ClientCommand: missing type" }));
+            return;
+        }
+        try {
+            switch (command.type) {
+                case "list_live_sessions": {
+                    const list = await this.controller.listLiveSessions();
+                    this.sendAck(client, command, list);
+                    break;
+                }
+                case "load_more_history": {
+                    const runner = this.controller.getSession(command.sessionId);
+                    if (!runner) {
+                        this.sendError(client, "session_not_found", command.id ?? "");
+                        break;
+                    }
+                    const result = await runner.loadMoreHistory(command.count);
+                    this.sendAck(client, command, result);
+                    break;
+                }
+                case "search_history": {
+                    const runner = this.controller.getSession(command.sessionId);
+                    if (!runner) {
+                        this.sendError(client, "session_not_found", command.id ?? "");
+                        break;
+                    }
+                    const result = await runner.searchHistory(command.keyword, command.maxResults, command.previewLength);
+                    this.sendAck(client, command, result);
+                    break;
+                }
+                case "list_models": {
+                    const runner = this.controller.getSession(command.sessionId);
+                    if (!runner) {
+                        this.sendError(client, "session_not_found", command.id ?? "");
+                        break;
+                    }
+                    const models = typeof runner.listModels === "function" ? runner.listModels() : [];
+                    this.sendAck(client, command, models);
+                    break;
+                }
+                case "list_skills": {
+                    const runner = this.controller.getSession(command.sessionId);
+                    if (!runner) {
+                        this.sendError(client, "session_not_found", command.id ?? "");
+                        break;
+                    }
+                    // 优先走 SDK resourceLoader（与 TUI 一致），回退到文件扫描
+                    const loaded = typeof runner.listLoadedSkills === "function" ? runner.listLoadedSkills() : [];
+                    const skills = loaded.length > 0 ? loaded : await listSkills(runner.state.cwd);
+                    this.sendAck(client, command, skills);
+                    break;
+                }
+                case "get_maestro_settings": {
+                    const overview = await readSettingsOverview();
+                    this.sendAck(client, command, overview);
+                    break;
+                }
+                case "update_maestro_settings": {
+                    if (command.key !== "settings") {
+                        this.sendError(client, "unsupported_key", undefined, command.id ?? "");
+                        break;
+                    }
+                    const result = await updateSettingsJson(command.patch);
+                    this.sendAck(client, command, result);
+                    break;
+                }
+                case "set_model": {
+                    const runner = this.controller.getSession(command.sessionId);
+                    if (!runner) {
+                        this.sendError(client, "session_not_found", command.id ?? "");
+                        break;
+                    }
+                    if (typeof runner.setModel !== "function") {
+                        this.sendError(client, "unsupported_command", undefined, command.id ?? "");
+                        break;
+                    }
+                    const result = await runner.setModel(command.modelId);
+                    this.sendAck(client, command, result);
+                    break;
+                }
+                case "set_thinking": {
+                    const runner = this.controller.getSession(command.sessionId);
+                    if (!runner) {
+                        this.sendError(client, "session_not_found", command.id ?? "");
+                        break;
+                    }
+                    if (typeof runner.setThinking !== "function") {
+                        this.sendError(client, "unsupported_command", undefined, command.id ?? "");
+                        break;
+                    }
+                    const result = runner.setThinking(command.level);
+                    this.sendAck(client, command, result);
+                    break;
+                }
+                case "compact": {
+                    const runner = this.controller.getSession(command.sessionId);
+                    if (!runner) {
+                        this.sendError(client, "session_not_found", command.id ?? "");
+                        break;
+                    }
+                    if (typeof runner.compact !== "function") {
+                        this.sendError(client, "unsupported_command", undefined, command.id ?? "");
+                        break;
+                    }
+                    const result = await runner.compact(command.customInstructions);
+                    this.sendAck(client, command, result);
+                    break;
+                }
+                case "rename_session": {
+                    const runner = this.controller.getSession(command.sessionId);
+                    if (!runner) {
+                        this.sendError(client, "session_not_found", command.id ?? "");
+                        break;
+                    }
+                    if (typeof runner.renameSession !== "function") {
+                        this.sendError(client, "unsupported_command", undefined, command.id ?? "");
+                        break;
+                    }
+                    const result = runner.renameSession(command.name);
+                    this.sendAck(client, command, result);
+                    break;
+                }
+                case "list_host_sessions": {
+                    const sessions = await this.controller.listSessions(command.cwd);
+                    const list = await toSessionSummaryList(sessions);
+                    this.sendAck(client, command, list);
+                    break;
+                }
+                case "open_session": {
+                    const runner = await this.controller.openSession({
+                        cwd: command.cwd,
+                        mode: command.mode,
+                        sessionFile: command.sessionFile,
+                    });
+                    this.sendAck(client, command, { sessionId: runner.id });
+                    break;
+                }
+                case "close_session": {
+                    await this.controller.closeSession(command.sessionId);
+                    this.sendAck(client, command, { closed: true });
+                    break;
+                }
+                case "prompt": {
+                    const runner = this.controller.getSession(command.sessionId);
+                    if (!runner) {
+                        this.sendError(client, "session_not_found", command.id ?? "");
+                        break;
+                    }
+                    // P1-3：透传图片（此前被静默丢弃），非法元素显式报错而非静默丢失
+                    const images = command.images?.map((img) => toSdkImageContent(img)).filter((x) => x !== undefined);
+                    if (command.images && command.images.length > 0 && images?.length !== command.images.length) {
+                        this.sendError(client, "invalid_image", "images 元素必须是 base64 data 与 mime 字段齐全的图片", command.id ?? "");
+                        break;
+                    }
+                    await runner.prompt(command.message, undefined, images);
+                    this.sendAck(client, command, {});
+                    break;
+                }
+                case "steer": {
+                    const runner = this.controller.getSession(command.sessionId);
+                    if (!runner) {
+                        this.sendError(client, "session_not_found", command.id ?? "");
+                        break;
+                    }
+                    await runner.steer(command.message);
+                    this.sendAck(client, command, {});
+                    break;
+                }
+                case "steer_window": {
+                    // 监督会话跨窗口发送：已打开 → 直接 steer；未打开 → 接管（open_session continue）后 steer。
+                    // 接管语义：Host 打开的会话与原桌面 Pi 进程并行写同一 JSONL，移动端 UI 必须明示「接管并发送」。
+                    const existing = this.controller.getSession(command.endpointId);
+                    if (existing) {
+                        await existing.steer(command.message);
+                        this.sendAck(client, command, { ok: true, sessionId: command.endpointId, tookOver: false });
+                        break;
+                    }
+                    try {
+                        const runner = await this.controller.openSession({ cwd: command.cwd, mode: "continue", sessionFile: undefined });
+                        await runner.steer(command.message);
+                        this.sendAck(client, command, { ok: true, sessionId: runner.id, tookOver: true });
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        this.sendAck(client, command, { ok: false, sessionId: command.endpointId, tookOver: false, error: message });
+                    }
+                    break;
+                }
+                case "follow_up": {
+                    const runner = this.controller.getSession(command.sessionId);
+                    if (!runner) {
+                        this.sendError(client, "session_not_found", command.id ?? "");
+                        break;
+                    }
+                    await runner.followUp(command.message);
+                    this.sendAck(client, command, {});
+                    break;
+                }
+                case "abort": {
+                    const runner = this.controller.getSession(command.sessionId);
+                    if (!runner) {
+                        this.sendError(client, "session_not_found", command.id ?? "");
+                        break;
+                    }
+                    await runner.abort();
+                    this.sendAck(client, command, {});
+                    break;
+                }
+                case "extension_ui_response": {
+                    const ok = this.controller.respondToExtensionUi(command.sessionId, command.requestId, command.response);
+                    if (ok) {
+                        this.sendAck(client, command, {});
+                    }
+                    else {
+                        this.sendError(client, "request_not_found", command.id ?? "");
+                    }
+                    break;
+                }
+                case "get_maestro_state": {
+                    const state = await this.controller.readMaestroStateNow();
+                    this.sendAck(client, command, state);
+                    break;
+                }
+                case "get_monitor_state": {
+                    // 与推送路径共用同一投影，避免双投影漂移
+                    const telemetry = await this.controller.readTelemetry();
+                    this.sendAck(client, command, projectMonitorState(telemetry));
+                    break;
+                }
+                case "get_snapshot": {
+                    const runner = this.controller.getSession(command.sessionId);
+                    if (!runner) {
+                        this.sendError(client, "session_not_found", command.id ?? "");
+                        break;
+                    }
+                    const snapshot = runner.snapshot();
+                    client.ws.send(JSON.stringify({
+                        type: "command_result",
+                        in_reply_to: command.id ?? "",
+                        ok: true,
+                        result: snapshot,
+                    }));
+                    break;
+                }
+                case "get_session_usage": {
+                    const runner = this.controller.getSession(command.sessionId);
+                    if (!runner) {
+                        this.sendError(client, "session_not_found", command.id ?? "");
+                        break;
+                    }
+                    const usage = typeof runner.getUsage === "function" ? await runner.getUsage() : { entries: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, totalTokens: 0, cost: 0 };
+                    const context = typeof runner.getContextUsage === "function" ? runner.getContextUsage() ?? null : null;
+                    this.sendAck(client, command, { sessionId: command.sessionId, ...usage, context });
+                    break;
+                }
+                default:
+                    this.sendError(client, "unsupported_command", command.id ?? "");
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.sendError(client, "command_failed", message);
+        }
+    }
+    sendAck(client, command, result) {
+        client.ws.send(JSON.stringify({
+            type: "command_result",
+            in_reply_to: command.id ?? "",
+            ok: true,
+            result,
+        }));
+    }
+    sendError(client, code, message, replyTo = "") {
+        client.ws.send(JSON.stringify({
+            type: "command_result",
+            in_reply_to: replyTo,
+            ok: false,
+            error: { code, message: message ?? code },
+        }));
+    }
+}
+function writeJson(response, status, body) {
+    response.writeHead(status, {
+        "Content-Type": "application/json; charset=utf-8",
+        "Cache-Control": "no-store",
+    });
+    response.end(JSON.stringify(body));
+}
+function applyCorsHeaders(response, origin) {
+    if (origin) {
+        response.setHeader("Access-Control-Allow-Origin", origin);
+        response.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS");
+        response.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    }
+}
+/**
+ * 将 SessionManager 返回的完整 SessionInfo 裁剪为移动端友好的摘要。
+ * 关键：不携带 allMessagesText 等大字段，避免移动端流量/内存浪费。
+ */
+async function toSessionSummaryList(records) {
+    const sessions = [];
+    for (const raw of records) {
+        const r = raw;
+        const cwd = String(r.cwd ?? "");
+        const title = String(r.firstMessage ?? r.title ?? "");
+        const id = String(r.id ?? "");
+        const path = String(r.path ?? r.sessionFile ?? "");
+        sessions.push({
+            id,
+            cwd,
+            cwdName: cwd.split("/").filter(Boolean).pop() ?? cwd,
+            path,
+            title: title.length > 80 ? `${title.slice(0, 80)}…` : title,
+            name: typeof r.name === "string" && r.name ? r.name : undefined,
+            model: await latestModelFromJsonl(path),
+            messageCount: typeof r.messageCount === "number" ? r.messageCount : 0,
+            // 规范化为 ISO 字符串：Hermes（iOS）解析不了 "Thu Sep 03 2026 ..." 这种本地化格式
+            updatedAt: normalizeIso(String(r.modified ?? r.updatedAt ?? "")),
+            ...(r.created ? { createdAt: normalizeIso(String(r.created)) } : {}),
+        });
+    }
+    return { sessions, observedAt: new Date().toISOString() };
+}
+/** 从 jsonl 里找最近的 model_change，返回 provider/modelId 精简名 */
+async function latestModelFromJsonl(path) {
+    if (!path || !path.endsWith(".jsonl"))
+        return undefined;
+    try {
+        // 只读尾部 256KB（model_change 通常在会话活跃期靠后出现），避免整文件扫描
+        const handle = await open(path, "r");
+        try {
+            const { size } = await handle.stat();
+            const readLen = Math.min(TRAIL_READ_BYTES, size);
+            const buf = Buffer.alloc(readLen);
+            await handle.read(buf, 0, readLen, size - readLen);
+            const tail = buf.toString("utf8");
+            const lines = tail.split("\n");
+            for (let i = lines.length - 1; i >= 0; i--) {
+                const line = lines[i];
+                if (!line.includes("model_change"))
+                    continue;
+                try {
+                    const o = JSON.parse(line);
+                    if (o.modelId) {
+                        const provider = o.provider ? `${o.provider}/` : "";
+                        return `${provider}${o.modelId}`;
+                    }
+                }
+                catch {
+                    // ignore malformed
+                }
+            }
+            return undefined;
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+const TRAIL_READ_BYTES = 256 * 1024;
+/** 尝试解析为 ISO；无法解析时保留原字符串（App 端需兜底） */
+function normalizeIso(raw) {
+    if (!raw)
+        return "";
+    const t = Date.parse(raw);
+    return Number.isFinite(t) ? new Date(t).toISOString() : raw;
+}
+/** 协议 images 元素 → Pi SDK ImageContent（type/data/mimeType）；非法返回 undefined */
+function toSdkImageContent(img) {
+    if (typeof img?.data !== "string" || img.data.length === 0)
+        return undefined;
+    if (typeof img?.mime !== "string" || !img.mime.startsWith("image/"))
+        return undefined;
+    return { type: "image", data: img.data, mimeType: img.mime };
+}
+const IMAGE_EXTENSIONS = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"]);
+const MAX_IMAGE_BYTES = 20 * 1024 * 1024; // 20MB
+const IMAGE_MIME = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".bmp": "image/bmp",
+};
+/** stat 包装（抛错由调用方捕获） */
+function fstat(p) {
+    return stat(p);
+}
+/** 安全读取本地图片：绝对路径 + 图片扩展名 + 大小限制 + realpath 防 symlink 绕过 */
+async function serveImageFile(filePath) {
+    const trimmed = filePath.trim();
+    if (!trimmed || !isAbsolute(trimmed))
+        return undefined;
+    // 防止路径穿越：normalize 后必须仍是绝对路径且不含 ..
+    const normalized = normalize(trimmed);
+    if (!isAbsolute(normalized) || normalized.includes(".."))
+        return undefined;
+    const ext = normalized.slice(normalized.lastIndexOf(".")).toLowerCase();
+    if (!IMAGE_EXTENSIONS.has(ext))
+        return undefined;
+    try {
+        // P3-3：先解析真实路径，防止指向任意位置的 symlink 绕过绝对路径约束
+        const resolved = await realpath(normalized);
+        if (!(await isUnderAllowedRoot(resolved)))
+            return undefined;
+        // 先 stat 校验大小再读取，避免超大文件先耗尽内存
+        const stat = await fstat(resolved);
+        if (stat.size === 0 || stat.size > MAX_IMAGE_BYTES)
+            return undefined;
+        const data = await readFile(resolved);
+        return { data, mime: IMAGE_MIME[ext] ?? "application/octet-stream" };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 允许读取的根目录：用户目录、系统临时目录、进程工作目录（会话产物、图片预览所在）。取 realpath 以兼容 /tmp → /private/tmp */
+async function isUnderAllowedRoot(resolved) {
+    const roots = [homedir(), tmpdir(), process.cwd()];
+    for (const root of roots) {
+        try {
+            const rp = await realpath(root);
+            if (resolved === rp || resolved.startsWith(rp + "/"))
+                return true;
+        }
+        catch {
+            // root 不存在时跳过
+        }
+    }
+    return false;
+}
+/** 扫描可用的 skill 名录（agent 全局 + 项目本地） */
+async function listSkills(cwd) {
+    const { readdir } = await import("node:fs/promises");
+    const { join } = await import("node:path");
+    const { homedir } = await import("node:os");
+    const dirs = [];
+    try {
+        dirs.push(join(homedir(), ".pi", "agent", "skills"));
+    }
+    catch { /* skip */ }
+    try {
+        dirs.push(join(cwd, ".pi", "skills"));
+    }
+    catch { /* skip */ }
+    const names = new Set();
+    for (const dir of dirs) {
+        try {
+            const entries = await readdir(dir, { withFileTypes: true });
+            for (const e of entries) {
+                if (e.isDirectory() && !e.name.startsWith("."))
+                    names.add(e.name);
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+    return [...names].sort();
+}
+//# sourceMappingURL=mobile-host-server.js.map