silentlake 3.0.0

package/dist/policy-CpkbSAfm.js

@@ -0,0 +1,60 @@
+import { i as evaluateSenderGroupAccessForPolicy } from "./group-access-DJZrYPx1.js";
+import { i as normalizeFeishuTarget } from "./runtime-B66W9flm.js";
+//#region extensions/feishu/src/policy.ts
+function normalizeFeishuAllowEntry(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return "";
+	if (trimmed === "*") return "*";
+	const withoutProviderPrefix = trimmed.replace(/^feishu:/i, "");
+	return (normalizeFeishuTarget(withoutProviderPrefix) ?? withoutProviderPrefix).trim().toLowerCase();
+}
+function resolveFeishuAllowlistMatch(params) {
+	const allowFrom = params.allowFrom.map((entry) => normalizeFeishuAllowEntry(String(entry))).filter(Boolean);
+	if (allowFrom.length === 0) return { allowed: false };
+	if (allowFrom.includes("*")) return {
+		allowed: true,
+		matchKey: "*",
+		matchSource: "wildcard"
+	};
+	const senderCandidates = [params.senderId, ...params.senderIds ?? []].map((entry) => normalizeFeishuAllowEntry(String(entry ?? ""))).filter(Boolean);
+	for (const senderId of senderCandidates) if (allowFrom.includes(senderId)) return {
+		allowed: true,
+		matchKey: senderId,
+		matchSource: "id"
+	};
+	return { allowed: false };
+}
+function resolveFeishuGroupConfig(params) {
+	const groups = params.cfg?.groups ?? {};
+	const wildcard = groups["*"];
+	const groupId = params.groupId?.trim();
+	if (!groupId) return;
+	const direct = groups[groupId];
+	if (direct) return direct;
+	const lowered = groupId.toLowerCase();
+	const matchKey = Object.keys(groups).find((key) => key.toLowerCase() === lowered);
+	if (matchKey) return groups[matchKey];
+	return wildcard;
+}
+function resolveFeishuGroupToolPolicy(params) {
+	const cfg = params.cfg.channels?.feishu;
+	if (!cfg) return;
+	return resolveFeishuGroupConfig({
+		cfg,
+		groupId: params.groupId
+	})?.tools;
+}
+function isFeishuGroupAllowed(params) {
+	return evaluateSenderGroupAccessForPolicy({
+		groupPolicy: params.groupPolicy === "allowall" ? "open" : params.groupPolicy,
+		groupAllowFrom: params.allowFrom.map((entry) => String(entry)),
+		senderId: params.senderId,
+		isSenderAllowed: () => resolveFeishuAllowlistMatch(params).allowed
+	}).allowed;
+}
+function resolveFeishuReplyPolicy(params) {
+	if (params.isDirectMessage) return { requireMention: false };
+	return { requireMention: params.groupConfig?.requireMention ?? params.globalConfig?.requireMention ?? true };
+}
+//#endregion
+export { resolveFeishuReplyPolicy as a, resolveFeishuGroupToolPolicy as i, resolveFeishuAllowlistMatch as n, resolveFeishuGroupConfig as r, isFeishuGroupAllowed as t };

package/dist/polls-B2VH7SN9.js

@@ -0,0 +1,35 @@
+//#region src/polls.ts
+function resolvePollMaxSelections(optionCount, allowMultiselect) {
+	return allowMultiselect ? Math.max(2, optionCount) : 1;
+}
+function normalizePollInput(input, options = {}) {
+	const question = input.question.trim();
+	if (!question) throw new Error("Poll question is required");
+	const cleaned = (input.options ?? []).map((option) => option.trim()).filter(Boolean);
+	if (cleaned.length < 2) throw new Error("Poll requires at least 2 options");
+	if (options.maxOptions !== void 0 && cleaned.length > options.maxOptions) throw new Error(`Poll supports at most ${options.maxOptions} options`);
+	const maxSelectionsRaw = input.maxSelections;
+	const maxSelections = typeof maxSelectionsRaw === "number" && Number.isFinite(maxSelectionsRaw) ? Math.floor(maxSelectionsRaw) : 1;
+	if (maxSelections < 1) throw new Error("maxSelections must be at least 1");
+	if (maxSelections > cleaned.length) throw new Error("maxSelections cannot exceed option count");
+	const durationSecondsRaw = input.durationSeconds;
+	const durationSeconds = typeof durationSecondsRaw === "number" && Number.isFinite(durationSecondsRaw) ? Math.floor(durationSecondsRaw) : void 0;
+	if (durationSeconds !== void 0 && durationSeconds < 1) throw new Error("durationSeconds must be at least 1");
+	const durationRaw = input.durationHours;
+	const durationHours = typeof durationRaw === "number" && Number.isFinite(durationRaw) ? Math.floor(durationRaw) : void 0;
+	if (durationHours !== void 0 && durationHours < 1) throw new Error("durationHours must be at least 1");
+	if (durationSeconds !== void 0 && durationHours !== void 0) throw new Error("durationSeconds and durationHours are mutually exclusive");
+	return {
+		question,
+		options: cleaned,
+		maxSelections,
+		durationSeconds,
+		durationHours
+	};
+}
+function normalizePollDurationHours(value, options) {
+	const base = typeof value === "number" && Number.isFinite(value) ? Math.floor(value) : options.defaultHours;
+	return Math.min(Math.max(base, 1), options.maxHours);
+}
+//#endregion
+export { normalizePollInput as n, resolvePollMaxSelections as r, normalizePollDurationHours as t };

package/dist/ports-BjWuIIQw.js

@@ -0,0 +1,262 @@
+import { C as sleep } from "./utils-Bxk6BLTg.js";
+import { n as resolveLsofCommandSync } from "./ports-lsof-DtJqhFOr.js";
+import { t as tryListenOnPort } from "./ports-probe-BQqp8l8E.js";
+import { execFileSync } from "node:child_process";
+import { createServer } from "node:net";
+//#region src/cli/ports.ts
+const FUSER_SIGNALS = {
+	SIGTERM: "TERM",
+	SIGKILL: "KILL"
+};
+function readExecOutput(value) {
+	if (typeof value === "string") return value;
+	if (value instanceof Buffer) return value.toString("utf8");
+	return "";
+}
+function withErrnoCode(message, code, cause) {
+	const out = new Error(message, { cause: cause instanceof Error ? cause : void 0 });
+	out.code = code;
+	return out;
+}
+function getErrnoCode(err) {
+	if (!err || typeof err !== "object") return;
+	const direct = err.code;
+	if (typeof direct === "string" && direct.length > 0) return direct;
+	const cause = err.cause;
+	if (cause && typeof cause === "object") {
+		const nested = cause.code;
+		if (typeof nested === "string" && nested.length > 0) return nested;
+	}
+}
+function isRecoverableLsofError(err) {
+	const code = getErrnoCode(err);
+	if (code === "ENOENT" || code === "EACCES" || code === "EPERM") return true;
+	const message = err instanceof Error ? err.message : String(err);
+	return /lsof.*(permission denied|not permitted|operation not permitted|eacces|eperm)/i.test(message);
+}
+function parseFuserPidList(output) {
+	if (!output) return [];
+	const values = /* @__PURE__ */ new Set();
+	for (const rawLine of output.split(/\r?\n/)) {
+		const line = rawLine.trim();
+		if (!line) continue;
+		const pidMatches = (line.includes(":") ? line.slice(line.indexOf(":") + 1) : line).match(/\d+/g) ?? [];
+		for (const match of pidMatches) {
+			const pid = Number.parseInt(match, 10);
+			if (Number.isFinite(pid) && pid > 0) values.add(pid);
+		}
+	}
+	return [...values];
+}
+function killPortWithFuser(port, signal) {
+	const args = [
+		"-k",
+		`-${FUSER_SIGNALS[signal]}`,
+		`${port}/tcp`
+	];
+	try {
+		return parseFuserPidList(execFileSync("fuser", args, {
+			encoding: "utf-8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		})).map((pid) => ({ pid }));
+	} catch (err) {
+		const execErr = err;
+		const code = execErr.code;
+		const status = execErr.status;
+		const parsed = parseFuserPidList([readExecOutput(execErr.stdout), readExecOutput(execErr.stderr)].filter(Boolean).join("\n"));
+		if (status === 1) return parsed.map((pid) => ({ pid }));
+		if (code === "ENOENT") throw withErrnoCode("fuser not found; required for --force when lsof is unavailable", "ENOENT", err);
+		if (code === "EACCES" || code === "EPERM") throw withErrnoCode("fuser permission denied while forcing gateway port", code, err);
+		throw err instanceof Error ? err : new Error(String(err));
+	}
+}
+async function isPortBusy(port) {
+	try {
+		await tryListenOnPort({
+			port,
+			exclusive: true
+		});
+		return false;
+	} catch (err) {
+		if (err.code === "EADDRINUSE") return true;
+		throw err instanceof Error ? err : new Error(String(err));
+	}
+}
+function parseLsofOutput(output) {
+	const lines = output.split(/\r?\n/).filter(Boolean);
+	const results = [];
+	let current = {};
+	for (const line of lines) if (line.startsWith("p")) {
+		if (current.pid) results.push(current);
+		current = { pid: Number.parseInt(line.slice(1), 10) };
+	} else if (line.startsWith("c")) current.command = line.slice(1);
+	if (current.pid) results.push(current);
+	return results;
+}
+function listPortListeners(port) {
+	if (process.platform === "win32") try {
+		const lines = execFileSync("netstat", [
+			"-ano",
+			"-p",
+			"TCP"
+		], { encoding: "utf-8" }).split(/\r?\n/).filter(Boolean);
+		const results = [];
+		for (const line of lines) {
+			const parts = line.trim().split(/\s+/);
+			if (parts.length >= 5 && parts[3] === "LISTENING") {
+				if (parts[1].split(":").pop() === String(port)) {
+					const pid = Number.parseInt(parts[4], 10);
+					if (!Number.isNaN(pid) && pid > 0) {
+						if (!results.some((p) => p.pid === pid)) results.push({ pid });
+					}
+				}
+			}
+		}
+		return results;
+	} catch (err) {
+		throw new Error(`netstat failed: ${String(err)}`, { cause: err });
+	}
+	try {
+		return parseLsofOutput(execFileSync(resolveLsofCommandSync(), [
+			"-nP",
+			`-iTCP:${port}`,
+			"-sTCP:LISTEN",
+			"-FpFc"
+		], { encoding: "utf-8" }));
+	} catch (err) {
+		const execErr = err;
+		const status = execErr.status ?? void 0;
+		const code = execErr.code;
+		if (code === "ENOENT") throw withErrnoCode("lsof not found; required for --force", "ENOENT", err);
+		if (code === "EACCES" || code === "EPERM") throw withErrnoCode("lsof permission denied while inspecting gateway port", code, err);
+		if (status === 1) {
+			const stderr = readExecOutput(execErr.stderr).trim();
+			if (stderr && /permission denied|not permitted|operation not permitted|can't stat/i.test(stderr)) throw withErrnoCode(`lsof permission denied while inspecting gateway port: ${stderr}`, "EACCES", err);
+			return [];
+		}
+		throw err instanceof Error ? err : new Error(String(err));
+	}
+}
+function forceFreePort(port) {
+	const listeners = listPortListeners(port);
+	for (const proc of listeners) try {
+		process.kill(proc.pid, "SIGTERM");
+	} catch (err) {
+		throw new Error(`failed to kill pid ${proc.pid}${proc.command ? ` (${proc.command})` : ""}: ${String(err)}`, { cause: err });
+	}
+	return listeners;
+}
+function killPids(listeners, signal) {
+	for (const proc of listeners) try {
+		process.kill(proc.pid, signal);
+	} catch (err) {
+		throw new Error(`failed to kill pid ${proc.pid}${proc.command ? ` (${proc.command})` : ""}: ${String(err)}`, { cause: err });
+	}
+}
+async function forceFreePortAndWait(port, opts = {}) {
+	const timeoutMs = Math.max(opts.timeoutMs ?? 1500, 0);
+	const intervalMs = Math.max(opts.intervalMs ?? 100, 1);
+	const sigtermTimeoutMs = Math.min(Math.max(opts.sigtermTimeoutMs ?? 600, 0), timeoutMs);
+	let killed = [];
+	let useFuserFallback = false;
+	try {
+		killed = forceFreePort(port);
+	} catch (err) {
+		if (!isRecoverableLsofError(err)) throw err;
+		useFuserFallback = true;
+		killed = killPortWithFuser(port, "SIGTERM");
+	}
+	const checkBusy = async () => useFuserFallback ? isPortBusy(port) : listPortListeners(port).length > 0;
+	if (!await checkBusy()) return {
+		killed,
+		waitedMs: 0,
+		escalatedToSigkill: false
+	};
+	let waitedMs = 0;
+	const triesSigterm = intervalMs > 0 ? Math.ceil(sigtermTimeoutMs / intervalMs) : 0;
+	for (let i = 0; i < triesSigterm; i++) {
+		if (!await checkBusy()) return {
+			killed,
+			waitedMs,
+			escalatedToSigkill: false
+		};
+		await sleep(intervalMs);
+		waitedMs += intervalMs;
+	}
+	if (!await checkBusy()) return {
+		killed,
+		waitedMs,
+		escalatedToSigkill: false
+	};
+	if (useFuserFallback) killPortWithFuser(port, "SIGKILL");
+	else killPids(listPortListeners(port), "SIGKILL");
+	const remainingBudget = Math.max(timeoutMs - waitedMs, 0);
+	const triesSigkill = intervalMs > 0 ? Math.ceil(remainingBudget / intervalMs) : 0;
+	for (let i = 0; i < triesSigkill; i++) {
+		if (!await checkBusy()) return {
+			killed,
+			waitedMs,
+			escalatedToSigkill: true
+		};
+		await sleep(intervalMs);
+		waitedMs += intervalMs;
+	}
+	if (!await checkBusy()) return {
+		killed,
+		waitedMs,
+		escalatedToSigkill: true
+	};
+	if (useFuserFallback) throw new Error(`port ${port} still has listeners after --force (fuser fallback)`);
+	const still = listPortListeners(port);
+	throw new Error(`port ${port} still has listeners after --force: ${still.map((p) => p.pid).join(", ")}`);
+}
+/**
+* Attempt a real TCP bind to verify the port is available at the OS level.
+* Catches TIME_WAIT / kernel-level holds that lsof won't show.
+*
+* Resolves false only for EADDRINUSE — a genuinely transient condition
+* (port still in TIME_WAIT after a --force kill) that the caller should retry.
+*
+* All other errors are non-retryable and are rejected immediately:
+* - EADDRNOTAVAIL: the host address doesn't exist on any local interface
+*   (hard misconfiguration, not a transient kernel hold).
+* - EACCES: bind to a privileged port as non-root.
+* - EINVAL, etc.: other unrecoverable OS errors.
+*/
+function probePortFree(port, host = "0.0.0.0") {
+	return new Promise((resolve, reject) => {
+		const srv = createServer();
+		srv.unref();
+		srv.once("error", (err) => {
+			srv.close();
+			if (err.code === "EADDRINUSE") resolve(false);
+			else reject(err);
+		});
+		srv.listen(port, host, () => {
+			srv.close(() => resolve(true));
+		});
+	});
+}
+/**
+* Poll until a real test-bind succeeds, up to `timeoutMs`.
+* Returns the number of ms waited, or throws if the port never freed.
+*/
+async function waitForPortBindable(port, opts = {}) {
+	const timeoutMs = Math.max(opts.timeoutMs ?? 3e3, 0);
+	const intervalMs = Math.max(opts.intervalMs ?? 150, 1);
+	const host = opts.host;
+	let waited = 0;
+	while (waited < timeoutMs) {
+		if (await probePortFree(port, host)) return waited;
+		await sleep(intervalMs);
+		waited += intervalMs;
+	}
+	if (await probePortFree(port, host)) return waited;
+	throw new Error(`port ${port} still not bindable after ${waited}ms (TIME_WAIT or kernel hold)`);
+}
+//#endregion
+export { forceFreePortAndWait as n, waitForPortBindable as r, forceFreePort as t };