remoteclaw 0.1.0-next.cd6ddde → 0.1.0-next.cf9ccbe

package/dist/fetch-DRVdxxEj.js

@@ -1,67 +0,0 @@
-import { t as bindAbortRelay } from "./fetch-timeout-l_6RdoMw.js";
-
-//#region src/infra/fetch.ts
-const wrapFetchWithAbortSignalMarker = Symbol.for("remoteclaw.fetch.abort-signal-wrapped");
-function withDuplex(init, input) {
-	const hasInitBody = init?.body != null;
-	const hasRequestBody = !hasInitBody && typeof Request !== "undefined" && input instanceof Request && input.body != null;
-	if (!hasInitBody && !hasRequestBody) return init;
-	if (init && "duplex" in init) return init;
-	return init ? {
-		...init,
-		duplex: "half"
-	} : { duplex: "half" };
-}
-function wrapFetchWithAbortSignal(fetchImpl) {
-	if (fetchImpl[wrapFetchWithAbortSignalMarker]) return fetchImpl;
-	const wrapped = ((input, init) => {
-		const patchedInit = withDuplex(init, input);
-		const signal = patchedInit?.signal;
-		if (!signal) return fetchImpl(input, patchedInit);
-		if (typeof AbortSignal !== "undefined" && signal instanceof AbortSignal) return fetchImpl(input, patchedInit);
-		if (typeof AbortController === "undefined") return fetchImpl(input, patchedInit);
-		if (typeof signal.addEventListener !== "function") return fetchImpl(input, patchedInit);
-		const controller = new AbortController();
-		const onAbort = bindAbortRelay(controller);
-		let listenerAttached = false;
-		if (signal.aborted) controller.abort();
-		else {
-			signal.addEventListener("abort", onAbort, { once: true });
-			listenerAttached = true;
-		}
-		const cleanup = () => {
-			if (!listenerAttached || typeof signal.removeEventListener !== "function") return;
-			listenerAttached = false;
-			try {
-				signal.removeEventListener("abort", onAbort);
-			} catch {}
-		};
-		try {
-			return fetchImpl(input, {
-				...patchedInit,
-				signal: controller.signal
-			}).finally(cleanup);
-		} catch (error) {
-			cleanup();
-			throw error;
-		}
-	});
-	const wrappedFetch = Object.assign(wrapped, fetchImpl);
-	const fetchWithPreconnect = fetchImpl;
-	wrappedFetch.preconnect = typeof fetchWithPreconnect.preconnect === "function" ? fetchWithPreconnect.preconnect.bind(fetchWithPreconnect) : () => {};
-	Object.defineProperty(wrappedFetch, wrapFetchWithAbortSignalMarker, {
-		value: true,
-		enumerable: false,
-		configurable: false,
-		writable: false
-	});
-	return wrappedFetch;
-}
-function resolveFetch(fetchImpl) {
-	const resolved = fetchImpl ?? globalThis.fetch;
-	if (!resolved) return;
-	return wrapFetchWithAbortSignal(resolved);
-}
-
-//#endregion
-export { wrapFetchWithAbortSignal as n, resolveFetch as t };

package/dist/file-lock-6NXMPZTT.js

@@ -1,107 +0,0 @@
-import { n as isPidAlive, t as resolveProcessScopedMap } from "./process-scoped-map-BwUkYFQV.js";
-import path from "node:path";
-import fs from "node:fs/promises";
-
-//#region src/plugin-sdk/file-lock.ts
-const HELD_LOCKS = resolveProcessScopedMap(Symbol.for("remoteclaw.fileLockHeldLocks"));
-function computeDelayMs(retries, attempt) {
-	const base = Math.min(retries.maxTimeout, Math.max(retries.minTimeout, retries.minTimeout * retries.factor ** attempt));
-	const jitter = retries.randomize ? 1 + Math.random() : 1;
-	return Math.min(retries.maxTimeout, Math.round(base * jitter));
-}
-async function readLockPayload(lockPath) {
-	try {
-		const raw = await fs.readFile(lockPath, "utf8");
-		const parsed = JSON.parse(raw);
-		if (typeof parsed.pid !== "number" || typeof parsed.createdAt !== "string") return null;
-		return {
-			pid: parsed.pid,
-			createdAt: parsed.createdAt
-		};
-	} catch {
-		return null;
-	}
-}
-async function resolveNormalizedFilePath(filePath) {
-	const resolved = path.resolve(filePath);
-	const dir = path.dirname(resolved);
-	await fs.mkdir(dir, { recursive: true });
-	try {
-		const realDir = await fs.realpath(dir);
-		return path.join(realDir, path.basename(resolved));
-	} catch {
-		return resolved;
-	}
-}
-async function isStaleLock(lockPath, staleMs) {
-	const payload = await readLockPayload(lockPath);
-	if (payload?.pid && !isPidAlive(payload.pid)) return true;
-	if (payload?.createdAt) {
-		const createdAt = Date.parse(payload.createdAt);
-		if (!Number.isFinite(createdAt) || Date.now() - createdAt > staleMs) return true;
-	}
-	try {
-		const stat = await fs.stat(lockPath);
-		return Date.now() - stat.mtimeMs > staleMs;
-	} catch {
-		return true;
-	}
-}
-async function releaseHeldLock(normalizedFile) {
-	const current = HELD_LOCKS.get(normalizedFile);
-	if (!current) return;
-	current.count -= 1;
-	if (current.count > 0) return;
-	HELD_LOCKS.delete(normalizedFile);
-	await current.handle.close().catch(() => void 0);
-	await fs.rm(current.lockPath, { force: true }).catch(() => void 0);
-}
-async function acquireFileLock(filePath, options) {
-	const normalizedFile = await resolveNormalizedFilePath(filePath);
-	const lockPath = `${normalizedFile}.lock`;
-	const held = HELD_LOCKS.get(normalizedFile);
-	if (held) {
-		held.count += 1;
-		return {
-			lockPath,
-			release: () => releaseHeldLock(normalizedFile)
-		};
-	}
-	const attempts = Math.max(1, options.retries.retries + 1);
-	for (let attempt = 0; attempt < attempts; attempt += 1) try {
-		const handle = await fs.open(lockPath, "wx");
-		await handle.writeFile(JSON.stringify({
-			pid: process.pid,
-			createdAt: (/* @__PURE__ */ new Date()).toISOString()
-		}, null, 2), "utf8");
-		HELD_LOCKS.set(normalizedFile, {
-			count: 1,
-			handle,
-			lockPath
-		});
-		return {
-			lockPath,
-			release: () => releaseHeldLock(normalizedFile)
-		};
-	} catch (err) {
-		if (err.code !== "EEXIST") throw err;
-		if (await isStaleLock(lockPath, options.stale)) {
-			await fs.rm(lockPath, { force: true }).catch(() => void 0);
-			continue;
-		}
-		if (attempt >= attempts - 1) break;
-		await new Promise((resolve) => setTimeout(resolve, computeDelayMs(options.retries, attempt)));
-	}
-	throw new Error(`file lock timeout for ${normalizedFile}`);
-}
-async function withFileLock(filePath, options, fn) {
-	const lock = await acquireFileLock(filePath, options);
-	try {
-		return await fn();
-	} finally {
-		await lock.release();
-	}
-}
-
-//#endregion
-export { withFileLock as t };

package/dist/file-lock-C_KRlR7M.js

@@ -1,107 +0,0 @@
-import { n as isPidAlive, t as resolveProcessScopedMap } from "./process-scoped-map-_zxf_kLz.js";
-import path from "node:path";
-import fsp from "node:fs/promises";
-
-//#region src/plugin-sdk/file-lock.ts
-const HELD_LOCKS = resolveProcessScopedMap(Symbol.for("remoteclaw.fileLockHeldLocks"));
-function computeDelayMs(retries, attempt) {
-	const base = Math.min(retries.maxTimeout, Math.max(retries.minTimeout, retries.minTimeout * retries.factor ** attempt));
-	const jitter = retries.randomize ? 1 + Math.random() : 1;
-	return Math.min(retries.maxTimeout, Math.round(base * jitter));
-}
-async function readLockPayload(lockPath) {
-	try {
-		const raw = await fsp.readFile(lockPath, "utf8");
-		const parsed = JSON.parse(raw);
-		if (typeof parsed.pid !== "number" || typeof parsed.createdAt !== "string") return null;
-		return {
-			pid: parsed.pid,
-			createdAt: parsed.createdAt
-		};
-	} catch {
-		return null;
-	}
-}
-async function resolveNormalizedFilePath(filePath) {
-	const resolved = path.resolve(filePath);
-	const dir = path.dirname(resolved);
-	await fsp.mkdir(dir, { recursive: true });
-	try {
-		const realDir = await fsp.realpath(dir);
-		return path.join(realDir, path.basename(resolved));
-	} catch {
-		return resolved;
-	}
-}
-async function isStaleLock(lockPath, staleMs) {
-	const payload = await readLockPayload(lockPath);
-	if (payload?.pid && !isPidAlive(payload.pid)) return true;
-	if (payload?.createdAt) {
-		const createdAt = Date.parse(payload.createdAt);
-		if (!Number.isFinite(createdAt) || Date.now() - createdAt > staleMs) return true;
-	}
-	try {
-		const stat = await fsp.stat(lockPath);
-		return Date.now() - stat.mtimeMs > staleMs;
-	} catch {
-		return true;
-	}
-}
-async function releaseHeldLock(normalizedFile) {
-	const current = HELD_LOCKS.get(normalizedFile);
-	if (!current) return;
-	current.count -= 1;
-	if (current.count > 0) return;
-	HELD_LOCKS.delete(normalizedFile);
-	await current.handle.close().catch(() => void 0);
-	await fsp.rm(current.lockPath, { force: true }).catch(() => void 0);
-}
-async function acquireFileLock(filePath, options) {
-	const normalizedFile = await resolveNormalizedFilePath(filePath);
-	const lockPath = `${normalizedFile}.lock`;
-	const held = HELD_LOCKS.get(normalizedFile);
-	if (held) {
-		held.count += 1;
-		return {
-			lockPath,
-			release: () => releaseHeldLock(normalizedFile)
-		};
-	}
-	const attempts = Math.max(1, options.retries.retries + 1);
-	for (let attempt = 0; attempt < attempts; attempt += 1) try {
-		const handle = await fsp.open(lockPath, "wx");
-		await handle.writeFile(JSON.stringify({
-			pid: process.pid,
-			createdAt: (/* @__PURE__ */ new Date()).toISOString()
-		}, null, 2), "utf8");
-		HELD_LOCKS.set(normalizedFile, {
-			count: 1,
-			handle,
-			lockPath
-		});
-		return {
-			lockPath,
-			release: () => releaseHeldLock(normalizedFile)
-		};
-	} catch (err) {
-		if (err.code !== "EEXIST") throw err;
-		if (await isStaleLock(lockPath, options.stale)) {
-			await fsp.rm(lockPath, { force: true }).catch(() => void 0);
-			continue;
-		}
-		if (attempt >= attempts - 1) break;
-		await new Promise((resolve) => setTimeout(resolve, computeDelayMs(options.retries, attempt)));
-	}
-	throw new Error(`file lock timeout for ${normalizedFile}`);
-}
-async function withFileLock(filePath, options, fn) {
-	const lock = await acquireFileLock(filePath, options);
-	try {
-		return await fn();
-	} finally {
-		await lock.release();
-	}
-}
-
-//#endregion
-export { withFileLock as t };

package/dist/fs-safe-DZHpH7TI.js

@@ -1,98 +0,0 @@
-import { n as isPathInside, r as isSymlinkOpenError, t as isNotFoundPathError } from "./path-guards-DOpzcMXz.js";
-import { constants } from "node:fs";
-import path from "node:path";
-import fs$1 from "node:fs/promises";
-
-//#region src/infra/file-identity.ts
-function isZero(value) {
-	return value === 0 || value === 0n;
-}
-function sameFileIdentity(left, right, platform = process.platform) {
-	if (left.ino !== right.ino) return false;
-	if (left.dev === right.dev) return true;
-	return platform === "win32" && (isZero(left.dev) || isZero(right.dev));
-}
-
-//#endregion
-//#region src/infra/fs-safe.ts
-var SafeOpenError = class extends Error {
-	constructor(code, message, options) {
-		super(message, options);
-		this.code = code;
-		this.name = "SafeOpenError";
-	}
-};
-const SUPPORTS_NOFOLLOW = process.platform !== "win32" && "O_NOFOLLOW" in constants;
-const OPEN_READ_FLAGS = constants.O_RDONLY | (SUPPORTS_NOFOLLOW ? constants.O_NOFOLLOW : 0);
-const ensureTrailingSep = (value) => value.endsWith(path.sep) ? value : value + path.sep;
-async function openVerifiedLocalFile(filePath) {
-	let handle;
-	try {
-		handle = await fs$1.open(filePath, OPEN_READ_FLAGS);
-	} catch (err) {
-		if (isNotFoundPathError(err)) throw new SafeOpenError("not-found", "file not found");
-		if (isSymlinkOpenError(err)) throw new SafeOpenError("symlink", "symlink open blocked", { cause: err });
-		throw err;
-	}
-	try {
-		const [stat, lstat] = await Promise.all([handle.stat(), fs$1.lstat(filePath)]);
-		if (lstat.isSymbolicLink()) throw new SafeOpenError("symlink", "symlink not allowed");
-		if (!stat.isFile()) throw new SafeOpenError("not-file", "not a file");
-		if (!sameFileIdentity(stat, lstat)) throw new SafeOpenError("path-mismatch", "path changed during read");
-		const realPath = await fs$1.realpath(filePath);
-		if (!sameFileIdentity(stat, await fs$1.stat(realPath))) throw new SafeOpenError("path-mismatch", "path mismatch");
-		return {
-			handle,
-			realPath,
-			stat
-		};
-	} catch (err) {
-		await handle.close().catch(() => {});
-		if (err instanceof SafeOpenError) throw err;
-		if (isNotFoundPathError(err)) throw new SafeOpenError("not-found", "file not found");
-		throw err;
-	}
-}
-async function openFileWithinRoot(params) {
-	let rootReal;
-	try {
-		rootReal = await fs$1.realpath(params.rootDir);
-	} catch (err) {
-		if (isNotFoundPathError(err)) throw new SafeOpenError("not-found", "root dir not found");
-		throw err;
-	}
-	const rootWithSep = ensureTrailingSep(rootReal);
-	const resolved = path.resolve(rootWithSep, params.relativePath);
-	if (!isPathInside(rootWithSep, resolved)) throw new SafeOpenError("invalid-path", "path escapes root");
-	let opened;
-	try {
-		opened = await openVerifiedLocalFile(resolved);
-	} catch (err) {
-		if (err instanceof SafeOpenError) {
-			if (err.code === "not-found") throw err;
-			throw new SafeOpenError("invalid-path", "path is not a regular file under root", { cause: err });
-		}
-		throw err;
-	}
-	if (!isPathInside(rootWithSep, opened.realPath)) {
-		await opened.handle.close().catch(() => {});
-		throw new SafeOpenError("invalid-path", "path escapes root");
-	}
-	return opened;
-}
-async function readLocalFileSafely(params) {
-	const opened = await openVerifiedLocalFile(params.filePath);
-	try {
-		if (params.maxBytes !== void 0 && opened.stat.size > params.maxBytes) throw new SafeOpenError("too-large", `file exceeds limit of ${params.maxBytes} bytes (got ${opened.stat.size})`);
-		return {
-			buffer: await opened.handle.readFile(),
-			realPath: opened.realPath,
-			stat: opened.stat
-		};
-	} finally {
-		await opened.handle.close().catch(() => {});
-	}
-}
-
-//#endregion
-export { sameFileIdentity as i, openFileWithinRoot as n, readLocalFileSafely as r, SafeOpenError as t };

package/dist/fs-safe-vm3JMUkq.js

@@ -1,88 +0,0 @@
-import { t as sameFileIdentity } from "./file-identity-BnGA6wyc.js";
-import { n as isPathInside, r as isSymlinkOpenError, t as isNotFoundPathError } from "./path-guards-DipYoPVw.js";
-import path from "node:path";
-import { constants } from "node:fs";
-import fsp from "node:fs/promises";
-
-//#region src/infra/fs-safe.ts
-var SafeOpenError = class extends Error {
-	constructor(code, message, options) {
-		super(message, options);
-		this.code = code;
-		this.name = "SafeOpenError";
-	}
-};
-const SUPPORTS_NOFOLLOW = process.platform !== "win32" && "O_NOFOLLOW" in constants;
-const OPEN_READ_FLAGS = constants.O_RDONLY | (SUPPORTS_NOFOLLOW ? constants.O_NOFOLLOW : 0);
-const ensureTrailingSep = (value) => value.endsWith(path.sep) ? value : value + path.sep;
-async function openVerifiedLocalFile(filePath) {
-	let handle;
-	try {
-		handle = await fsp.open(filePath, OPEN_READ_FLAGS);
-	} catch (err) {
-		if (isNotFoundPathError(err)) throw new SafeOpenError("not-found", "file not found");
-		if (isSymlinkOpenError(err)) throw new SafeOpenError("symlink", "symlink open blocked", { cause: err });
-		throw err;
-	}
-	try {
-		const [stat, lstat] = await Promise.all([handle.stat(), fsp.lstat(filePath)]);
-		if (lstat.isSymbolicLink()) throw new SafeOpenError("symlink", "symlink not allowed");
-		if (!stat.isFile()) throw new SafeOpenError("not-file", "not a file");
-		if (!sameFileIdentity(stat, lstat)) throw new SafeOpenError("path-mismatch", "path changed during read");
-		const realPath = await fsp.realpath(filePath);
-		if (!sameFileIdentity(stat, await fsp.stat(realPath))) throw new SafeOpenError("path-mismatch", "path mismatch");
-		return {
-			handle,
-			realPath,
-			stat
-		};
-	} catch (err) {
-		await handle.close().catch(() => {});
-		if (err instanceof SafeOpenError) throw err;
-		if (isNotFoundPathError(err)) throw new SafeOpenError("not-found", "file not found");
-		throw err;
-	}
-}
-async function openFileWithinRoot(params) {
-	let rootReal;
-	try {
-		rootReal = await fsp.realpath(params.rootDir);
-	} catch (err) {
-		if (isNotFoundPathError(err)) throw new SafeOpenError("not-found", "root dir not found");
-		throw err;
-	}
-	const rootWithSep = ensureTrailingSep(rootReal);
-	const resolved = path.resolve(rootWithSep, params.relativePath);
-	if (!isPathInside(rootWithSep, resolved)) throw new SafeOpenError("invalid-path", "path escapes root");
-	let opened;
-	try {
-		opened = await openVerifiedLocalFile(resolved);
-	} catch (err) {
-		if (err instanceof SafeOpenError) {
-			if (err.code === "not-found") throw err;
-			throw new SafeOpenError("invalid-path", "path is not a regular file under root", { cause: err });
-		}
-		throw err;
-	}
-	if (!isPathInside(rootWithSep, opened.realPath)) {
-		await opened.handle.close().catch(() => {});
-		throw new SafeOpenError("invalid-path", "path escapes root");
-	}
-	return opened;
-}
-async function readLocalFileSafely(params) {
-	const opened = await openVerifiedLocalFile(params.filePath);
-	try {
-		if (params.maxBytes !== void 0 && opened.stat.size > params.maxBytes) throw new SafeOpenError("too-large", `file exceeds limit of ${params.maxBytes} bytes (got ${opened.stat.size})`);
-		return {
-			buffer: await opened.handle.readFile(),
-			realPath: opened.realPath,
-			stat: opened.stat
-		};
-	} finally {
-		await opened.handle.close().catch(() => {});
-	}
-}
-
-//#endregion
-export { openFileWithinRoot as n, readLocalFileSafely as r, SafeOpenError as t };