@youweichen/pi-harness 0.0.0-stage → 1.1.0

package/dist/server/model-config-merge.js

@@ -0,0 +1,32 @@
+export const isChatModelConfig = (model) => model.type === undefined || model.type === "chat";
+/** A chat editor owns chat fields only; keep provider operations and typed models intact. */
+export function mergeChatProvider(previous, config) {
+    const existing = Array.isArray(previous.models) ? previous.models : [];
+    const typed = existing.filter(model => !isChatModelConfig(model));
+    const ids = new Set();
+    const models = config.models.filter(model => model.id.trim()).map(model => {
+        const id = model.id.trim();
+        if (ids.has(id))
+            throw new Error(`Duplicate chat model ID: ${id}`);
+        ids.add(id);
+        const result = { ...existing.find(entry => entry.id === id && isChatModelConfig(entry)), id };
+        for (const key of ["name", "reasoning", "input", "contextWindow", "maxTokens"]) {
+            delete result[key];
+            const value = model[key];
+            if (value !== undefined && value !== "")
+                result[key] = value;
+        }
+        return result;
+    });
+    const result = { ...previous, models: [...models, ...typed] };
+    for (const key of ["name", "api", "baseUrl", "authHeader"]) {
+        delete result[key];
+        const value = config[key];
+        if (value !== undefined && value !== "")
+            result[key] = value;
+    }
+    // An empty key in an existing editor means retain the server-owned credential.
+    if (config.apiKey?.trim())
+        result.apiKey = config.apiKey.trim();
+    return result;
+}

package/dist/server/native-mcp-config.js

@@ -0,0 +1,103 @@
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, mkdirSync, writeFileSync, renameSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentDir, ProjectTrustStore } from "@earendil-works/pi-coding-agent";
+const sdkDirectory = createRequire(import.meta.url).resolve.paths("@earendil-works/pi-coding-agent")?.map(path => join(path, "@earendil-works/pi-coding-agent/dist/core/mcp-servers.js")).find(path => existsSync(path));
+if (!sdkDirectory)
+    throw new Error("Pi MCP configuration validator missing");
+const { validateMcpServerConfig } = await import(pathToFileURL(sdkDirectory).href);
+const MASK = "••••••••";
+function read(path) { try {
+    return readFileSync(path, "utf8");
+}
+catch (error) {
+    if (error.code === "ENOENT")
+        return "{}";
+    throw error;
+} }
+function version(raw) { return createHash("sha256").update(raw).digest("hex"); }
+function transform(value, old, mask, secret = false) {
+    if (Array.isArray(value))
+        return value.map((v, i) => transform(v, Array.isArray(old) ? old[i] : undefined, mask, secret));
+    if (value && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, transform(v, old && typeof old === "object" ? old[k] : undefined, mask, secret || /secret|token|password|apiKey|headers|env/i.test(k))]));
+    if (secret && typeof value === "string") {
+        if (mask)
+            return value ? MASK : "";
+        if (value === MASK) {
+            if (typeof old !== "string")
+                throw new Error("Masked value has no existing secret");
+            return old;
+        }
+    }
+    return value;
+}
+export class NativeMcpConfigService {
+    isTrusted(cwd) { return new ProjectTrustStore(getAgentDir()).get(cwd) === true; }
+    path(cwd, scope) { if (scope !== "global" && scope !== "project")
+        throw new Error("Invalid MCP configuration scope"); return scope === "global" ? join(getAgentDir(), "mcp.json") : join(cwd, ".pi", "mcp.json"); }
+    get(cwd, scope) {
+        const path = this.path(cwd, scope), raw = read(path), document = JSON.parse(raw);
+        if (!document || typeof document !== "object" || Array.isArray(document))
+            throw new Error("MCP configuration must be an object");
+        const inheritedAutoEnableCodemode = scope === "global" || JSON.parse(read(this.path(cwd, "global")))?.autoEnableCodemode !== false;
+        return { path, paths: { global: this.path(cwd, "global"), project: this.path(cwd, "project") }, scope, version: version(raw), document: transform(document, undefined, true), trusted: this.isTrusted(cwd), inheritedAutoEnableCodemode };
+    }
+    save(cwd, scope, expected, incoming) {
+        if (!incoming || typeof incoming !== "object" || Array.isArray(incoming))
+            throw new Error("MCP configuration must be an object");
+        const path = this.path(cwd, scope), raw = read(path);
+        if (version(raw) !== expected)
+            throw new Error("MCP configuration changed externally; refresh before saving");
+        const old = JSON.parse(raw);
+        const document = transform({ ...old, ...incoming }, old, false);
+        document.mcpServers ??= {};
+        if (!document.mcpServers || Array.isArray(document.mcpServers) || typeof document.mcpServers !== "object")
+            throw new Error("mcpServers must be an object");
+        if (document.autoEnableCodemode !== undefined && typeof document.autoEnableCodemode !== "boolean")
+            throw new Error("autoEnableCodemode must be a boolean");
+        for (const [name, config] of Object.entries(document.mcpServers)) {
+            let candidate = config;
+            if (scope === "project" && config && typeof config === "object" && !Array.isArray(config) && !["command", "url", "type"].some(key => Object.hasOwn(config, key))) {
+                if (Object.keys(config).some(key => !["enabled", "exposure", "toolExposure"].includes(key)))
+                    throw new Error("Project overrides only allow enabled, exposure, and toolExposure");
+                const base = JSON.parse(read(this.path(cwd, "global"))).mcpServers?.[name];
+                if (!base)
+                    throw new Error(`No global MCP server to override: ${name}`);
+                candidate = { ...base, ...config };
+            }
+            const result = validateMcpServerConfig(name, candidate);
+            if (typeof result === "string")
+                throw new Error(result);
+            if (scope === "project" && config.auth)
+                throw new Error("Provider authentication is allowed only in global MCP configuration");
+        }
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(`${path}.webui.tmp`, JSON.stringify(document, null, 2) + "\n", { mode: 0o600 });
+        renameSync(`${path}.webui.tmp`, path);
+        return this.get(cwd, scope);
+    }
+    codemode(cwd, scope, effective = {}) {
+        const path = join(scope === "global" ? getAgentDir() : join(cwd, ".pi"), "settings.json"), raw = read(path);
+        const settings = JSON.parse(raw).codemode ?? {};
+        return { path, version: version(raw), mode: settings.mode ?? "on", inlineBudget: settings.inlineBudget ?? 3000, effectiveMode: effective.mode ?? "on", effectiveInlineBudget: effective.inlineBudget ?? 3000 };
+    }
+    saveCodemode(cwd, scope, expected, value) {
+        this.path(cwd, scope);
+        const path = this.codemode(cwd, scope).path, raw = read(path);
+        if (version(raw) !== expected)
+            throw new Error("Pi settings changed externally; refresh before saving");
+        const patch = value;
+        if (!patch || !["on", "only"].includes(String(patch.mode)) || !Number.isInteger(patch.inlineBudget) || Number(patch.inlineBudget) < 0 || Number(patch.inlineBudget) > 100000)
+            throw new Error("Invalid codemode settings");
+        const document = JSON.parse(raw);
+        document.codemode = { ...document.codemode, mode: patch.mode, inlineBudget: patch.inlineBudget };
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(`${path}.webui.tmp`, JSON.stringify(document, null, 2) + "\n", { mode: 0o600 });
+        renameSync(`${path}.webui.tmp`, path);
+    }
+    log() { const path = join(getAgentDir(), "mcp.log"); return existsSync(path) ? read(path).slice(-32000) : ""; }
+    trust(cwd) { new ProjectTrustStore(getAgentDir()).set(cwd, true); }
+}

package/dist/server/native-mcp-presentation.js

@@ -0,0 +1,12 @@
+/** Pi's official non-TUI /mcp output is the status API in 1.0.4. Keep unknown lines visible. */
+export function parseNativeMcpStatus(text) {
+    const servers = [];
+    for (const line of text.split("\n")) {
+        const match = /^([\w-]+): (needs sign-in|disabled|disconnected|connecting|connected|starting|failed|error)(.*)$/.exec(line);
+        if (match)
+            servers.push({ name: match[1], state: match[2] === "needs sign-in" ? "needs-auth" : match[2], toolCount: Number(/, (\d+) tools/.exec(match[3])?.[1] ?? 0), detail: line });
+        else if (/^\s+/.test(line) && servers.length)
+            servers[servers.length - 1].detail += `\n${line.trim()}`;
+    }
+    return servers;
+}

package/dist/server/native-prompt-template.js

@@ -0,0 +1,12 @@
+import { pathToFileURL } from "node:url";
+import { join } from "node:path";
+import { getPackageDir, VERSION } from "@earendil-works/pi-coding-agent";
+/** Internal API of pinned 1.0.4, located by the SDK itself in npm and desktop layouts. */
+export async function expandNativeTemplate(text, templates) {
+    if (VERSION !== "1.0.4")
+        throw new Error("Unsupported native prompt template contract");
+    const module = await import(pathToFileURL(join(getPackageDir(), "dist/core/prompt-templates.js")).href);
+    if (typeof module.expandPromptTemplate !== "function")
+        throw new Error("Native prompt template adapter unavailable");
+    return module.expandPromptTemplate(text, templates);
+}

package/dist/server/native-tools.js

@@ -0,0 +1,32 @@
+import { createPlanExtension } from "./plan/extension.js";
+import { SettingsManager, createCodemodeExtension, createMcpExtension, createToolSearchExtension } from "@earendil-works/pi-coding-agent";
+const runOverrides = new WeakMap();
+export function setConversationRunSettings(settings, values) {
+    const overrides = { ...runOverrides.get(settings), ...(typeof values.autoCompaction === "boolean" ? { compaction: { enabled: values.autoCompaction } } : {}), ...(typeof values.autoRetry === "boolean" ? { retry: { enabled: values.autoRetry } } : {}) };
+    runOverrides.set(settings, overrides);
+}
+/** A native manager with conversation-local overrides; native writes stay native. */
+export function conversationSettings(cwd, agentDir) {
+    const settings = SettingsManager.create(cwd, agentDir);
+    const getCompactionEnabled = settings.getCompactionEnabled.bind(settings);
+    const getRetryEnabled = settings.getRetryEnabled.bind(settings);
+    const getDefaultTools = settings.getDefaultTools.bind(settings);
+    const defaultTools = SettingsManager.inMemory({ defaultTools: ["+codemode", "+tool_search"] }).getDefaultTools();
+    settings.getCompactionEnabled = () => runOverrides.get(settings)?.compaction?.enabled ?? getCompactionEnabled();
+    settings.getRetryEnabled = () => runOverrides.get(settings)?.retry?.enabled ?? getRetryEnabled();
+    settings.getDefaultTools = () => [...(getDefaultTools() ?? defaultTools)];
+    return settings;
+}
+/** Same native extensions as the Pi CLI; activation follows the user's settings. */
+export function nativeToolExtensions() {
+    return [
+        { name: "pi-harness-plan", replaceable: true, factory: createPlanExtension() },
+        { name: "codemode", builtin: true, replaceable: true, factory: createCodemodeExtension() },
+        { name: "tool-search", builtin: true, replaceable: true, factory: createToolSearchExtension() },
+        { name: "mcp", builtin: true, replaceable: true, factory: createMcpExtension() },
+    ];
+}
+/** Stable settings aliases for the SDK's named inline extension paths. */
+export function nativeExtensionPath(path) {
+    return /^builtin:(mcp|tool-search|codemode)$/.test(path) ? `<inline:${path.slice(8)}>` : path;
+}

package/dist/server/node-agent.js

@@ -0,0 +1,262 @@
+/** Native Pi RPC over one SSH exec channel. No local model or terminal injection. */
+import { randomUUID } from "node:crypto";
+import { StringDecoder } from "node:string_decoder";
+import { serializeMessage } from "./serialize.js";
+const MAX_RECORD = 16 * 1024 * 1024;
+const quote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+export function nodeAgentCommand(cwd) {
+    if (!cwd.startsWith("/") || /[\0\r\n]/.test(cwd) || cwd.length > 4096)
+        throw new Error("Invalid remote working directory");
+    return `sh -lc ${quote(`cd ${quote(cwd)} && exec pi --mode rpc`)}`;
+}
+export class NodeAgent {
+    stream;
+    changed;
+    id = randomUUID();
+    buffer = "";
+    decoder = new StringDecoder("utf8");
+    stderr = "";
+    seq = 0;
+    revision = 0;
+    dialogTimers = new Map();
+    timer;
+    pending = new Map();
+    state;
+    constructor(stream, cwd, changed) {
+        this.stream = stream;
+        this.changed = changed;
+        this.state = { id: this.id, cwd, phase: "starting", running: false, messages: [], tools: [], models: [], dialogs: [] };
+        stream.on("data", (data) => this.receive(this.decoder.write(Buffer.isBuffer(data) ? data : Buffer.from(data))));
+        stream.stderr.on("data", data => { this.stderr = (this.stderr + data.toString()).slice(-8000); });
+        stream.on("error", (error) => this.finish(error.message));
+        stream.on("close", () => this.finish(this.stderr || "Remote Pi exited"));
+    }
+    get busy() { return this.state.phase !== "closed" && (this.state.phase === "starting" || this.state.running || this.pending.size > 0 || this.state.dialogs.length > 0); }
+    snapshot() { return this.state; }
+    publish(immediate = false) {
+        if (this.timer) {
+            if (!immediate)
+                return;
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        if (immediate)
+            this.changed(this.state);
+        else
+            this.timer = setTimeout(() => { this.timer = undefined; this.changed(this.state); }, 60);
+    }
+    set(patch, immediate = false) { this.state = { ...this.state, ...patch }; this.publish(immediate); }
+    finish(error) {
+        if (this.state.phase === "closed")
+            return;
+        for (const task of this.pending.values()) {
+            clearTimeout(task.timer);
+            task.reject(new Error(error || "Remote Pi closed"));
+        }
+        this.pending.clear();
+        for (const timer of this.dialogTimers.values())
+            clearTimeout(timer);
+        this.dialogTimers.clear();
+        this.set({ phase: "closed", running: false, dialogs: [], error }, true);
+    }
+    close() {
+        this.finish();
+        try {
+            this.stream.signal("TERM");
+        }
+        catch { /* SSH may already be gone. */ }
+        this.stream.end();
+        this.stream.destroy();
+    }
+    receive(chunk) {
+        if (this.state.phase === "closed")
+            return;
+        this.buffer += chunk;
+        let index;
+        while ((index = this.buffer.indexOf("\n")) >= 0) {
+            const line = this.buffer.slice(0, index);
+            this.buffer = this.buffer.slice(index + 1);
+            if (line.length > MAX_RECORD) {
+                this.finish("Remote Pi response exceeds 16 MiB");
+                this.close();
+                return;
+            }
+            if (!line.trim())
+                continue;
+            try {
+                this.event(JSON.parse(line));
+            }
+            catch (error) {
+                this.finish(`Invalid remote Pi RPC response: ${error.message}`);
+                this.close();
+                return;
+            }
+        }
+        if (this.buffer.length > MAX_RECORD) {
+            this.finish("Remote Pi response exceeds 16 MiB");
+            this.close();
+        }
+    }
+    request(type, fields = {}) {
+        if (this.state.phase === "closed")
+            return Promise.reject(new Error("Remote Pi is not running"));
+        if (this.pending.size >= 32)
+            return Promise.reject(new Error("Too many pending remote commands"));
+        const id = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => { this.pending.delete(id); reject(new Error(`Remote Pi ${type} timed out`)); }, 30000);
+            this.pending.set(id, { resolve, reject, timer });
+            try {
+                this.stream.write(JSON.stringify({ ...fields, id, type }) + "\n");
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(error);
+            }
+        });
+    }
+    async start() {
+        try {
+            await this.refresh();
+            const available = await this.request("get_available_models");
+            this.set({ phase: "ready", models: (available.models ?? []).map((m) => ({ id: String(m.id), provider: String(m.provider), name: String(m.name ?? m.id) })) }, true);
+        }
+        catch (error) {
+            this.finish(`${error.message}${this.stderr ? `\n${this.stderr}` : ""}`);
+            this.close();
+            throw error;
+        }
+    }
+    retainMessages(messages) {
+        let bytes = 0, start = messages.length;
+        while (start > 0 && messages.length - start < 200) {
+            const size = Buffer.byteLength(JSON.stringify(messages[start - 1]));
+            if (start < messages.length && bytes + size > 4 * 1024 * 1024)
+                break;
+            bytes += size;
+            start--;
+        }
+        return messages.slice(start);
+    }
+    async refresh() {
+        const revision = this.revision;
+        const state = await this.request("get_state");
+        if (typeof state.sessionId !== "string" || typeof state.isStreaming !== "boolean")
+            throw new Error("Remote Pi must support the native 1.0.4 RPC protocol");
+        const history = await this.request("get_messages");
+        const messages = (history.messages ?? []).slice(-200).map((m, index) => serializeMessage(m, index)).filter((m) => !!m);
+        if (this.revision !== revision)
+            return;
+        this.seq = messages.length;
+        this.set({ sessionId: state.sessionId, sessionFile: state.sessionFile, model: state.model ? { id: String(state.model.id), provider: String(state.model.provider), name: String(state.model.name ?? state.model.id) } : undefined, thinkingLevel: state.thinkingLevel, running: state.isStreaming || state.isCompacting, messages: this.retainMessages(messages) });
+    }
+    async prompt(text, queue) {
+        if (this.state.phase !== "ready")
+            throw new Error("Remote Pi is not ready");
+        if (!text.trim() || text.length > 200000)
+            throw new Error("Invalid remote prompt");
+        this.set({ error: undefined });
+        await this.request("prompt", { message: text, ...(queue ? { streamingBehavior: queue } : {}) });
+    }
+    async abort() { await this.request("abort"); }
+    async newSession() {
+        if (this.state.running || this.state.dialogs.length)
+            throw new Error("Stop the remote task first");
+        const result = await this.request("new_session");
+        if (result.cancelled)
+            return;
+        this.set({ tools: [], streamingMessage: undefined });
+        await this.refresh();
+    }
+    async model(provider, modelId) {
+        if (this.state.running)
+            throw new Error("Stop the remote task first");
+        if (!this.state.models.some(m => m.id === modelId && m.provider === provider))
+            throw new Error("Unknown remote model");
+        await this.request("set_model", { provider, modelId });
+        await this.refresh();
+    }
+    dialog(id, response) {
+        const dialog = this.state.dialogs.find(d => d.id === id);
+        if (!dialog)
+            throw new Error("Remote dialog expired");
+        if (!response.cancelled && dialog.method === "select" && !dialog.options?.includes(response.value ?? ""))
+            throw new Error("Invalid remote selection");
+        if (response.value && response.value.length > 200000)
+            throw new Error("Remote response too large");
+        clearTimeout(this.dialogTimers.get(id));
+        this.dialogTimers.delete(id);
+        this.stream.write(JSON.stringify({ type: "extension_ui_response", id, ...response }) + "\n");
+        this.set({ dialogs: this.state.dialogs.filter(d => d.id !== id) });
+    }
+    event(event) {
+        if (!event || typeof event.type !== "string")
+            throw new Error("Missing RPC record type");
+        if (event.type === "response") {
+            const task = this.pending.get(event.id);
+            if (!task)
+                return;
+            clearTimeout(task.timer);
+            this.pending.delete(event.id);
+            if (event.success)
+                task.resolve(event.data ?? {});
+            else
+                task.reject(new Error(String(event.error ?? "Remote Pi command failed")));
+            return;
+        }
+        if (["agent_start", "compaction_start", "auto_retry_start"].includes(event.type)) {
+            this.revision++;
+            this.set({ running: true, error: undefined, tools: [] });
+        }
+        if (event.type === "agent_settled") {
+            this.set({ running: false });
+            void this.refresh().catch(error => this.set({ error: error.message }));
+        }
+        if (event.type === "message_start" && event.message?.role === "assistant")
+            this.set({ streamingMessage: serializeMessage(event.message, this.seq) ?? undefined });
+        if (event.type === "message_update") {
+            const delta = event.assistantMessageEvent, current = this.state.streamingMessage;
+            if (!current || !delta || !Number.isInteger(delta.contentIndex) || delta.contentIndex < 0 || delta.contentIndex > 4096)
+                return;
+            const content = [...current.content], index = delta.contentIndex, previous = content[index];
+            if (delta.type === "text_delta")
+                content[index] = { type: "text", text: (String(previous && "text" in previous ? previous.text ?? "" : "") + String(delta.delta ?? "")).slice(-200000) };
+            else if (delta.type === "thinking_delta")
+                content[index] = { type: "thinking", thinking: (String(previous && "thinking" in previous ? previous.thinking ?? "" : "") + String(delta.delta ?? "")).slice(-200000) };
+            else if (delta.type === "toolcall_start")
+                content[index] = { type: "toolCall", id: String(delta.id), name: String(delta.toolName), argumentsText: "" };
+            else if (delta.type === "toolcall_delta" && previous?.type === "toolCall")
+                content[index] = { ...previous, argumentsText: (String(previous.argumentsText ?? "") + String(delta.delta ?? "")).slice(0, 20000) };
+            else
+                return;
+            this.set({ streamingMessage: { ...current, content: content.filter(Boolean) } });
+        }
+        if (event.type === "message_end") {
+            this.revision++;
+            const message = serializeMessage(event.message, this.seq++);
+            if (message)
+                this.set({ messages: this.retainMessages([...this.state.messages, message]), ...(event.message.role === "assistant" ? { streamingMessage: undefined } : {}) });
+        }
+        if (event.type === "tool_execution_start" || event.type === "tool_execution_end") {
+            const tools = this.state.tools.filter(t => t.id !== event.toolCallId);
+            tools.push({ id: String(event.toolCallId), name: String(event.toolName), running: event.type === "tool_execution_start", isError: !!event.isError });
+            this.set({ tools: tools.slice(-256) });
+        }
+        if (event.type === "extension_ui_request") {
+            if (["select", "confirm", "input", "editor"].includes(event.method)) {
+                if (this.state.dialogs.length >= 32) {
+                    this.stream.write(JSON.stringify({ type: "extension_ui_response", id: event.id, cancelled: true }) + "\n");
+                    return;
+                }
+                if (typeof event.timeout === "number" && event.timeout >= 0 && event.timeout <= 2147483647)
+                    this.dialogTimers.set(String(event.id), setTimeout(() => { this.dialogTimers.delete(String(event.id)); this.set({ dialogs: this.state.dialogs.filter(d => d.id !== event.id) }); }, event.timeout));
+                this.set({ dialogs: [...this.state.dialogs, { id: String(event.id), method: event.method, title: String(event.title ?? ""), message: String(event.message ?? ""), options: Array.isArray(event.options) ? event.options.map(String) : undefined, prefill: typeof event.prefill === "string" ? event.prefill : undefined }] }, true);
+            }
+            if (event.method === "notify")
+                this.set({ notice: String(event.message ?? "").slice(0, 8000) });
+            if (event.method === "set_editor_text")
+                this.set({ editorText: { id: String(event.id), text: String(event.text ?? "").slice(0, 200000) } });
+        }
+    }
+}

package/dist/server/node-sources.js

@@ -0,0 +1,142 @@
+/** Read-only source adapters. Never read saved passwords or execute SSH config commands. */
+import { readdir, readFile, stat } from "node:fs/promises";
+import { basename, dirname, join, relative, resolve, isAbsolute } from "node:path";
+import { homedir, userInfo } from "node:os";
+import { decodeText } from "./text-sniff.js";
+export function parseXshell(text, file) {
+    const sections = {};
+    let section = "";
+    for (const line of text.replace(/^\uFEFF/, "").split(/\r?\n/)) {
+        const header = line.trim().match(/^\[([^\]]+)\]$/);
+        if (header) {
+            section = header[1].toUpperCase();
+            sections[section] ??= {};
+            continue;
+        }
+        const pair = line.match(/^\s*([^=;#]+?)\s*=(.*)$/);
+        if (pair)
+            (sections[section] ??= {})[pair[1].toUpperCase()] = pair[2].trim();
+    }
+    const c = sections.CONNECTION ?? {}, a = sections["CONNECTION:AUTHENTICATION"] ?? {};
+    const host = c.HOST ?? "", port = Number(c.PORT || 22);
+    if (!host || /[\r\n\0]/.test(host) || !Number.isInteger(port) || port < 1 || port > 65535)
+        throw new Error(`${file}: 地址或端口无效`);
+    const unsupported = [];
+    if (c.PROTOCOL?.toUpperCase() !== "SSH")
+        unsupported.push("protocol");
+    for (const [name, values] of Object.entries(sections)) {
+        for (const [key, value] of Object.entries(values)) {
+            if ((/PROXY|JUMPHOST/.test(key) || /PROXY|JUMPHOST/.test(name)) && value && !/^(0|-1|none|false)$/i.test(value))
+                unsupported.push("proxy");
+        }
+    }
+    if (Object.entries(a).some(([key, value]) => /AUTH.*PROFILE/.test(key) && value && !/^(0|false|none)$/i.test(value)))
+        unsupported.push("authentication-profile");
+    const keyPath = a.USERKEY || a.PUBLICKEYFILE || a.PRIVATEKEY || undefined;
+    const auth = a.METHOD === "1" || keyPath ? "key" : "password";
+    if (a.METHOD && !["0", "1"].includes(a.METHOD))
+        unsupported.push("authentication");
+    if (!a.USERNAME)
+        unsupported.push("username");
+    if (auth === "key" && !keyPath)
+        unsupported.push("key");
+    return { name: basename(file).replace(/\.xsh$/i, ""), group: dirname(file) === "." ? "Xshell" : dirname(file), host, port, username: a.USERNAME || "", auth, keyPath, defaultDir: "/", sourceKey: file, unsupported: [...new Set(unsupported)] };
+}
+/** First obtained value wins, matching OpenSSH's Host ordering. Complex directives are blocked. */
+export function parseSshConfig(text) {
+    const blocks = [{ patterns: ["*"], values: {} }];
+    let current = blocks[0];
+    const unsupported = new Set();
+    for (const line of text.split(/\r?\n/)) {
+        const m = line.trim().match(/^([^\s=#]+)(?:\s*=\s*|\s+)(.*)$/);
+        if (!m || m[1].startsWith("#"))
+            continue;
+        const key = m[1].toLowerCase();
+        const value = m[2].replace(/\s+#.*$/, "").trim().replace(/^"(.*)"$/, "$1");
+        if (key === "host") {
+            current = { patterns: value.split(/\s+/), values: {} };
+            blocks.push(current);
+        }
+        else if (key === "match" || key === "include")
+            unsupported.add(key);
+        else
+            current.values[key] ??= value;
+    }
+    const match = (pattern, alias) => new RegExp(`^${pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replaceAll("*", ".*").replaceAll("?", ".")}$`, "i").test(alias);
+    const aliases = [...new Set(blocks.flatMap((b) => b.patterns).filter((p) => !/[*!?]/.test(p)))];
+    return aliases.map((alias) => {
+        const v = {};
+        for (const b of blocks)
+            if (b.patterns.some((p) => !p.startsWith("!") && match(p, alias)) && !b.patterns.some((p) => p.startsWith("!") && match(p.slice(1), alias)))
+                for (const [k, val] of Object.entries(b.values))
+                    v[k] ??= val;
+        const blocked = [...unsupported];
+        for (const key of ["proxyjump", "proxycommand", "localcommand", "remotecommand", "identityagent", "certificatefile", "localforward", "remoteforward", "dynamicforward"])
+            if (v[key] && v[key] !== "none")
+                blocked.push(key);
+        const port = Number(v.port || 22), host = v.hostname || alias;
+        if (!Number.isInteger(port) || port < 1 || port > 65535)
+            throw new Error(`${alias}: 端口无效`);
+        if (host.includes("%") || v.identityfile?.includes("%"))
+            blocked.push("tokens");
+        return { name: alias, group: "SSH config", host, port, username: v.user || userInfo().username, auth: v.identityfile ? "key" : "agent", keyPath: v.identityfile, defaultDir: "/", sourceKey: alias, unsupported: blocked };
+    });
+}
+async function readBounded(path) {
+    if ((await stat(path)).size > 1024 * 1024)
+        throw new Error("配置文件超过 1 MiB");
+    const bytes = await readFile(path);
+    if (bytes[0] === 0xff && bytes[1] === 0xfe)
+        return bytes.subarray(2).toString("utf16le");
+    return decodeText(bytes);
+}
+export async function scanSource(source) {
+    if (source.kind === "ssh") {
+        const nodes = parseSshConfig(await readBounded(source.path));
+        if (nodes.length > 200)
+            throw new Error("每个来源最多 200 个节点");
+        return nodes;
+    }
+    const nodes = [];
+    let visited = 0;
+    async function walk(dir, depth) {
+        if (depth > 12)
+            throw new Error("会话目录层级过深");
+        for (const entry of await readdir(dir, { withFileTypes: true })) {
+            if (++visited > 4000)
+                throw new Error("会话目录文件过多");
+            const path = join(dir, entry.name);
+            if (entry.isDirectory())
+                await walk(path, depth + 1);
+            else if (entry.isFile() && /\.xsh$/i.test(entry.name)) {
+                const node = parseXshell(await readBounded(path), relative(source.path, path));
+                if (node.keyPath) {
+                    node.keyPath = node.keyPath.replace(/%([^%]+)%/g, (original, name) => process.env[name] ?? original);
+                    if (!isAbsolute(node.keyPath) && !node.keyPath.startsWith("~/"))
+                        node.unsupported = [...node.unsupported ?? [], "key"];
+                }
+                nodes.push(node);
+                if (nodes.length > 200)
+                    throw new Error("每个来源最多 200 个节点");
+            }
+        }
+    }
+    await walk(source.path, 0);
+    return nodes;
+}
+export async function detectSources() {
+    const home = homedir();
+    const candidates = [{ kind: "ssh", path: join(home, ".ssh", "config") }];
+    if (process.platform === "win32")
+        for (const base of [join(home, "Documents"), ...(process.env.OneDrive ? [join(process.env.OneDrive, "Documents")] : [])])
+            candidates.unshift({ kind: "xshell", path: join(base, "NetSarang Computer", "8", "Xshell", "Sessions") });
+    const found = await Promise.all(candidates.map(async (source) => { try {
+        const nodes = await scanSource(source);
+        return { ...source, count: nodes.length, groups: new Set(nodes.map((n) => n.group)).size };
+    }
+    catch {
+        return null;
+    } }));
+    return found.filter((s) => s !== null);
+}
+export function sourcePath(value) { return resolve(value.startsWith("~/") ? join(homedir(), value.slice(2)) : value); }