pi-web-ui 0.95.0 → 0.96.1

package/dist/server/plugin-catalog-sync.js

@@ -16,14 +16,22 @@
  *      不因为一条坏条目就停掉整批；
  *   3. 回执是结构化的（ok/error/entries/installed），不靠 DOM 事件或控制台文字。
  */
-import { readFileSync, existsSync } from "node:fs";
-import { isAbsolute, join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import { pick } from "./i18n.js";
 import { normalizeSyncPayload, writeCustomCatalog } from "./plugin-catalog.js";
+import { workspacePath } from "./files-service.js";
 /**
- * 读同步文档：`http(s)://` 走网络，其余当本地文件路径（须为绝对路径）。
- * 只读文本，JSON 解析交给调用方（解析失败也走同一条「不写盘」的路径）。
+ * 读同步文档：`http(s)://` 走网络，其余当本地文件路径 —— **只允许工作区内的路径**
+ * （复用 files-service 的 workspacePath 校验；任意绝对路径可读会成为「文件存在 /
+ * 可读性」探测 oracle）。只读文本；本地来源的读失败与过大统一进 `localDocFailed`
+ * 这一条错误（调用方把解析失败也并进来），不区分「读不到 / 解析失败」两种失败。
  */
+function localDocFailed(l) {
+    return {
+        error: pick(l, "目录文档无效或不可读（仅支持 http(s) URL 或工作区内的 JSON 文件）", "Invalid or unreadable catalog document (http(s) URL or an in-workspace JSON file only)", "plugincatalog.sync.doc.invalid"),
+    };
+}
 async function readDocument(source, deps, lang) {
     const l = lang();
     const maxBytes = Math.max(1024, Number(deps.maxBytes ?? 1024 * 1024));
@@ -51,24 +59,21 @@ async function readDocument(source, deps, lang) {
             };
         return { text };
     }
-    const p = source.trim();
-    if (!isAbsolute(p))
-        return {
-            error: pick(l, "来源需为 http(s) URL 或本地文件的绝对路径", "Source must be an http(s) URL or an absolute local file path", "plugincatalog.sync.source.invalid"),
-        };
+    // 本地来源：必须在工作区内（workspacePath 对相对/绝对路径统一做越界判定）。
+    // 越界 / 读不到 / 过大统一返回同一条错误，不给调用方区分的余地。
+    const wp = deps.workspaceRoot ? workspacePath(deps.workspaceRoot, source.trim()) : null;
+    if (!wp)
+        return localDocFailed(l);
+    let text;
     try {
-        const text = readFileSync(p, "utf8");
-        if (text.length > maxBytes)
-            return {
-                error: pick(l, `目录文档过大（> ${Math.round(maxBytes / 1024)} KB）`, `Catalog document too large (> ${Math.round(maxBytes / 1024)} KB)`, "plugincatalog.sync.too.large", { kb: String(Math.round(maxBytes / 1024)) }),
-            };
-        return { text };
+        text = readFileSync(wp.abs, "utf8");
     }
-    catch (err) {
-        return {
-            error: pick(l, `读取目录文件失败：${err?.message ?? err}`, `Failed to read the catalog file: ${err?.message ?? err}`, "plugincatalog.sync.read.failed", { reason: String(err?.message ?? err) }),
-        };
+    catch {
+        return localDocFailed(l);
     }
+    if (text.length > maxBytes)
+        return localDocFailed(l);
+    return { text };
 }
 /**
  * 同步一次目录：读 → 校验 → 原子写 → 可选安装 → 重载 + 重推。
@@ -86,11 +91,16 @@ export async function syncPluginCatalog(source, opts, deps) {
     const doc = await readDocument(src, deps, lang);
     if ("error" in doc)
         return { ok: false, error: doc.error };
+    const isLocalSource = !/^https?:\/\//i.test(src);
     let raw;
     try {
         raw = JSON.parse(doc.text);
     }
     catch (err) {
+        // 本地来源不区分「读得到但解析失败 / 读不到 / 越界」——组合起来就是文件探测
+        // oracle；http(s) 来源与本地文件无关，保留解析细节方便排障。
+        if (isLocalSource)
+            return { ok: false, error: localDocFailed(lang()).error };
         return {
             ok: false,
             error: pick(l, `目录 JSON 解析失败：${err?.message ?? err}`, `Catalog JSON is not valid JSON: ${err?.message ?? err}`, "plugincatalog.sync.parse.failed", { reason: String(err?.message ?? err) }),
@@ -104,6 +114,13 @@ export async function syncPluginCatalog(source, opts, deps) {
     await deps.afterWrite();
     let installed;
     if (opts.install === true && payload.entries.length) {
+        // 安装确认门（P0）：安装/更新插件是高风险动作，必须先经用户确认。第三方页面
+        // 脚本可以直发 plugin_catalog_sync，没有这道门就能静默装任意插件。拒绝 /
+        // 超时 / 无确认设施（无头 DSH）一律只保留目录更新，不安装。
+        const items = payload.entries.map((e) => ({ id: e.id, source: e.source }));
+        const confirmed = deps.confirmInstall ? await deps.confirmInstall(items) : false;
+        if (!confirmed)
+            return { ok: true, installRefused: true, installed: [] };
         installed = [];
         for (const e of payload.entries) {
             const action = existsSync(join(deps.pluginsDir, e.id)) ? "update" : "install";

package/dist/server/plugin-catalog.js

@@ -92,7 +92,11 @@ function toEntry(raw, builtin) {
         ...(homepage ? { homepage } : {}),
     };
 }
-/** 读合并后的目录：builtin 在前，custom 在后（同 id 时 custom 覆盖 builtin）。 */
+/** 读合并后的目录：builtin 在前，custom 在后（同 id 时 custom 覆盖 builtin）。
+ *  custom 覆盖 builtin 时强制打 `overridesBuiltin: true` 标记（builtin 同时为
+ *  false）：显示字段（name/icon/description）来自用户可写来源，可能仿冒官方条目，
+ *  前端据此把它标识为「自定义覆盖」。source 始终保留真实（custom）安装来源，
+ *  不允许伪装成官方来源。 */
 export function readCatalog(builtinPath, customPath) {
     const out = [];
     const seen = new Set();
@@ -117,10 +121,13 @@ export function readCatalog(builtinPath, customPath) {
         if (!e)
             continue;
         const idx = out.findIndex((x) => x.id === e.id);
-        if (idx >= 0)
-            out[idx] = e;
-        else
+        if (idx >= 0) {
+            // 覆盖了同名 builtin 条目：强制带标识（不信任 custom 文件里的任何自标字段）。
+            out[idx] = { ...e, builtin: false, overridesBuiltin: true };
+        }
+        else {
             out.push(e);
+        }
         seen.add(e.id);
     }
     return out;

package/dist/server/plugin-facilities.js

@@ -21,6 +21,9 @@ import { readFile as fspReadFile, readdir as fspReaddir, rm as fspRm, mkdir as f
 import { dirname, join, relative, resolve } from "node:path";
 import { createRequire } from "node:module";
 import { spawnSync } from "node:child_process";
+// 与 plugin-project 共用同一套 realpath 越界复核（isInsideRoot / realPathOfNearest），
+// 避免「同一个安全语义、两份实现」漂移。
+import { isInsideRoot, realPathOfNearest } from "./plugin-project.js";
 /** tmp+rename 原子写（错误由调用方隔离——插件设施的 IO 一律尽力而为）。 */
 function atomicWrite(file, data) {
     mkdirSync(dirname(file), { recursive: true });
@@ -29,6 +32,43 @@ function atomicWrite(file, data) {
     renameSync(tmp, file);
 }
 // ---------------------------------------------------------------------------
+// storage.json 的进程内「读-改-写」互斥
+// ---------------------------------------------------------------------------
+/** 按文件路径的 RMW 互斥链（key = resolve 后的绝对路径）。 */
+const rmwChains = new Map();
+/**
+ * 进程内「读-改-写」互斥（按文件路径的 promise 链锁）。
+ *
+ * storage.json 有两个读-改-写者：PluginStorage（插件 KV）与宿主 settings 面板的
+ * saveSettingsValues（plugins.ts，直写同一文件的 settings 键）。两段 RMW 必须互斥
+ * —— 现在两段关键区都是同步的（单线程下本就不会交错），但只要将来任何一处把
+ * 「读」和「写」之间插进 await，就会退回「旧快照整份回写、抹掉对方刚写的键」的
+ * 丢更新。两处统一收进这把锁：
+ *  - 空链 + 同步 fn：原地直跑（不引入微任务延迟，set() 后同步 get() 立即可见，
+ *    语义与未加锁完全一致）；fn 若返回 promise（异步写者）则占住链尾，后续排队；
+ *  - 链忙：挂到链尾串行（前一个成功/失败都放行下一个）。
+ * Map 不主动清理：键数量 = 有 storage.json 的插件数，天然有界。
+ */
+export function withFileRmwLock(file, fn) {
+    const key = resolve(file);
+    const prev = rmwChains.get(key);
+    if (prev) {
+        const queued = prev.then(fn, fn);
+        rmwChains.set(key, queued.then(() => undefined, () => undefined));
+        return queued;
+    }
+    const result = fn();
+    if (result instanceof Promise) {
+        const tail = result.then(() => undefined, () => undefined);
+        rmwChains.set(key, tail);
+        void tail.then(() => {
+            if (rmwChains.get(key) === tail)
+                rmwChains.delete(key);
+        });
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
 // storage
 // ---------------------------------------------------------------------------
 /** 每插件的 JSON 文件 KV。所有方法同步（数据量小，避免并发写乱序）。
@@ -88,29 +128,37 @@ export class PluginStorage {
     set(key, value) {
         if (!key)
             throw new Error("storage.set: key 不能为空");
-        // 写前必重读磁盘：宿主 settings 面板的 saveSettingsValues 直写同一文件的
-        // settings 键（不经过本缓存），拿旧快照整份回写会把它抹掉。写是低频路径，
-        // 重读的代价可忽略；mtime 粒度即使同毫秒也抹不掉（这里是无条件重读）。
-        const store = this.readFromDisk();
-        store[key] = value;
-        try {
-            atomicWrite(this.file, JSON.stringify(store));
-        }
-        catch (err) {
-            console.error(`[plugin-storage] 写入失败 (${this.file}):`, err);
-        }
+        // 与宿主 saveSettingsValues 同一把按文件路径的 RMW 锁（见 withFileRmwLock）：
+        // 两段「读-改-写」互斥，谁也不会拿旧快照抹掉对方刚写的键。当前关键区是同步的
+        // （空链直跑），set() 后同步 get() 立即可见，行为与未加锁一致。
+        void withFileRmwLock(this.file, () => {
+            // 写前必重读磁盘：宿主 settings 面板的 saveSettingsValues 直写同一文件的
+            // settings 键（不经过本缓存），拿旧快照整份回写会把它抹掉。写是低频路径，
+            // 重读的代价可忽略；mtime 粒度即使同毫秒也抹不掉（这里是无条件重读）。
+            const store = this.readFromDisk();
+            store[key] = value;
+            try {
+                atomicWrite(this.file, JSON.stringify(store));
+            }
+            catch (err) {
+                console.error(`[plugin-storage] 写入失败 (${this.file}):`, err);
+            }
+        });
     }
     delete(key) {
-        const store = this.readFromDisk(); // 同 set：写前重读，不拿旧快照回写
-        if (!(key in store))
-            return;
-        delete store[key];
-        try {
-            atomicWrite(this.file, JSON.stringify(store));
-        }
-        catch (err) {
-            console.error(`[plugin-storage] 写入失败 (${this.file}):`, err);
-        }
+        // 同 set：写前重读 + RMW 锁，不拿旧快照回写。
+        void withFileRmwLock(this.file, () => {
+            const store = this.readFromDisk();
+            if (!(key in store))
+                return;
+            delete store[key];
+            try {
+                atomicWrite(this.file, JSON.stringify(store));
+            }
+            catch (err) {
+                console.error(`[plugin-storage] 写入失败 (${this.file}):`, err);
+            }
+        });
     }
 }
 function seal(key, plaintext) {
@@ -362,6 +410,24 @@ export class WorkspaceFS {
         }
         return target;
     }
+    /**
+     * 写类操作（write/append/mkdir/remove）的 realpath 复核：abs() 是纯字符串
+     * 比较，工作区里的符号链接/junction 能把写入（或递归删除）引到工作区之外。
+     * 取目标最近已存在祖先的 realpath，复核它仍在「活根」的 realpath 内。
+     * 读/list/stat/glob 保持字符串校验（高频路径；读不存在「把内容写到别处」
+     * 的风险，性能优先 —— 有意的取舍）。
+     */
+    assertRealInsideRoot(rel) {
+        const target = this.abs(rel); // 字符串越界先拒绝（错误文案不变）
+        const targetReal = realPathOfNearest(target);
+        if (!targetReal)
+            throw new Error(`路径越界：无法解析真实路径 ${String(rel)}`);
+        const rootDir = resolve(this.root());
+        const rootReal = realPathOfNearest(rootDir) ?? rootDir;
+        if (!isInsideRoot(rootReal, targetReal)) {
+            throw new Error(`路径越界（符号链接指向工作区之外）：${String(rel)}`);
+        }
+    }
     /** 单层目录列表（浅层；深度遍历请插件自行递归）。 */
     async list(relDir = "") {
         try {
@@ -386,18 +452,21 @@ export class WorkspaceFS {
     }
     /** 写文件（自动补父目录；注意相对路径锚定当前项目——切换 cwd 后写进新项目）。 */
     async write(relPath, data) {
+        this.assertRealInsideRoot(relPath);
         const target = this.abs(relPath);
         await fspMkdir(dirname(target), { recursive: true });
         await fspWriteFile(target, data);
     }
     /** 追加写文件（日志/队列场景；父目录自动补；越界拒绝与 write 同口径）。 */
     async append(relPath, data) {
+        this.assertRealInsideRoot(relPath);
         const target = this.abs(relPath);
         await fspMkdir(dirname(target), { recursive: true });
         await fspAppendFile(target, data);
     }
     /** 建目录（递归；已存在幂等成功；越界拒绝与 write 同口径）。 */
     async mkdir(relDir) {
+        this.assertRealInsideRoot(relDir);
         await fspMkdir(this.abs(relDir), { recursive: true });
     }
     /** 文件元信息（size/mtime 供同步/缓存判断；不存在抛错）。 */
@@ -457,6 +526,8 @@ export class WorkspaceFS {
     }
     /** 删除文件/目录（递归；只允许删工作区内的路径）。 */
     async remove(relPath) {
+        // remove 同样做 realpath 复核：递归删除跟着目录链接走，比写文件更危险。
+        this.assertRealInsideRoot(relPath);
         await fspRm(this.abs(relPath), { recursive: true, force: false });
     }
 }

package/dist/server/plugin-installer.js

@@ -315,3 +315,33 @@ export class PluginInstaller {
         this.currentJobId = null;
     }
 }
+/**
+ * 插件安装的用户确认门（P0）：plugin_catalog_sync 的 install:true 与 plugin_job
+ * 的 install/update 在真正动安装器之前必须拿到用户确认。
+ *
+ * 用户若选择「记住并允许」，授权存入 plugin-permissions.json（后续同类操作自动放行，
+ * 设置面板「能力授权」页可审计与撤销）。拒绝 / 超时 / 未接弹窗设施（无头 DSH）一律 fail-closed。
+ */
+export async function confirmPluginInstall(items, deps) {
+    if (deps.permGrants?.has("plugin-installer", "net", { host: "github.com" })) {
+        return true;
+    }
+    const ask = deps.permissionRequester;
+    if (!ask)
+        return false;
+    const list = items.map((x) => `${x.id} ← ${x.source}`).join("\n");
+    const ans = await ask("plugin-installer", {
+        family: "net",
+        hosts: ["github.com"],
+        reason: `安装确认：将安装/更新以下插件（id ← source）：\n${list}\n拒绝或 120 秒未确认则不安装。`,
+    });
+    if (ans.ok && ans.remember && deps.permGrants) {
+        deps.permGrants.grant("plugin-installer", "net", {
+            hosts: ["github.com"],
+            reason: "插件安装/更新确认",
+            remember: true,
+        });
+        deps.onGrantsChanged?.();
+    }
+    return ans.ok === true;
+}

package/dist/server/plugin-llm.js

@@ -48,82 +48,88 @@ export async function completeWithIsolatedSession(env, req) {
     const maxChars = Math.min(Math.max(Number(req?.maxChars ?? DEFAULT_MAX_CHARS) || DEFAULT_MAX_CHARS, 1), MAX_MAX_CHARS);
     const timeoutMs = Math.min(Math.max(Number(req?.timeoutMs ?? DEFAULT_TIMEOUT_MS) || DEFAULT_TIMEOUT_MS, MIN_TIMEOUT_MS), MAX_TIMEOUT_MS);
     inflight += 1;
-    try {
-        const run = (async () => {
-            let dispose;
-            try {
-                const services = await createAgentSessionServices({
-                    cwd: env.cwd,
-                    agentDir: env.agentDir,
-                    // 技能全剥：纯补全不需要技能上下文（省 token，结果可预测）。
-                    resourceLoaderOptions: {
-                        skillsOverride: (res) => ({ ...res, skills: [] }),
-                    },
-                    modelRuntime: await ModelRuntime.create({
-                        authPath: join(env.agentDir, "auth.json"),
-                        modelsPath: join(env.agentDir, "models.json"),
-                    }),
-                });
-                // 模型：显式指定 > 主会话回落 > 会话默认（与 reviewer 同优先级）。
-                let model;
-                let modelName = "default";
-                const spec = parseModelSpec(req?.model);
-                if (spec) {
-                    model = services.modelRuntime.getModel(spec.provider, spec.id);
-                    if (!model)
-                        return fail(`llm.complete: 找不到模型 ${spec.spec}`);
-                    modelName = spec.spec;
-                }
-                if (!model && env.fallbackModel) {
-                    model = services.modelRuntime.getModel(env.fallbackModel.provider, env.fallbackModel.id);
-                    if (model)
-                        modelName = `${env.fallbackModel.provider}/${env.fallbackModel.id}`;
-                }
-                const srv = await createAgentSessionFromServices({
-                    services,
-                    sessionManager: SessionManager.inMemory(env.cwd),
-                    ...(model ? { model } : {}),
-                    // 全部工具关闭（"all"）：纯补全，无副作用（SDK 的 noTools 是 "builtin"|"all" 枚举）。
-                    noTools: "all",
-                });
-                dispose = () => {
-                    try {
-                        srv.session.dispose();
-                    }
-                    catch {
-                        /* dispose 尽力而为 */
-                    }
-                };
-                const text = system.trim() ? `系统指令：${system.trim()}\n\n---\n\n任务：${prompt}` : prompt;
-                await srv.session.prompt(text, { expandPromptTemplates: false });
-                const raw = srv.session.getLastAssistantText() ?? "";
-                let usage;
-                try {
-                    const stats = srv.session.getSessionStats();
-                    usage = { input: stats.tokens.input, output: stats.tokens.output };
-                }
-                catch {
-                    /* usage 尽力而为 */
-                }
-                return { ok: true, text: raw.slice(0, maxChars), model: modelName, ...(usage ? { usage } : {}) };
+    const run = (async () => {
+        let dispose;
+        try {
+            const services = await createAgentSessionServices({
+                cwd: env.cwd,
+                agentDir: env.agentDir,
+                // 技能全剥：纯补全不需要技能上下文（省 token，结果可预测）。
+                resourceLoaderOptions: {
+                    skillsOverride: (res) => ({ ...res, skills: [] }),
+                },
+                modelRuntime: await ModelRuntime.create({
+                    authPath: join(env.agentDir, "auth.json"),
+                    modelsPath: join(env.agentDir, "models.json"),
+                }),
+            });
+            // 模型：显式指定 > 主会话回落 > 会话默认（与 reviewer 同优先级）。
+            let model;
+            let modelName = "default";
+            const spec = parseModelSpec(req?.model);
+            if (spec) {
+                model = services.modelRuntime.getModel(spec.provider, spec.id);
+                if (!model)
+                    return fail(`llm.complete: 找不到模型 ${spec.spec}`);
+                modelName = spec.spec;
+            }
+            if (!model && env.fallbackModel) {
+                model = services.modelRuntime.getModel(env.fallbackModel.provider, env.fallbackModel.id);
+                if (model)
+                    modelName = `${env.fallbackModel.provider}/${env.fallbackModel.id}`;
             }
-            finally {
-                // 会话回收跟 run 走：超时竞速输了 run 还在飞，run 落定才 dispose，不留孤儿。
+            const srv = await createAgentSessionFromServices({
+                services,
+                sessionManager: SessionManager.inMemory(env.cwd),
+                ...(model ? { model } : {}),
+                // 全部工具关闭（"all"）：纯补全，无副作用（SDK 的 noTools 是 "builtin"|"all" 枚举）。
+                noTools: "all",
+            });
+            dispose = () => {
                 try {
-                    dispose?.();
+                    srv.session.dispose();
                 }
                 catch {
                     /* dispose 尽力而为 */
                 }
+            };
+            const text = system.trim() ? `系统指令：${system.trim()}\n\n---\n\n任务：${prompt}` : prompt;
+            await srv.session.prompt(text, { expandPromptTemplates: false });
+            const raw = srv.session.getLastAssistantText() ?? "";
+            let usage;
+            try {
+                const stats = srv.session.getSessionStats();
+                usage = { input: stats.tokens.input, output: stats.tokens.output };
+            }
+            catch {
+                /* usage 尽力而为 */
+            }
+            return { ok: true, text: raw.slice(0, maxChars), model: modelName, ...(usage ? { usage } : {}) };
+        }
+        finally {
+            // 会话回收跟 run 走：超时竞速输了 run 还在飞，run 落定才 dispose，不留孤儿。
+            try {
+                dispose?.();
+            }
+            catch {
+                /* dispose 尽力而为 */
             }
-        })();
+        }
+    })();
+    // 并发计数跟**真实 run** 走，而不是外层函数的 finally：超时竞速返回后 run 还在飞，
+    // 计数必须继续占着 MAX_INFLIGHT 的位 —— 否则每次超时都「腾出」一路并发，
+    // 连续超时的插件能把在飞会话越堆越多，护栏失效。catch 挂在分支上兜住 run 的
+    // 拒绝（竞速已由 timer 赢时，外层 catch 不会再收到它）。
+    void run
+        .catch(() => { })
+        .finally(() => {
+        inflight -= 1;
+    });
+    try {
         const timer = new Promise((resolve) => setTimeout(() => resolve(fail(`llm.complete: 超时（约${Math.round(timeoutMs / 1000)}s）`)), timeoutMs));
         return await Promise.race([run, timer]);
     }
     catch (err) {
         return fail(`llm.complete: ${err.message}`);
     }
-    finally {
-        inflight -= 1;
-    }
 }

package/dist/server/plugin-project.js

@@ -24,7 +24,8 @@
  */
 import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { readdir as fspReaddir } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { killPidTree } from "./process-utils.js";
 /** 单条 git 命令的默认墙钟上限：大仓库 clone 可能很慢，给足 5 分钟。 */
@@ -91,8 +92,9 @@ function realpathOf(p) {
  * 目标自身（存在时）或它最近一个**已存在的祖先**的真实路径；一路到盘根都解析不出来 → null。
  * 用途是复核符号链接：`<root>/link/file.txt` 里 link 若是指向别处的 junction，
  * 单看字符串它「在 root 里」，realpath 之后就露馅了。
+ * 导出给 plugin-facilities / plugins.ts 的写类操作复用（同一套越界复核语义）。
  */
-function realPathOfNearest(abs) {
+export function realPathOfNearest(abs) {
     let probe = abs;
     for (let i = 0; i < MAX_ANCESTOR_HOPS; i++) {
         try {
@@ -111,6 +113,28 @@ function realPathOfNearest(abs) {
 function toSlash(p) {
     return p.split(sep).join("/");
 }
+/**
+ * 递归列目录，返回树内全部符号链接 / junction 的绝对路径。
+ * win32 上 Dirent.isSymbolicLink() 同样覆盖 junction（lstat 语义）；只读不跟随。
+ * 目录读不了（权限/竞态删除）返回空数组 —— 兜底交给写入前的逐目标 realpath 复核。
+ */
+async function findSymlinks(dir) {
+    const out = [];
+    let entries;
+    try {
+        entries = await fspReaddir(dir, { recursive: true, withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        if (!e.isSymbolicLink())
+            continue;
+        const parent = e.parentPath ?? dir;
+        out.push(join(parent, e.name));
+    }
+    return out;
+}
 function errMessage(err) {
     return err instanceof Error ? err.message : String(err);
 }
@@ -394,6 +418,28 @@ export async function createProject(spec, deps = {}) {
         return undefined;
     };
     try {
+        // 本轮真正 clone 出的目录（根目录本身除外 —— 它是授权目录，绝不清理）与
+        // 已写入的文件，供「clone 后置复核命中」时回滚，不把半个带毒仓库留在盘上。
+        const clonedThisRun = plannedRepos.filter((r) => !samePath(r.dest, root)).map((r) => r.dest);
+        const writtenThisRun = [];
+        const cleanupThisRun = () => {
+            for (const f of writtenThisRun) {
+                try {
+                    rmSync(f, { force: true });
+                }
+                catch {
+                    /* 清理尽力而为 */
+                }
+            }
+            for (const d of clonedThisRun) {
+                try {
+                    rmSync(d, { recursive: true, force: true });
+                }
+                catch {
+                    /* 清理尽力而为 */
+                }
+            }
+        };
         for (const r of plannedRepos) {
             const atRoot = samePath(r.dest, root);
             // 根目录已存在是常态（它就是那个已存在的授权目录），既不 rm 也不 mkdir ——
@@ -420,10 +466,32 @@ export async function createProject(spec, deps = {}) {
             if (why)
                 return fail(`${why}${res.stderrTail === "" ? "" : `：${res.stderrTail}`}`);
         }
+        // ——— ⑥ clone 后置复核（写文件前）：前置校验（③④）都在 clone 之前，而恶意
+        //     仓库可以在 clone 时落地指向 root 之外的符号链接，随后的文件写入就会跟着
+        //     链接跑出授权目录（「先 clone 后校验」的逃逸窗口）。两道防线：
+        //     a. 扫描 clone 出的目录树，出现任何符号链接即视为恶意仓库整体拒绝
+        //        （clone --depth 1 不跑包管理器，正常仓库极少提交 symlink，宁可误杀）；
+        //     b. 每个写入目标写前再做一次 realPathOfNearest 复核（覆盖 a 与写盘之间的窗口）。
+        //     任一命中：清理本轮 clone 的目录（rmSync 不跟随符号链接，安全）与已写文件。
+        for (const dest of clonedThisRun) {
+            const offenders = await findSymlinks(dest);
+            if (offenders.length > 0) {
+                cleanupThisRun();
+                return fail(`仓库包含符号链接（视为恶意仓库拒绝），例如：${toSlash(relative(root, offenders[0]))}`);
+            }
+        }
         for (const f of plannedFiles) {
+            // 写前复核目标仍解析在 rootReal 内：前置校验时它还不存在（最近祖先在 root 内），
+            // clone 之后可能被仓库塞进来的符号链接顶掉。
+            const real = realPathOfNearest(f.abs);
+            if (real === null || !isInsideRoot(rootReal, real)) {
+                cleanupThisRun();
+                return fail(`files 路径越界（clone 后复核：符号链接指向 dir 之外）：${f.rel}`);
+            }
             emit(`write ${f.rel}`);
             mkdirSync(dirname(f.abs), { recursive: true });
             writeFileSync(f.abs, f.content, "utf8");
+            writtenThisRun.push(f.abs);
         }
         if (spec?.gitInit === true) {
             emit("git init");