import fs from "node:fs/promises";

import os from "node:os";

import path from "node:path";

import { MAX_TIMER_TIMEOUT_MS } from "@openclaw/normalization-core/number-coercion";

import { afterEach, describe, expect, it, vi } from "vitest";

import { resolveSessionTranscriptPathInDir } from "../../../config/sessions/paths.js";

import {

symlinkOwner.release();

});

it("clamps oversized session file owner wait timeouts before arming timers", async () => {

const sessionFile = await createTempSessionFile();

const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");

const firstOwner = await acquireEmbeddedAttemptSessionFileOwner({ sessionFile });

const secondOwnerPromise = acquireEmbeddedAttemptSessionFileOwner({

sessionFile,

timeoutMs: MAX_TIMER_TIMEOUT_MS + 1,

});

await Promise.resolve();

expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), MAX_TIMER_TIMEOUT_MS);

firstOwner.release();

const secondOwner = await secondOwnerPromise;

secondOwner.release();

});

it("releases the coarse attempt lock before prompt submission and reacquires for cleanup", async () => {

const releases: string[] = [];

const acquireSessionWriteLockLocal28 = vi

import { createReadStream, readFileSync, statSync } from "node:fs";

import fs from "node:fs/promises";

import { isDeepStrictEqual } from "node:util";

import { clampTimerTimeoutMs } from "@openclaw/normalization-core/number-coercion";

import { normalizeStringEntries } from "@openclaw/normalization-core/string-normalization";

import {

type OwnedSessionTranscriptPublishedEntry,

return abortReason(signal) ?? new Error("operation aborted", { cause: signal });

}

function resolveSessionFileOwnerWaitTimeoutMs(timeoutMs: number | undefined): number | undefined {

if (timeoutMs === undefined) {

return undefined;

}

return clampTimerTimeoutMs(timeoutMs);

}

function waitForSessionFileOwnerRelease(params: {

sessionFile: string;

entry: SessionFileOwnerEntry;

cleanup();

reject(toLintErrorObject(error, "Non-Error rejection"));

};

if (params.timeoutMs !== undefined && Number.isFinite(params.timeoutMs)) {

const timeoutMs = resolveSessionFileOwnerWaitTimeoutMs(params.timeoutMs);

if (timeoutMs !== undefined) {

waiter.timer = setTimeout(

() => {

waiter.reject(

new EmbeddedAttemptSessionFileOwnerTimeoutError(

params.sessionFile,

params.timeoutMs ?? 0,

timeoutMs,

),

);

},

Math.max(1, Math.floor(params.timeoutMs)),

timeoutMs,

);

waiter.timer.unref?.();

}