@youweichen/pi-harness 0.0.0-stage → 1.0.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-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); }