@ericsanchezok/synergy-util 3.0.11 → 3.0.12

package/dist/fs-lock.d.ts

@@ -0,0 +1,13 @@
+export interface FileLockOptions {
+    directory: string;
+    key: string;
+    retryMs?: number;
+    timeoutMs?: number;
+    staleMetadataMs?: number;
+    timeoutMessage?: string;
+}
+export declare const HOLOS_ACCOUNTS_WRITE_LOCK_KEY = "holos-accounts:write";
+export declare const LEGACY_API_KEY_WRITE_LOCK_KEY = "legacy-api-key:write";
+export declare function authLockDirectory(synergyRoot: string): string;
+export declare function fileLockPath(directory: string, key: string): string;
+export declare function withFileLock<T>(options: FileLockOptions, fn: () => Promise<T>): Promise<T>;

package/dist/fs-lock.js

@@ -0,0 +1,100 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+const DEFAULT_RETRY_MS = 25;
+const DEFAULT_TIMEOUT_MS = 60_000;
+const DEFAULT_STALE_METADATA_MS = 5_000;
+export const HOLOS_ACCOUNTS_WRITE_LOCK_KEY = "holos-accounts:write";
+export const LEGACY_API_KEY_WRITE_LOCK_KEY = "legacy-api-key:write";
+export function authLockDirectory(synergyRoot) {
+    return path.join(synergyRoot, "data", "auth", ".locks");
+}
+export function fileLockPath(directory, key) {
+    const digest = createHash("sha256").update(key).digest("hex");
+    return path.join(directory, `${digest}.lock`);
+}
+export async function withFileLock(options, fn) {
+    const lock = await acquireFileLock(options);
+    try {
+        return await fn();
+    }
+    finally {
+        await lock.release();
+    }
+}
+async function acquireFileLock(options) {
+    const retryMs = options.retryMs ?? DEFAULT_RETRY_MS;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const staleMetadataMs = options.staleMetadataMs ?? DEFAULT_STALE_METADATA_MS;
+    await fs.mkdir(options.directory, { recursive: true, mode: 0o700 });
+    await fs.chmod(options.directory, 0o700);
+    const filename = fileLockPath(options.directory, options.key);
+    const startedAt = Date.now();
+    while (true) {
+        try {
+            const handle = await fs.open(filename, "wx", 0o600);
+            try {
+                await handle.writeFile(JSON.stringify({ pid: process.pid, acquiredAt: Date.now() }));
+            }
+            catch (error) {
+                await fs.unlink(filename).catch(() => { });
+                throw error;
+            }
+            finally {
+                await handle.close();
+            }
+            return {
+                async release() {
+                    await fs.unlink(filename).catch((error) => {
+                        if (error.code !== "ENOENT")
+                            throw error;
+                    });
+                },
+            };
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            const owner = await readLockOwner(filename);
+            if (owner?.pid && !processExists(owner.pid)) {
+                await fs.unlink(filename).catch(() => { });
+                continue;
+            }
+            if (!owner?.pid) {
+                const stat = await fs.stat(filename).catch(() => undefined);
+                if (stat && Date.now() - stat.mtimeMs > staleMetadataMs) {
+                    await fs.unlink(filename).catch(() => { });
+                    continue;
+                }
+            }
+            if (Date.now() - startedAt >= timeoutMs) {
+                throw new Error(options.timeoutMessage ?? `Timed out acquiring file lock for ${options.key}`);
+            }
+            await sleep(retryMs);
+        }
+    }
+}
+async function readLockOwner(filename) {
+    try {
+        const owner = JSON.parse(await fs.readFile(filename, "utf8"));
+        if (!owner || typeof owner !== "object")
+            return undefined;
+        const pid = owner.pid;
+        return typeof pid === "number" ? { pid } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function processExists(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+}
+async function sleep(milliseconds) {
+    await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}

package/dist/plugin-policy.d.ts

@@ -10,6 +10,11 @@ export interface RuntimeLimits {
     heartbeatIntervalMs: number;
     maxMemoryMb: number;
     memorySampleIntervalMs: number;
+    agentCallMaxRuntimeMs: number;
+    hookTimeoutMs: number;
+    contributionInvokeTimeoutMs: number;
+    shellRunTimeoutMs: number;
+    taskRunWaitTimeoutMs: number;
 }
 export type RuntimeLimitOverrides = Partial<RuntimeLimits>;
 export interface PluginRuntimePolicyInput {

package/dist/plugin-policy.js

@@ -8,6 +8,11 @@ export const DEFAULT_PLUGIN_RUNTIME_LIMITS = {
     heartbeatIntervalMs: 5_000,
     maxMemoryMb: 512,
     memorySampleIntervalMs: 5_000,
+    agentCallMaxRuntimeMs: 120_000,
+    hookTimeoutMs: 120_000,
+    contributionInvokeTimeoutMs: 120_000,
+    shellRunTimeoutMs: 120_000,
+    taskRunWaitTimeoutMs: 120_000,
 };
 export function resolveRuntimeMode(input) {
     return input.source === "builtin" ? "inProcess" : "process";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericsanchezok/synergy-util",
-  "version": "3.0.11",
+  "version": "3.0.12",
   "type": "module",
   "license": "MIT",
   "exports": {