larkin 0.4.17 → 0.4.19

package/dist/runtime/pi-profile-migration.mjs

@@ -4,6 +4,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { spawnSync } from "node:child_process";
 import processInspect from "../platform/process-inspect.cjs";
+import { applyPiPackageDirForChild } from "./builtin-pi-assets.mjs";
 import { resolveRuntimeExecutable } from "./runtime-readiness.mjs";
 import { mergeOwnedPiSettings, parsePiExecutableVersion } from "./pi-compaction-recovery.mjs";
 import { BUNDLED_PI_VERSION } from "./pi-provider-config.mjs";
@@ -16,6 +17,60 @@ const EXECUTABLE_LIMIT = 256 * 1024 * 1024;
 const SOURCE_MODES = new Set([0o600, 0o644, 0o640]);
 const TARGET_LOCK_SUFFIX = ".larkin-pi-import.lock";
 function hash(bytes) { return crypto.createHash("sha256").update(bytes).digest("hex"); }
+function isPiOrLarkinEnvKey(key) {
+    return key === "PATH" || key.startsWith("PI_") || key.startsWith("LARKIN_");
+}
+function isolatePlannedReplayEnv(source) {
+    const next = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (isPiOrLarkinEnvKey(key))
+            continue;
+        next[key] = value;
+    }
+    if (source.PATH)
+        next.PATH = source.PATH;
+    if (source.LARKIN_PI_COMMAND)
+        next.LARKIN_PI_COMMAND = source.LARKIN_PI_COMMAND;
+    if (source.PI_PACKAGE_DIR)
+        next.PI_PACKAGE_DIR = source.PI_PACKAGE_DIR;
+    return next;
+}
+function capturePackageRootProof(directory) {
+    const resolved = fs.realpathSync(directory);
+    const rootStat = fs.statSync(resolved);
+    const theme = path.join(resolved, "dist", "modes", "interactive", "theme", "dark.json");
+    let fd;
+    try {
+        fd = fs.openSync(theme, fs.constants.O_RDONLY);
+        const themeStat = fs.fstatSync(fd);
+        if (!themeStat.isFile())
+            throw new Error("external Pi package root changed; refusing migration");
+        const bytes = fs.readFileSync(fd);
+        return { dir: resolved, dev: rootStat.dev, ino: rootStat.ino, themeSha256: hash(bytes) };
+    }
+    finally {
+        if (fd !== undefined)
+            try {
+                fs.closeSync(fd);
+            }
+            catch { /* ignore */ }
+    }
+}
+function assertPackageRootProof(state) {
+    if (!state.sourcePackageDir)
+        return;
+    let current;
+    try {
+        current = capturePackageRootProof(state.sourcePackageDir);
+    }
+    catch {
+        throw new Error("external Pi package root changed; refusing migration");
+    }
+    if (current.dir !== state.sourcePackageDir || current.dev !== state.sourcePackageDev
+        || current.ino !== state.sourcePackageIno || current.themeSha256 !== state.sourcePackageThemeSha256) {
+        throw new Error("external Pi package root changed; refusing migration");
+    }
+}
 function targetLockFile(state) { return path.join(path.dirname(state.targetDir), `${state.agentId}${TARGET_LOCK_SUFFIX}`); }
 function acquireTargetLock(state) {
     const file = targetLockFile(state);
@@ -269,13 +324,20 @@ function targetDirectory(configDir, agentId) {
         throw new Error("Pi Agent ID 格式无效");
     return path.join(path.resolve(configDir), "providers", "pi", agentId);
 }
-function sourceVersion(env, cwd) {
+function sourceVersion(env, cwd, alreadySanitized = false) {
     const command = String(env.LARKIN_PI_COMMAND || "pi");
     const executable = resolveRuntimeExecutable(command, env);
     if (!executable)
         throw new Error("外部 Pi 0.84.2 profile import requires an installed Pi executable");
     const executableState = readExecutable(executable, "external Pi executable");
-    const result = spawnSync(executableState.path, ["--version"], { cwd, env, encoding: "utf8", timeout: 5_000, maxBuffer: 64 * 1024 });
+    const probeEnv = alreadySanitized ? env : applyPiPackageDirForChild(env, { distribution: "external" });
+    const result = spawnSync(executableState.path, ["--version"], {
+        cwd,
+        env: probeEnv,
+        encoding: "utf8",
+        timeout: 5_000,
+        maxBuffer: 64 * 1024,
+    });
     if (result.status !== 0)
         throw new Error("external Pi version probe failed");
     try {
@@ -321,10 +383,11 @@ function targetPrior(directory) {
     return { stat, entries, files };
 }
 export function preparePiProfileMigration(env, configDir, agentId, distribution = "builtin") {
-    const sourceDir = sourceDirectory(env);
+    const sanitized = applyPiPackageDirForChild({ ...env }, { distribution: "external" });
+    const sourceDir = sourceDirectory(sanitized);
     verifySourceProfile(sourceDir);
     const sourceDirectoryState = assertDirectory(sourceDir, "external Pi profile");
-    const sourceExecutable = sourceVersion(env, sourceDir);
+    const sourceExecutable = sourceVersion(sanitized, sourceDir, true);
     const sourceFiles = Object.fromEntries(FILES.map((name) => {
         const file = readRegular(path.join(sourceDir, name), `external Pi ${name}`, false);
         if (!file)
@@ -346,14 +409,28 @@ export function preparePiProfileMigration(env, configDir, agentId, distribution
     const afterFiles = Object.fromEntries(FILES.map((name) => [name, safeState({ bytes: imported[name], mode: 0o600 }, false)]));
     return {
         state: { version: 1, agentId, sourceDir, sourceDirMode: sourceDirectoryState.mode & 0o777,
-            sourceCommand: String(env.LARKIN_PI_COMMAND || "pi"), sourceExecutable,
+            sourceCommand: String(sanitized.LARKIN_PI_COMMAND || "pi"), sourceExecutable,
             sourceFiles: Object.fromEntries(FILES.map((name) => [name, safeState(sourceFiles[name], false)])),
             targetDir, targetDirExisted: Boolean(target.stat), targetDirMode: target.stat ? target.stat.mode & 0o777 : 0o700,
             ...(target.stat ? { targetDirDevice: target.stat.dev, targetDirInode: target.stat.ino } : {}), targetEntries: target.entries,
-            priorFiles: target.files, afterFiles },
+            priorFiles: target.files, afterFiles,
+            ...(sanitized.PATH ? { sourcePath: sanitized.PATH } : {}),
+            ...(sanitized.PI_PACKAGE_DIR ? (() => {
+                const proof = capturePackageRootProof(sanitized.PI_PACKAGE_DIR);
+                return {
+                    sourcePackageDir: proof.dir,
+                    sourcePackageDev: proof.dev,
+                    sourcePackageIno: proof.ino,
+                    sourcePackageThemeSha256: proof.themeSha256,
+                };
+            })() : {}) },
         sourceBytes: { "auth.json": sourceFiles["auth.json"].bytes, "models.json": sourceFiles["models.json"].bytes,
             "settings.json": imported["settings.json"] },
-        sourceEnvironment: { PATH: env.PATH, LARKIN_PI_COMMAND: env.LARKIN_PI_COMMAND },
+        sourceEnvironment: {
+            PATH: sanitized.PATH,
+            LARKIN_PI_COMMAND: String(sanitized.LARKIN_PI_COMMAND || "pi"),
+            ...(sanitized.PI_PACKAGE_DIR ? { PI_PACKAGE_DIR: capturePackageRootProof(sanitized.PI_PACKAGE_DIR).dir } : {}),
+        },
     };
 }
 export function validatePiProfileMigrationState(value) {
@@ -394,12 +471,26 @@ export function validatePiProfileMigrationState(value) {
         }
     }
 }
+function replayExternalPiPackageEnv(env) {
+    const next = { ...env };
+    const planned = env.PI_PACKAGE_DIR;
+    if (!planned) {
+        delete next.PI_PACKAGE_DIR;
+        return next;
+    }
+    const resolved = applyPiPackageDirForChild({ PI_PACKAGE_DIR: planned }, { distribution: "external", explicitPackageDir: planned }).PI_PACKAGE_DIR;
+    if (!resolved)
+        throw new Error("external Pi package root changed; refusing migration");
+    next.PI_PACKAGE_DIR = resolved;
+    return next;
+}
 function assertSourceUnchanged(state, resolutionEnvironment = process.env, verifyResolution = true) {
     const directory = assertDirectory(state.sourceDir, "external Pi profile");
     if ((directory.mode & 0o777) !== state.sourceDirMode)
         throw new Error("external Pi profile changed; refusing migration");
     verifySourceProfile(state.sourceDir);
-    const probeEnvironment = { ...process.env, ...resolutionEnvironment };
+    assertPackageRootProof(state);
+    const probeEnvironment = replayExternalPiPackageEnv(resolutionEnvironment);
     const resolved = verifyResolution ? resolveRuntimeExecutable(state.sourceCommand, probeEnvironment) : state.sourceExecutable.path;
     if (!resolved)
         throw new Error("external Pi executable changed; refusing migration");
@@ -408,7 +499,13 @@ function assertSourceUnchanged(state, resolutionEnvironment = process.env, verif
         || executable.bytes !== state.sourceExecutable.bytes || executable.mode !== state.sourceExecutable.mode) {
         throw new Error("external Pi executable changed; refusing migration");
     }
-    const result = spawnSync(executable.path, ["--version"], { cwd: state.sourceDir, env: probeEnvironment, encoding: "utf8", timeout: 5_000, maxBuffer: 64 * 1024 });
+    const result = spawnSync(executable.path, ["--version"], {
+        cwd: state.sourceDir,
+        env: probeEnvironment,
+        encoding: "utf8",
+        timeout: 5_000,
+        maxBuffer: 64 * 1024,
+    });
     if (result.status !== 0)
         throw new Error("external Pi version probe failed");
     try {
@@ -520,9 +617,8 @@ function restoreFile(file, prior) {
         fs.chmodSync(file, prior.mode);
 }
 export function applyPiProfileMigration(plan) {
-    const sameEnvironment = process.env.PATH === plan.sourceEnvironment.PATH
-        && process.env.LARKIN_PI_COMMAND === plan.sourceEnvironment.LARKIN_PI_COMMAND;
-    assertSourceUnchanged(plan.state, sameEnvironment ? process.env : plan.sourceEnvironment);
+    const replayEnv = isolatePlannedReplayEnv(plan.sourceEnvironment);
+    assertSourceUnchanged(plan.state, replayEnv);
     const parent = path.dirname(plan.state.targetDir);
     assertNoSymlinkAncestors(parent);
     fs.mkdirSync(parent, { recursive: true, mode: 0o700 });
@@ -568,7 +664,11 @@ function fsyncDirectory(directory) {
 }
 export function rollbackPiProfileMigration(state) {
     validatePiProfileMigrationState(state);
-    assertSourceUnchanged(state, process.env, false);
+    assertSourceUnchanged(state, isolatePlannedReplayEnv({
+        PATH: state.sourcePath,
+        LARKIN_PI_COMMAND: state.sourceCommand,
+        ...(state.sourcePackageDir ? { PI_PACKAGE_DIR: state.sourcePackageDir } : {}),
+    }), false);
     const target = assertDirectory(state.targetDir, "Pi provider target", false);
     if (!target) {
         if (state.targetDirExisted)