@allurereport/plugin-agent 3.11.0 → 3.12.0

package/dist/utils.js

@@ -0,0 +1,171 @@
+import { createHash } from "node:crypto";
+import { mkdir, open, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+export const ALLURE_AGENT_STATE_DIR_ENV = "ALLURE_AGENT_STATE_DIR";
+export const AGENT_MANAGED_OUTPUT_DIR_PREFIX = "allure-agent-";
+const AGENT_STATE_LOCK_STALE_MS = 10 * 60 * 1000;
+const AGENT_STATE_LOCK_RETRIES = 100;
+const AGENT_STATE_LOCK_RETRY_MS = 20;
+export const isFileNotFoundError = (error) => typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+const isFileExistsError = (error) => typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+const projectHash = (cwd) => createHash("sha256").update(cwd).digest("hex").slice(0, 16);
+export const resolveAgentStateDir = (_cwd) => {
+    const configuredDir = process.env[ALLURE_AGENT_STATE_DIR_ENV]?.trim();
+    if (configuredDir) {
+        return resolve(configuredDir);
+    }
+    return join(tmpdir(), "allure-agent-state");
+};
+export const projectStatePath = (cwd) => join(resolveAgentStateDir(cwd), `${projectHash(resolve(cwd))}.jsonl`);
+const projectLockPath = (cwd) => join(resolveAgentStateDir(cwd), `${projectHash(resolve(cwd))}.lock`);
+export const listAgentStatePaths = async (cwd) => {
+    const stateDir = resolveAgentStateDir(cwd);
+    try {
+        const entries = await readdir(stateDir, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl"))
+            .map((entry) => join(stateDir, entry.name));
+    }
+    catch (error) {
+        if (isFileNotFoundError(error)) {
+            return [];
+        }
+        throw error;
+    }
+};
+export const listAgentManagedTempOutputDirs = async () => {
+    const tempRoot = tmpdir();
+    try {
+        const entries = await readdir(tempRoot, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory() && entry.name.startsWith(AGENT_MANAGED_OUTPUT_DIR_PREFIX))
+            .map((entry) => join(tempRoot, entry.name));
+    }
+    catch (error) {
+        if (isFileNotFoundError(error)) {
+            return [];
+        }
+        throw error;
+    }
+};
+export const writeJsonlAtomic = async (filePath, values) => {
+    await mkdir(dirname(filePath), { recursive: true });
+    const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    const content = values.map((value) => JSON.stringify(value)).join("\n") + (values.length ? "\n" : "");
+    await writeFile(tempPath, content, "utf-8");
+    await rename(tempPath, filePath);
+};
+const removeLockIfStale = async (lockPath) => {
+    try {
+        const lockStat = await stat(lockPath);
+        if (Date.now() - lockStat.mtimeMs > AGENT_STATE_LOCK_STALE_MS) {
+            await rm(lockPath, { force: true });
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        if (isFileNotFoundError(error)) {
+            return true;
+        }
+        throw error;
+    }
+};
+const openAgentStateLock = async (lockPath) => {
+    let lockHandle;
+    try {
+        lockHandle = await open(lockPath, "wx");
+        await lockHandle.writeFile(`${process.pid}\n${Date.now()}\n`, "utf-8");
+        return lockHandle;
+    }
+    catch (error) {
+        if (lockHandle) {
+            await lockHandle.close().catch(() => undefined);
+            await rm(lockPath, { force: true }).catch(() => undefined);
+        }
+        throw error;
+    }
+};
+const runWithAgentStateLock = async (lockPath, lockHandle, operation) => {
+    try {
+        return await operation();
+    }
+    finally {
+        await lockHandle.close().catch(() => undefined);
+        await rm(lockPath, { force: true }).catch(() => undefined);
+    }
+};
+export const withAgentStateLock = async (cwd, operation) => {
+    const normalizedCwd = resolve(cwd);
+    const stateDir = resolveAgentStateDir(normalizedCwd);
+    const lockPath = projectLockPath(normalizedCwd);
+    let lastError;
+    await mkdir(stateDir, { recursive: true });
+    for (let attempt = 0; attempt < AGENT_STATE_LOCK_RETRIES; attempt += 1) {
+        try {
+            const lockHandle = await openAgentStateLock(lockPath);
+            return await runWithAgentStateLock(lockPath, lockHandle, operation);
+        }
+        catch (error) {
+            if (!isFileExistsError(error)) {
+                throw error;
+            }
+            lastError = error;
+            await removeLockIfStale(lockPath);
+            await sleep(AGENT_STATE_LOCK_RETRY_MS);
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(`Could not acquire agent state lock: ${lockPath}`);
+};
+export const tryWithAgentStateLock = async (cwd, operation) => {
+    const normalizedCwd = resolve(cwd);
+    const stateDir = resolveAgentStateDir(normalizedCwd);
+    const lockPath = projectLockPath(normalizedCwd);
+    await mkdir(stateDir, { recursive: true });
+    try {
+        const lockHandle = await openAgentStateLock(lockPath);
+        return {
+            acquired: true,
+            result: await runWithAgentStateLock(lockPath, lockHandle, operation),
+        };
+    }
+    catch (error) {
+        if (!isFileExistsError(error)) {
+            throw error;
+        }
+        if (!(await removeLockIfStale(lockPath))) {
+            return { acquired: false };
+        }
+    }
+    try {
+        const lockHandle = await openAgentStateLock(lockPath);
+        return {
+            acquired: true,
+            result: await runWithAgentStateLock(lockPath, lockHandle, operation),
+        };
+    }
+    catch (error) {
+        if (isFileExistsError(error)) {
+            return { acquired: false };
+        }
+        throw error;
+    }
+};
+export const pathExists = async (path) => {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch (error) {
+        if (isFileNotFoundError(error)) {
+            return false;
+        }
+        return true;
+    }
+};
+export const readPathMtimeMs = async (path) => {
+    const pathStat = await stat(path);
+    return pathStat.mtimeMs;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-agent",
-  "version": "3.11.0",
+  "version": "3.12.0",
   "description": "Allure Agent Plugin – AI-friendly markdown report generator",
   "keywords": [
     "agent",
@@ -31,12 +31,12 @@
     "lint:fix": "yarn run -T oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.11.0",
-    "@allurereport/plugin-api": "3.11.0",
+    "@allurereport/core-api": "3.12.0",
+    "@allurereport/plugin-api": "3.12.0",
     "yaml": "^2.8.1"
   },
   "devDependencies": {
-    "@allurereport/reader-api": "3.11.0",
+    "@allurereport/reader-api": "3.12.0",
     "@types/node": "^20",
     "@vitest/runner": "^2",
     "allure-js-commons": "^3",