@tea-agent/loop-agent 0.24.11-beta.0 → 0.25.1

package/dist/executors/pi-prompt-transport.js

@@ -0,0 +1,198 @@
+import { closeSync, fstatSync, fsyncSync, ftruncateSync, lstatSync, mkdtempSync, openSync, realpathSync, rmdirSync, unlinkSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+const PROMPT_DIRECTORY_PREFIX = "loop-agent-pi-prompt-";
+const PROMPT_FILE_NAME = "system-prompt.md";
+function identityOf(stats) {
+    return { dev: stats.dev, ino: stats.ino };
+}
+function hasIdentity(stats, identity) {
+    return stats.dev === identity.dev && stats.ino === identity.ino;
+}
+function normalizedPath(value) {
+    const resolved = path.resolve(value);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function assertOwnedPromptPaths(transport) {
+    const tempRoot = normalizedPath(transport.tempRoot);
+    const directoryPath = normalizedPath(transport.directoryPath);
+    const filePath = normalizedPath(transport.filePath);
+    const tempRootStats = lstatSync(transport.tempRoot, { bigint: true });
+    if (!tempRootStats.isDirectory() ||
+        tempRootStats.isSymbolicLink() ||
+        !hasIdentity(tempRootStats, transport.tempRootIdentity)) {
+        throw new Error("Pi prompt cleanup refused: temporary root identity changed");
+    }
+    if (normalizedPath(path.dirname(transport.directoryPath)) !== tempRoot) {
+        throw new Error("Pi prompt cleanup refused: temporary directory escaped its recorded root");
+    }
+    if (!path.basename(directoryPath).startsWith(PROMPT_DIRECTORY_PREFIX)) {
+        throw new Error("Pi prompt cleanup refused: unexpected temporary directory name");
+    }
+    if (normalizedPath(path.dirname(transport.filePath)) !== directoryPath) {
+        throw new Error("Pi prompt cleanup refused: prompt file escaped its recorded directory");
+    }
+    if (path.basename(filePath) !== PROMPT_FILE_NAME) {
+        throw new Error("Pi prompt cleanup refused: unexpected prompt file name");
+    }
+}
+export function createPiPromptTransport(prompt) {
+    const tempRoot = realpathSync.native(tmpdir());
+    const tempRootStats = lstatSync(tempRoot, { bigint: true });
+    if (!tempRootStats.isDirectory() || tempRootStats.isSymbolicLink()) {
+        throw new Error("Pi prompt transport requires a real temporary directory");
+    }
+    const tempRootIdentity = identityOf(tempRootStats);
+    const directoryPath = mkdtempSync(path.join(tempRoot, PROMPT_DIRECTORY_PREFIX));
+    const currentTempRootStats = lstatSync(tempRoot, { bigint: true });
+    if (!hasIdentity(currentTempRootStats, tempRootIdentity)) {
+        throw new Error("Pi prompt transport temporary root changed during creation");
+    }
+    const directoryStats = lstatSync(directoryPath, { bigint: true });
+    if (!directoryStats.isDirectory() || directoryStats.isSymbolicLink()) {
+        throw new Error("Pi prompt transport did not create a private directory");
+    }
+    const filePath = path.join(directoryPath, PROMPT_FILE_NAME);
+    let fileDescriptor;
+    let fileIdentity;
+    try {
+        fileDescriptor = openSync(filePath, "wx", 0o600);
+        fileIdentity = identityOf(fstatSync(fileDescriptor, { bigint: true }));
+        writeFileSync(fileDescriptor, prompt, { encoding: "utf-8" });
+        fsyncSync(fileDescriptor);
+        return {
+            directoryPath,
+            filePath,
+            fileDescriptor,
+            tempRoot,
+            tempRootIdentity,
+            directoryIdentity: identityOf(directoryStats),
+            fileIdentity,
+        };
+    }
+    catch (error) {
+        if (fileDescriptor !== undefined && fileIdentity !== undefined) {
+            try {
+                cleanupPiPromptTransport({
+                    directoryPath,
+                    filePath,
+                    fileDescriptor,
+                    tempRoot,
+                    tempRootIdentity,
+                    directoryIdentity: identityOf(directoryStats),
+                    fileIdentity,
+                });
+            }
+            catch {
+                // Creation failed; the original error remains authoritative.
+            }
+        }
+        else {
+            try {
+                if (fileDescriptor !== undefined)
+                    closeSync(fileDescriptor);
+            }
+            catch {
+                // Best effort before rethrowing the creation error.
+            }
+            try {
+                const currentDirectory = lstatSync(directoryPath, { bigint: true });
+                if (hasIdentity(currentDirectory, identityOf(directoryStats))) {
+                    rmdirSync(directoryPath);
+                }
+            }
+            catch {
+                // Never recursively remove a transport directory.
+            }
+        }
+        throw error;
+    }
+}
+/**
+ * Clear and remove only the exact prompt file created by this transport.
+ * The directory is removed only when it is still the same empty directory.
+ */
+export function cleanupPiPromptTransport(transport) {
+    const warnings = [];
+    let contentCleared = false;
+    let fileRemoved = false;
+    let directoryRemoved = false;
+    let truncateError;
+    try {
+        ftruncateSync(transport.fileDescriptor, 0);
+        fsyncSync(transport.fileDescriptor);
+        contentCleared = true;
+    }
+    catch (error) {
+        truncateError = error;
+    }
+    finally {
+        try {
+            closeSync(transport.fileDescriptor);
+        }
+        catch {
+            // A closed descriptor is acceptable; identity checks still guard deletion.
+        }
+    }
+    let pathsOwned = false;
+    try {
+        assertOwnedPromptPaths(transport);
+        const directoryStats = lstatSync(transport.directoryPath, { bigint: true });
+        const fileStats = lstatSync(transport.filePath, { bigint: true });
+        pathsOwned =
+            directoryStats.isDirectory() &&
+                !directoryStats.isSymbolicLink() &&
+                hasIdentity(directoryStats, transport.directoryIdentity) &&
+                fileStats.isFile() &&
+                !fileStats.isSymbolicLink() &&
+                hasIdentity(fileStats, transport.fileIdentity);
+        if (!pathsOwned) {
+            warnings.push("Pi prompt cleanup refused deletion because path identity changed");
+        }
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            fileRemoved = true;
+        }
+        else {
+            warnings.push(`Pi prompt cleanup could not verify the exact prompt path: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (pathsOwned) {
+        try {
+            unlinkSync(transport.filePath);
+            fileRemoved = true;
+        }
+        catch (error) {
+            warnings.push(`Pi prompt cleanup could not unlink the exact prompt file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (!contentCleared && !fileRemoved) {
+        throw new Error(`Pi prompt cleanup could not prove prompt removal: ${truncateError instanceof Error ? truncateError.message : String(truncateError ?? "unknown truncate failure")}`);
+    }
+    if (fileRemoved) {
+        try {
+            const directoryStats = lstatSync(transport.directoryPath, { bigint: true });
+            if (directoryStats.isDirectory() &&
+                !directoryStats.isSymbolicLink() &&
+                hasIdentity(directoryStats, transport.directoryIdentity)) {
+                rmdirSync(transport.directoryPath);
+                directoryRemoved = true;
+            }
+            else {
+                warnings.push("Pi prompt cleanup refused directory removal because identity changed");
+            }
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ENOENT") {
+                directoryRemoved = true;
+            }
+            else {
+                warnings.push(`Pi prompt cleanup left an empty or non-empty transport directory: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    return { contentCleared, fileRemoved, directoryRemoved, warnings };
+}

package/dist/executors/pi-sdk-executor.js

@@ -296,7 +296,7 @@ export async function executeSingleSdkAttempt(options) {
         '--model', modelConfig.model ?? '(default)',
         ...(modelConfig.thinking ? ['--thinking', modelConfig.thinking] : []),
         '--tools', options.toolNames.join(','),
-        '--append-system-prompt', options.prompt,
+        '--append-system-prompt', '<in-memory-system-prompt>',
         ...options.attachedFiles.map((file) => `@${file}`),
         options.userMessage,
     ];

package/dist/executors/process-tree.js

@@ -0,0 +1,33 @@
+import { spawnSync } from "node:child_process";
+/** Terminate a command and all descendants that it started. */
+export function terminateProcessTree(child, signal, dependencies = {}) {
+    if (child.exitCode !== null && child.exitCode !== undefined)
+        return true;
+    const pid = child.pid;
+    if (!pid)
+        return child.kill(signal);
+    const platform = dependencies.platform ?? process.platform;
+    if (platform === "win32") {
+        const runTaskkill = dependencies.runTaskkill ?? ((targetPid) => {
+            const result = spawnSync("taskkill.exe", ["/pid", String(targetPid), "/t", "/f"], { stdio: "ignore", windowsHide: true });
+            return !result.error && result.status === 0;
+        });
+        return runTaskkill(pid) || child.kill(signal);
+    }
+    try {
+        const killProcessGroup = dependencies.killProcessGroup ?? ((targetPid, targetSignal) => {
+            process.kill(-targetPid, targetSignal);
+        });
+        killProcessGroup(pid, signal);
+        return true;
+    }
+    catch {
+        return child.kill(signal);
+    }
+}
+export function processTreeSpawnOptions() {
+    return {
+        detached: process.platform !== "win32",
+        windowsHide: true,
+    };
+}