larkin 0.4.28 → 0.4.29

package/dist/runtime/pi-official-auth.cjs

@@ -0,0 +1,594 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.officialPiHasStoredProvider = officialPiHasStoredProvider;
+exports.beginBuiltinPiCredentialTransaction = beginBuiltinPiCredentialTransaction;
+exports.createOfficialPiRegistryRuntime = createOfficialPiRegistryRuntime;
+exports.createOfficialPiCredentialRuntime = createOfficialPiCredentialRuntime;
+exports.createOfficialPiLogoutRuntime = createOfficialPiLogoutRuntime;
+exports.createOfficialPiModelRuntime = createOfficialPiModelRuntime;
+exports.listOfficialPiAuthProviders = listOfficialPiAuthProviders;
+exports.createOfficialPiAuthInteraction = createOfficialPiAuthInteraction;
+exports.runOfficialPiLogin = runOfficialPiLogin;
+exports.verifyOfficialPiProviderTurn = verifyOfficialPiProviderTurn;
+exports.officialPiAuthStatus = officialPiAuthStatus;
+exports.logoutOfficialPiProvider = logoutOfficialPiProvider;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_url_1 = require("node:url");
+const secure_metadata_js_1 = require("../platform/secure-metadata.cjs");
+// proper-lockfile does not publish TypeScript declarations.
+// @ts-expect-error bundled CommonJS dependency
+const proper_lockfile_1 = __importDefault(require("proper-lockfile"));
+const pi_coding_agent_1 = require("@earendil-works/pi-coding-agent");
+const pi_ai_1 = require("@earendil-works/pi-ai");
+const pi_provider_config_js_1 = require("./pi-provider-config.cjs");
+const SNAPSHOT_FILES = ["auth.json", "models.json", "models-store.json"];
+const LOCK_WAIT_MS = 15_000;
+const LOCK_RETRY_MS = 25;
+const heldCredentialLocks = new Map();
+const credentialQueues = new Map();
+function credentialLockPath(configDir, agentId) {
+    if (!/^cli_[A-Za-z0-9]+$/.test(agentId))
+        throw new Error("invalid Agent ID for Pi credential lock");
+    return node_path_1.default.join((0, pi_provider_config_js_1.piAgentDirectory)(configDir, agentId), "auth.json");
+}
+function ensureLockDirectory(lockPath) {
+    const directory = node_path_1.default.dirname(lockPath);
+    node_fs_1.default.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    node_fs_1.default.chmodSync(directory, 0o700);
+    if (secure_metadata_js_1.isWindows) {
+        // Windows 无 POSIX 权限位（mode 恒 0o666）：改用 icacls 收紧 ACL 并回读校验。
+        (0, secure_metadata_js_1.secureWindowsDirectoryAcl)(directory, { label: "Pi credential lock 目录" });
+        return;
+    }
+    const stat = node_fs_1.default.lstatSync(directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink()
+        || (typeof process.getuid === "function" && stat.uid !== process.getuid())
+        || (stat.mode & 0o777) !== 0o700)
+        throw new Error("Pi credential lock directory must be an owned 0700 directory");
+}
+function acquireCredentialLockSync(lockPath) {
+    const existing = heldCredentialLocks.get(lockPath);
+    if (existing) {
+        existing.depth += 1;
+        return existing.owner;
+    }
+    ensureLockDirectory(lockPath);
+    const owner = { pid: process.pid, token: node_crypto_1.default.randomUUID(), createdAt: Date.now() };
+    const deadline = Date.now() + LOCK_WAIT_MS;
+    while (true) {
+        try {
+            const release = proper_lockfile_1.default.lockSync(lockPath, { realpath: false, stale: 30_000, update: 10_000 });
+            heldCredentialLocks.set(lockPath, { owner, depth: 1, release });
+            return owner;
+        }
+        catch (error) {
+            if (error.code !== "ELOCKED")
+                throw error;
+            if (Date.now() >= deadline)
+                throw new Error("Pi credential store is locked by another live process");
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, LOCK_RETRY_MS);
+        }
+    }
+}
+function releaseCredentialLock(lockPath, owner) {
+    const held = heldCredentialLocks.get(lockPath);
+    if (!held || held.owner.token !== owner.token)
+        throw new Error("Pi credential lock ownership mismatch");
+    held.depth -= 1;
+    if (held.depth > 0)
+        return;
+    try {
+        held.release();
+    }
+    finally {
+        heldCredentialLocks.delete(lockPath);
+    }
+}
+function withCredentialLock(lockPath, operation) {
+    const previous = credentialQueues.get(lockPath) ?? Promise.resolve();
+    const result = previous.catch(() => undefined).then(async () => {
+        const owner = acquireCredentialLockSync(lockPath);
+        try {
+            return await operation();
+        }
+        finally {
+            releaseCredentialLock(lockPath, owner);
+        }
+    });
+    credentialQueues.set(lockPath, result.catch(() => undefined));
+    return result;
+}
+function ensurePrivateDirectory(directory) {
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(directory), { recursive: true, mode: 0o700 });
+    node_fs_1.default.chmodSync(node_path_1.default.dirname(directory), 0o700);
+    node_fs_1.default.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    node_fs_1.default.chmodSync(directory, 0o700);
+    if (secure_metadata_js_1.isWindows) {
+        // Windows 无 POSIX 权限位：icacls 收紧为「当前用户 + SYSTEM」并回读校验。
+        (0, secure_metadata_js_1.secureWindowsDirectoryAcl)(directory, { label: "Pi official credential 目录" });
+        return;
+    }
+    const stat = node_fs_1.default.lstatSync(directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink()
+        || (typeof process.getuid === "function" && stat.uid !== process.getuid())
+        || (stat.mode & 0o777) !== 0o700) {
+        throw new Error("Pi official credential directory must be an owned 0700 directory");
+    }
+}
+function safeRead(file) {
+    try {
+        const stat = node_fs_1.default.lstatSync(file);
+        if (!stat.isFile() || stat.isSymbolicLink()
+            || (typeof process.getuid === "function" && stat.uid !== process.getuid())
+            || (!secure_metadata_js_1.isWindows && (stat.mode & 0o777) !== 0o600))
+            throw new Error(`unsafe Pi auth file: ${node_path_1.default.basename(file)}`);
+        return node_fs_1.default.readFileSync(file);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function restoreFile(file, bytes) {
+    if (bytes === null) {
+        try {
+            node_fs_1.default.unlinkSync(file);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        return;
+    }
+    const temporary = `${file}.${process.pid}.${node_crypto_1.default.randomUUID()}.tmp`;
+    try {
+        node_fs_1.default.writeFileSync(temporary, bytes, { mode: 0o600, flag: "wx" });
+        node_fs_1.default.renameSync(temporary, file);
+        node_fs_1.default.chmodSync(file, 0o600);
+    }
+    finally {
+        try {
+            node_fs_1.default.unlinkSync(temporary);
+        }
+        catch { /* renamed or absent */ }
+    }
+}
+function readCredentialData(authPath) {
+    const bytes = safeRead(authPath);
+    if (bytes === null)
+        return {};
+    const parsed = JSON.parse(bytes.toString("utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new Error("Pi auth.json must contain an object");
+    return parsed;
+}
+/** 只读校验 Agent 凭证路径：每级必须是当前用户拥有的非 symlink 目录，不创建、不改权限。 */
+function officialPiOwnedAuthPath(configDir, agentId) {
+    if (!/^cli_[A-Za-z0-9]+$/.test(agentId))
+        return null;
+    const root = node_path_1.default.resolve(configDir);
+    const expected = node_path_1.default.join(root, "providers", "pi", agentId, "auth.json");
+    const segments = ["providers", "pi", agentId];
+    let current = root;
+    try {
+        const rootStat = node_fs_1.default.lstatSync(current);
+        if (!rootStat.isDirectory() || rootStat.isSymbolicLink())
+            return null;
+        if (typeof process.getuid === "function" && rootStat.uid !== process.getuid())
+            return null;
+    }
+    catch {
+        return null;
+    }
+    for (let index = 0; index < segments.length; index += 1) {
+        current = node_path_1.default.join(current, segments[index]);
+        let stat;
+        try {
+            stat = node_fs_1.default.lstatSync(current);
+        }
+        catch {
+            return null;
+        }
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            return null;
+        if (typeof process.getuid === "function" && stat.uid !== process.getuid())
+            return null;
+        if (index === segments.length - 1 && !secure_metadata_js_1.isWindows && (stat.mode & 0o777) !== 0o700)
+            return null;
+    }
+    const authPath = node_path_1.default.join(current, "auth.json");
+    return authPath === expected ? authPath : null;
+}
+/** Presence-only check against the Agent-owned official store. Never returns credential bytes. */
+function officialPiHasStoredProvider(configDir, agentId, providerId) {
+    const provider = typeof providerId === "string" ? providerId.trim() : "";
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/.test(provider))
+        return false;
+    try {
+        const authPath = officialPiOwnedAuthPath(configDir, agentId);
+        if (!authPath)
+            return false;
+        const credential = readCredentialData(authPath)[provider];
+        return credential?.type === "api_key" || credential?.type === "oauth";
+    }
+    catch {
+        return false;
+    }
+}
+function writeCredentialData(authPath, data) {
+    ensurePrivateDirectory(node_path_1.default.dirname(authPath));
+    const temporary = `${authPath}.${process.pid}.${node_crypto_1.default.randomUUID()}.tmp`;
+    try {
+        node_fs_1.default.writeFileSync(temporary, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+        node_fs_1.default.renameSync(temporary, authPath);
+        node_fs_1.default.chmodSync(authPath, 0o600);
+    }
+    finally {
+        try {
+            node_fs_1.default.unlinkSync(temporary);
+        }
+        catch { /* renamed or absent */ }
+    }
+}
+/** Official CredentialStore contract backed by raw auth.json bytes.
+ * Reads never resolve `!command` API-key values and absent stores stay absent.
+ */
+class RawFileCredentialStore {
+    authPath;
+    lockPath;
+    constructor(authPath, lockPath) {
+        this.authPath = authPath;
+        this.lockPath = lockPath;
+    }
+    read(providerId) {
+        if (!node_fs_1.default.existsSync(this.authPath))
+            return Promise.resolve(undefined);
+        return withCredentialLock(this.lockPath, async () => {
+            safeRead(this.authPath); // enforce owner/type/mode before the official raw reader
+            return (0, pi_coding_agent_1.readStoredCredential)(providerId, this.authPath);
+        });
+    }
+    list() {
+        if (!node_fs_1.default.existsSync(this.authPath))
+            return Promise.resolve([]);
+        return withCredentialLock(this.lockPath, async () => Object.entries(readCredentialData(this.authPath)).flatMap(([providerId, credential]) => credential?.type === "api_key" || credential?.type === "oauth" ? [{ providerId, type: credential.type }] : []));
+    }
+    modify(providerId, fn) {
+        ensurePrivateDirectory(node_path_1.default.dirname(this.authPath));
+        return withCredentialLock(this.lockPath, async () => {
+            const data = readCredentialData(this.authPath);
+            const current = data[providerId];
+            const next = await fn(current);
+            if (next === undefined)
+                return current;
+            data[providerId] = next;
+            writeCredentialData(this.authPath, data);
+            return next;
+        });
+    }
+    delete(providerId) {
+        if (!node_fs_1.default.existsSync(this.authPath))
+            return Promise.resolve();
+        return withCredentialLock(this.lockPath, async () => {
+            const data = readCredentialData(this.authPath);
+            if (!(providerId in data))
+                return;
+            delete data[providerId];
+            writeCredentialData(this.authPath, data);
+        });
+    }
+}
+/** Logout only sees an empty credential view; the official logout mutation is
+ * delegated to the raw store for its one requested provider. This prevents
+ * ModelRuntime's create/post-logout refresh from resolving unrelated entries.
+ */
+class DeleteOnlyCredentialStore {
+    target;
+    constructor(target) {
+        this.target = target;
+    }
+    async read() { return undefined; }
+    async list() { return []; }
+    async modify() { return undefined; }
+    delete(providerId) { return this.target.delete(providerId); }
+}
+function beginBuiltinPiCredentialTransaction(configDir, agentId) {
+    const directory = (0, pi_provider_config_js_1.piAgentDirectory)(configDir, agentId);
+    const lockPath = credentialLockPath(configDir, agentId);
+    const existed = node_fs_1.default.existsSync(directory);
+    ensurePrivateDirectory(directory);
+    const lockOwner = acquireCredentialLockSync(lockPath);
+    let snapshots;
+    try {
+        snapshots = new Map(SNAPSHOT_FILES.map((name) => [name, safeRead(node_path_1.default.join(directory, name))]));
+    }
+    catch (error) {
+        releaseCredentialLock(lockPath, lockOwner);
+        throw error;
+    }
+    let active = true;
+    return {
+        directory,
+        commit() {
+            if (!active)
+                return;
+            active = false;
+            releaseCredentialLock(lockPath, lockOwner);
+            if (!existed) {
+                try {
+                    node_fs_1.default.rmdirSync(directory);
+                }
+                catch { /* keep non-empty provider state */ }
+            }
+        },
+        rollback() {
+            if (!active)
+                return;
+            try {
+                for (const name of [...SNAPSHOT_FILES].reverse())
+                    restoreFile(node_path_1.default.join(directory, name), snapshots.get(name) ?? null);
+            }
+            finally {
+                active = false;
+                releaseCredentialLock(lockPath, lockOwner);
+            }
+            if (!existed) {
+                try {
+                    node_fs_1.default.rmdirSync(directory);
+                }
+                catch { /* keep a non-empty safe directory */ }
+            }
+        },
+    };
+}
+async function createOfficialRuntime(options) {
+    const previousOffline = process.env.PI_OFFLINE;
+    process.env.PI_OFFLINE = "1";
+    try {
+        const runtime = await pi_coding_agent_1.ModelRuntime.create({ ...options, allowModelNetwork: false });
+        if (process.env.LARKIN_TEST_BOT_REGISTER_MODULE && process.env.LARKIN_TEST_PI_AUTH_PROVIDER_MODULE) {
+            const fixture = await Promise.resolve(`${(0, node_url_1.pathToFileURL)(node_path_1.default.resolve(process.env.LARKIN_TEST_PI_AUTH_PROVIDER_MODULE)).href}`).then(s => __importStar(require(s)));
+            await fixture.configure?.(runtime);
+        }
+        return runtime;
+    }
+    finally {
+        if (previousOffline === undefined)
+            delete process.env.PI_OFFLINE;
+        else
+            process.env.PI_OFFLINE = previousOffline;
+    }
+}
+/** Provider catalog only: no Agent credential/model path is opened or created. */
+function createOfficialPiRegistryRuntime() {
+    return createOfficialRuntime({ credentials: new pi_ai_1.InMemoryCredentialStore(), modelsPath: null });
+}
+/** Status/logout runtime: raw credentials are injected without resolving API-key commands. */
+function createOfficialPiCredentialRuntime(configDir, agentId) {
+    const directory = (0, pi_provider_config_js_1.piAgentDirectory)(configDir, agentId);
+    return createOfficialRuntime({
+        credentials: new RawFileCredentialStore(node_path_1.default.join(directory, "auth.json"), credentialLockPath(configDir, agentId)),
+        modelsPath: null,
+    });
+}
+/** Logout runtime deletes through the official ModelRuntime API while keeping
+ * unrelated stored credentials invisible to its automatic refreshes. */
+function createOfficialPiLogoutRuntime(configDir, agentId) {
+    const directory = (0, pi_provider_config_js_1.piAgentDirectory)(configDir, agentId);
+    const store = new RawFileCredentialStore(node_path_1.default.join(directory, "auth.json"), credentialLockPath(configDir, agentId));
+    return createOfficialRuntime({ credentials: new DeleteOnlyCredentialStore(store), modelsPath: null });
+}
+/** Login/request runtime: official auth orchestration with a command-free persistent CredentialStore. */
+function createOfficialPiModelRuntime(configDir, agentId) {
+    const directory = (0, pi_provider_config_js_1.piAgentDirectory)(configDir, agentId);
+    return createOfficialRuntime({
+        credentials: new RawFileCredentialStore(node_path_1.default.join(directory, "auth.json"), credentialLockPath(configDir, agentId)),
+        modelsPath: node_fs_1.default.existsSync(node_path_1.default.join(directory, "models.json")) ? node_path_1.default.join(directory, "models.json") : null,
+        modelsStorePath: node_path_1.default.join(directory, "models-store.json"),
+    });
+}
+function listOfficialPiAuthProviders(runtime) {
+    return runtime.getProviders().map((provider) => {
+        const methods = [];
+        if (provider.auth.apiKey?.login)
+            methods.push({ type: "api_key", name: provider.auth.apiKey.name });
+        if (provider.auth.oauth?.login)
+            methods.push({ type: "oauth", name: provider.auth.oauth.loginLabel || provider.auth.oauth.name });
+        return {
+            id: provider.id,
+            name: provider.name,
+            methods,
+            models: provider.getModels().map((model) => `${model.provider}/${model.id}`),
+            ambientOnly: methods.length === 0 && Boolean(provider.auth.apiKey),
+        };
+    });
+}
+function abortError() {
+    const error = new Error("Pi auth login cancelled");
+    error.name = "AbortError";
+    return error;
+}
+async function abortable(promise, signals) {
+    const active = signals.filter((signal) => Boolean(signal));
+    if (active.some((signal) => signal.aborted))
+        throw abortError();
+    let cleanup = () => { };
+    const aborted = new Promise((_resolve, reject) => {
+        const listener = () => reject(abortError());
+        for (const signal of active)
+            signal.addEventListener("abort", listener, { once: true });
+        cleanup = () => { for (const signal of active)
+            signal.removeEventListener("abort", listener); };
+    });
+    try {
+        return await Promise.race([promise, aborted]);
+    }
+    finally {
+        cleanup();
+    }
+}
+function safeUrl(raw) {
+    try {
+        const url = new URL(raw);
+        url.username = "";
+        url.password = "";
+        url.search = "";
+        url.hash = "";
+        return url.toString();
+    }
+    catch {
+        return "(invalid URL)";
+    }
+}
+function copyableAuthUrl(raw) {
+    try {
+        const url = new URL(raw);
+        if (url.protocol !== "https:" && url.protocol !== "http:")
+            return null;
+        if (url.username || url.password || /[\0\r\n]/.test(raw))
+            return null;
+        return url.toString();
+    }
+    catch {
+        return null;
+    }
+}
+function promptLabel(prompt) {
+    return `${prompt.message}${"placeholder" in prompt && prompt.placeholder ? `（${prompt.placeholder}）` : ""}`;
+}
+function createOfficialPiAuthInteraction(input) {
+    const prompt = async (request) => {
+        if (request.type === "select") {
+            const lines = request.options.map((option, index) => `  ${index + 1}. ${option.label}${option.description ? ` — ${option.description}` : ""}`).join("\n");
+            const answer = await abortable(input.questioner.ask(`${request.message}\n${lines}\n> `, request.signal), [input.signal, request.signal]);
+            const index = Number(answer.trim()) - 1;
+            if (!Number.isInteger(index) || index < 0 || index >= request.options.length)
+                throw new Error(`请选择 1-${request.options.length}`);
+            return request.options[index].id;
+        }
+        const question = `${promptLabel(request)}\n> `;
+        const operation = request.type === "secret" || request.type === "manual_code"
+            ? input.questioner.secret(question, request.signal)
+            : input.questioner.ask(question, request.signal);
+        return abortable(operation, [input.signal, request.signal]);
+    };
+    const notify = (event) => {
+        if (event.type === "info") {
+            input.report(event.message);
+            for (const link of event.links ?? [])
+                input.report(`${link.label || "More information"}: ${safeUrl(link.url)}`);
+            return;
+        }
+        if (event.type === "auth_url") {
+            const fullUrl = copyableAuthUrl(event.url);
+            const opened = Boolean(fullUrl) && input.openUrl?.(fullUrl) === true;
+            input.report(`${opened ? "登录地址已在浏览器打开" : "请复制完整登录地址"}: ${opened ? safeUrl(fullUrl) : fullUrl || "(invalid URL)"}`);
+            if (event.instructions)
+                input.report(event.instructions);
+            return;
+        }
+        if (event.type === "device_code") {
+            input.report(`设备登录码：${event.userCode}`);
+            input.report(`验证地址：${safeUrl(event.verificationUri)}`);
+            if (event.expiresInSeconds)
+                input.report(`有效期：${event.expiresInSeconds} 秒`);
+            return;
+        }
+        input.report(event.message);
+    };
+    return { signal: input.signal, prompt, notify };
+}
+function runOfficialPiLogin(runtime, providerId, authType, interaction) {
+    return runtime.login(providerId, authType, interaction);
+}
+async function verifyOfficialPiProviderTurn(runtime, modelId, signal) {
+    const separator = modelId.indexOf("/");
+    const providerId = separator > 0 ? modelId.slice(0, separator) : "";
+    const providerModelId = separator > 0 ? modelId.slice(separator + 1) : "";
+    const model = runtime.getModel(providerId, providerModelId);
+    if (!model)
+        throw new Error("selected Pi provider model is not registered");
+    const timeout = new AbortController();
+    const timer = setTimeout(() => timeout.abort(), 60_000);
+    const combined = signal ? AbortSignal.any([signal, timeout.signal]) : timeout.signal;
+    try {
+        const response = await runtime.completeSimple(model, {
+            systemPrompt: "This is a setup readiness check. Do not use tools.",
+            messages: [{ role: "user", content: "Reply exactly: LARKIN_READY", timestamp: Date.now() }],
+        }, { maxTokens: 32, signal: combined });
+        const text = response.content.flatMap((entry) => entry.type === "text" ? [entry.text] : []).join("").trim();
+        if (response.stopReason === "error" || response.stopReason === "aborted" || !text) {
+            throw new Error(response.errorMessage || "provider readiness turn returned no authenticated text");
+        }
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function safeSource(value) {
+    if (!value || value.length > 120 || /[\0\r\n]/.test(value) || /[?&#=]/.test(value))
+        return "configured";
+    return value;
+}
+async function officialPiAuthStatus(runtime) {
+    const providers = new Map(runtime.getProviders().map((provider) => [provider.id, provider.name]));
+    const stored = new Map((await runtime.listCredentials()).map((entry) => [entry.providerId, entry.type]));
+    const providerIds = [...new Set([...providers.keys(), ...stored.keys()])];
+    const statuses = [];
+    for (const providerId of providerIds) {
+        const check = await runtime.checkAuth(providerId);
+        const credentialType = stored.get(providerId) || check?.type;
+        if (!credentialType)
+            continue;
+        statuses.push({
+            providerId,
+            providerName: providers.get(providerId) || providerId,
+            credentialType,
+            source: safeSource(check?.source),
+            stored: stored.has(providerId),
+        });
+    }
+    return statuses;
+}
+function logoutOfficialPiProvider(runtime, providerId) {
+    return runtime.logout(providerId);
+}

package/dist/runtime/pi-official-auth.mjs

@@ -151,6 +151,59 @@ function readCredentialData(authPath) {
         throw new Error("Pi auth.json must contain an object");
     return parsed;
 }
+/** 只读校验 Agent 凭证路径：每级必须是当前用户拥有的非 symlink 目录，不创建、不改权限。 */
+function officialPiOwnedAuthPath(configDir, agentId) {
+    if (!/^cli_[A-Za-z0-9]+$/.test(agentId))
+        return null;
+    const root = path.resolve(configDir);
+    const expected = path.join(root, "providers", "pi", agentId, "auth.json");
+    const segments = ["providers", "pi", agentId];
+    let current = root;
+    try {
+        const rootStat = fs.lstatSync(current);
+        if (!rootStat.isDirectory() || rootStat.isSymbolicLink())
+            return null;
+        if (typeof process.getuid === "function" && rootStat.uid !== process.getuid())
+            return null;
+    }
+    catch {
+        return null;
+    }
+    for (let index = 0; index < segments.length; index += 1) {
+        current = path.join(current, segments[index]);
+        let stat;
+        try {
+            stat = fs.lstatSync(current);
+        }
+        catch {
+            return null;
+        }
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            return null;
+        if (typeof process.getuid === "function" && stat.uid !== process.getuid())
+            return null;
+        if (index === segments.length - 1 && !isWindows && (stat.mode & 0o777) !== 0o700)
+            return null;
+    }
+    const authPath = path.join(current, "auth.json");
+    return authPath === expected ? authPath : null;
+}
+/** Presence-only check against the Agent-owned official store. Never returns credential bytes. */
+export function officialPiHasStoredProvider(configDir, agentId, providerId) {
+    const provider = typeof providerId === "string" ? providerId.trim() : "";
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/.test(provider))
+        return false;
+    try {
+        const authPath = officialPiOwnedAuthPath(configDir, agentId);
+        if (!authPath)
+            return false;
+        const credential = readCredentialData(authPath)[provider];
+        return credential?.type === "api_key" || credential?.type === "oauth";
+    }
+    catch {
+        return false;
+    }
+}
 function writeCredentialData(authPath, data) {
     ensurePrivateDirectory(path.dirname(authPath));
     const temporary = `${authPath}.${process.pid}.${crypto.randomUUID()}.tmp`;