@pixelzx/genesis 2026.6.28 → 2026.6.29

package/dist/native-hook-relay-CiXmqOtV.js

@@ -0,0 +1,519 @@
+import { t as createSubsystemLogger } from "./subsystem-CNq69MoE.js";
+import { t as getGlobalHookRunner } from "./hook-runner-global-tqFu1d31.js";
+import { i as PluginApprovalResolutions } from "./types-Dvo8MKe4.js";
+import { p as normalizeToolName } from "./tool-policy-BIGITEMh.js";
+import { i as runBeforeToolCallHook, n as consumeAdjustedParamsForToolCall } from "./pi-tools.before-tool-call-BZ1PLh46.js";
+import { t as callGatewayTool } from "./gateway-BxIfReRV.js";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+//#region src/agents/harness/hook-helpers.ts
+const log$1 = createSubsystemLogger("agents/harness");
+async function runAgentHarnessAfterToolCallHook(params) {
+	const hookRunner = getGlobalHookRunner();
+	if (!hookRunner?.hasHooks("after_tool_call")) return;
+	const adjustedArgs = consumeAdjustedParamsForToolCall(params.toolCallId, params.runId);
+	const eventArgs = adjustedArgs && typeof adjustedArgs === "object" ? adjustedArgs : params.startArgs;
+	try {
+		await hookRunner.runAfterToolCall({
+			toolName: params.toolName,
+			params: eventArgs,
+			...params.runId ? { runId: params.runId } : {},
+			toolCallId: params.toolCallId,
+			...params.result ? { result: params.result } : {},
+			...params.error ? { error: params.error } : {},
+			...params.startedAt != null ? { durationMs: Date.now() - params.startedAt } : {}
+		}, {
+			toolName: params.toolName,
+			...params.agentId ? { agentId: params.agentId } : {},
+			...params.sessionId ? { sessionId: params.sessionId } : {},
+			...params.sessionKey ? { sessionKey: params.sessionKey } : {},
+			...params.runId ? { runId: params.runId } : {},
+			toolCallId: params.toolCallId
+		});
+	} catch (error) {
+		log$1.warn(`after_tool_call hook failed: tool=${params.toolName} error=${String(error)}`);
+	}
+}
+function runAgentHarnessBeforeMessageWriteHook(params) {
+	const hookRunner = getGlobalHookRunner();
+	if (!hookRunner?.hasHooks("before_message_write")) return params.message;
+	const result = hookRunner.runBeforeMessageWrite({ message: params.message }, {
+		...params.agentId ? { agentId: params.agentId } : {},
+		...params.sessionKey ? { sessionKey: params.sessionKey } : {}
+	});
+	if (result?.block) return null;
+	return result?.message ?? params.message;
+}
+//#endregion
+//#region src/agents/harness/native-hook-relay.ts
+const NATIVE_HOOK_RELAY_EVENTS = [
+	"pre_tool_use",
+	"post_tool_use",
+	"permission_request"
+];
+const DEFAULT_RELAY_TTL_MS = 1800 * 1e3;
+const DEFAULT_RELAY_TIMEOUT_MS = 5e3;
+const DEFAULT_PERMISSION_TIMEOUT_MS = 12e4;
+const MAX_NATIVE_HOOK_RELAY_INVOCATIONS = 200;
+const MAX_NATIVE_HOOK_RELAY_JSON_DEPTH = 64;
+const MAX_NATIVE_HOOK_RELAY_JSON_NODES = 2e4;
+const MAX_APPROVAL_TITLE_LENGTH = 80;
+const MAX_APPROVAL_DESCRIPTION_LENGTH = 700;
+const MAX_PERMISSION_APPROVALS_PER_WINDOW = 12;
+const PERMISSION_APPROVAL_WINDOW_MS = 6e4;
+const ANSI_ESCAPE_PATTERN = new RegExp(`${String.fromCharCode(27)}\\[[0-?]*[ -/]*[@-~]`, "g");
+const relays = /* @__PURE__ */ new Map();
+const invocations = [];
+const pendingPermissionApprovals = /* @__PURE__ */ new Map();
+const permissionApprovalWindows = /* @__PURE__ */ new Map();
+const log = createSubsystemLogger("agents/harness/native-hook-relay");
+let nativeHookRelayPermissionApprovalRequester = requestNativeHookRelayPermissionApproval;
+const nativeHookRelayProviderAdapters = { codex: {
+	normalizeMetadata: normalizeCodexHookMetadata,
+	readToolInput: readCodexToolInput,
+	readToolResponse: readCodexToolResponse,
+	renderNoopResponse: () => {
+		return {
+			stdout: "",
+			stderr: "",
+			exitCode: 0
+		};
+	},
+	renderPreToolUseBlockResponse: (reason) => ({
+		stdout: `${JSON.stringify({ hookSpecificOutput: {
+			hookEventName: "PreToolUse",
+			permissionDecision: "deny",
+			permissionDecisionReason: reason
+		} })}\n`,
+		stderr: "",
+		exitCode: 0
+	}),
+	renderPermissionDecisionResponse: (decision, message) => ({
+		stdout: `${JSON.stringify({ hookSpecificOutput: {
+			hookEventName: "PermissionRequest",
+			decision: decision === "allow" ? { behavior: "allow" } : {
+				behavior: "deny",
+				message: message?.trim() || "Denied by Genesis"
+			}
+		} })}\n`,
+		stderr: "",
+		exitCode: 0
+	})
+} };
+function registerNativeHookRelay(params) {
+	pruneExpiredNativeHookRelays();
+	const relayId = randomUUID();
+	const allowedEvents = normalizeAllowedEvents(params.allowedEvents);
+	const registration = {
+		relayId,
+		provider: params.provider,
+		...params.agentId ? { agentId: params.agentId } : {},
+		sessionId: params.sessionId,
+		...params.sessionKey ? { sessionKey: params.sessionKey } : {},
+		runId: params.runId,
+		allowedEvents,
+		expiresAtMs: Date.now() + normalizePositiveInteger(params.ttlMs, DEFAULT_RELAY_TTL_MS),
+		...params.signal ? { signal: params.signal } : {}
+	};
+	relays.set(relayId, registration);
+	return {
+		...registration,
+		commandForEvent: (event) => buildNativeHookRelayCommand({
+			provider: params.provider,
+			relayId,
+			event,
+			timeoutMs: params.command?.timeoutMs,
+			executable: params.command?.executable,
+			nodeExecutable: params.command?.nodeExecutable
+		}),
+		unregister: () => unregisterNativeHookRelay(relayId)
+	};
+}
+function unregisterNativeHookRelay(relayId) {
+	relays.delete(relayId);
+	removeNativeHookRelayInvocations(relayId);
+	removeNativeHookRelayPermissionState(relayId);
+}
+function buildNativeHookRelayCommand(params) {
+	const timeoutMs = normalizePositiveInteger(params.timeoutMs, DEFAULT_RELAY_TIMEOUT_MS);
+	const executable = params.executable ?? resolveGenesisCliExecutable();
+	return shellQuoteArgs([
+		...executable === "genesis" ? ["genesis"] : [params.nodeExecutable ?? process.execPath, executable],
+		"hooks",
+		"relay",
+		"--provider",
+		params.provider,
+		"--relay-id",
+		params.relayId,
+		"--event",
+		params.event,
+		"--timeout",
+		String(timeoutMs)
+	]);
+}
+async function invokeNativeHookRelay(params) {
+	const provider = readNativeHookRelayProvider(params.provider);
+	const relayId = readNonEmptyString(params.relayId, "relayId");
+	const event = readNativeHookRelayEvent(params.event);
+	const registration = relays.get(relayId);
+	if (!registration) {
+		pruneExpiredNativeHookRelays();
+		throw new Error("native hook relay not found");
+	}
+	if (Date.now() > registration.expiresAtMs) {
+		relays.delete(relayId);
+		removeNativeHookRelayInvocations(relayId);
+		throw new Error("native hook relay expired");
+	}
+	if (registration.provider !== provider) throw new Error("native hook relay provider mismatch");
+	if (!registration.allowedEvents.includes(event)) throw new Error("native hook relay event not allowed");
+	if (!isJsonValue(params.rawPayload)) throw new Error("native hook relay payload must be JSON-compatible");
+	const normalized = normalizeNativeHookInvocation({
+		registration,
+		event,
+		rawPayload: params.rawPayload
+	});
+	recordNativeHookRelayInvocation(normalized);
+	return processNativeHookRelayInvocation({
+		registration,
+		invocation: normalized,
+		adapter: getNativeHookRelayProviderAdapter(provider)
+	});
+}
+function renderNativeHookRelayUnavailableResponse(params) {
+	const provider = readNativeHookRelayProvider(params.provider);
+	const event = readNativeHookRelayEvent(params.event);
+	const adapter = getNativeHookRelayProviderAdapter(provider);
+	const message = params.message?.trim() || "Native hook relay unavailable";
+	if (event === "pre_tool_use") return adapter.renderPreToolUseBlockResponse(message);
+	if (event === "permission_request") return adapter.renderPermissionDecisionResponse("deny", message);
+	return adapter.renderNoopResponse(event);
+}
+function recordNativeHookRelayInvocation(invocation) {
+	invocations.push(invocation);
+	if (invocations.length > MAX_NATIVE_HOOK_RELAY_INVOCATIONS) invocations.splice(0, invocations.length - MAX_NATIVE_HOOK_RELAY_INVOCATIONS);
+}
+function removeNativeHookRelayInvocations(relayId) {
+	for (let index = invocations.length - 1; index >= 0; index -= 1) if (invocations[index]?.relayId === relayId) invocations.splice(index, 1);
+}
+function pruneExpiredNativeHookRelays(now = Date.now()) {
+	for (const [relayId, registration] of relays) if (now > registration.expiresAtMs) {
+		relays.delete(relayId);
+		removeNativeHookRelayInvocations(relayId);
+	}
+}
+async function processNativeHookRelayInvocation(params) {
+	if (params.invocation.event === "pre_tool_use") return runNativeHookRelayPreToolUse(params);
+	if (params.invocation.event === "post_tool_use") return runNativeHookRelayPostToolUse(params);
+	return runNativeHookRelayPermissionRequest(params);
+}
+async function runNativeHookRelayPreToolUse(params) {
+	const outcome = await runBeforeToolCallHook({
+		toolName: normalizeNativeHookToolName(params.invocation.toolName),
+		params: params.adapter.readToolInput(params.invocation.rawPayload),
+		...params.invocation.toolUseId ? { toolCallId: params.invocation.toolUseId } : {},
+		signal: params.registration.signal,
+		ctx: {
+			...params.registration.agentId ? { agentId: params.registration.agentId } : {},
+			sessionId: params.registration.sessionId,
+			...params.registration.sessionKey ? { sessionKey: params.registration.sessionKey } : {},
+			runId: params.registration.runId
+		}
+	});
+	if (outcome.blocked) return params.adapter.renderPreToolUseBlockResponse(outcome.reason);
+	return params.adapter.renderNoopResponse(params.invocation.event);
+}
+async function runNativeHookRelayPostToolUse(params) {
+	await runAgentHarnessAfterToolCallHook({
+		toolName: normalizeNativeHookToolName(params.invocation.toolName),
+		toolCallId: params.invocation.toolUseId ?? `${params.invocation.event}:${params.invocation.receivedAt}`,
+		runId: params.registration.runId,
+		...params.registration.agentId ? { agentId: params.registration.agentId } : {},
+		sessionId: params.registration.sessionId,
+		...params.registration.sessionKey ? { sessionKey: params.registration.sessionKey } : {},
+		startArgs: params.adapter.readToolInput(params.invocation.rawPayload),
+		result: params.adapter.readToolResponse(params.invocation.rawPayload)
+	});
+	return params.adapter.renderNoopResponse(params.invocation.event);
+}
+async function runNativeHookRelayPermissionRequest(params) {
+	const request = {
+		provider: params.registration.provider,
+		...params.registration.agentId ? { agentId: params.registration.agentId } : {},
+		sessionId: params.registration.sessionId,
+		...params.registration.sessionKey ? { sessionKey: params.registration.sessionKey } : {},
+		runId: params.registration.runId,
+		toolName: normalizeNativeHookToolName(params.invocation.toolName),
+		...params.invocation.toolUseId ? { toolCallId: params.invocation.toolUseId } : {},
+		...params.invocation.cwd ? { cwd: params.invocation.cwd } : {},
+		...params.invocation.model ? { model: params.invocation.model } : {},
+		toolInput: params.adapter.readToolInput(params.invocation.rawPayload),
+		...params.registration.signal ? { signal: params.registration.signal } : {}
+	};
+	const approvalKey = nativeHookRelayPermissionApprovalKey({
+		registration: params.registration,
+		request
+	});
+	const pendingApproval = pendingPermissionApprovals.get(approvalKey);
+	try {
+		const decision = await (pendingApproval ?? requestNativeHookRelayPermissionApprovalWithBudget({
+			registration: params.registration,
+			approvalKey,
+			request
+		}));
+		if (decision === "allow") return params.adapter.renderPermissionDecisionResponse("allow");
+		if (decision === "deny") return params.adapter.renderPermissionDecisionResponse("deny", "Denied by user");
+	} catch (error) {
+		log.warn(`native hook permission approval failed; deferring: ${String(error)}`);
+	}
+	return params.adapter.renderNoopResponse(params.invocation.event);
+}
+async function requestNativeHookRelayPermissionApprovalWithBudget(params) {
+	if (!consumeNativeHookRelayPermissionBudget(params.registration.relayId)) {
+		log.warn(`native hook permission approval rate limit exceeded; deferring: relay=${params.registration.relayId} run=${params.registration.runId}`);
+		return "defer";
+	}
+	const approval = nativeHookRelayPermissionApprovalRequester(params.request).finally(() => {
+		pendingPermissionApprovals.delete(params.approvalKey);
+	});
+	pendingPermissionApprovals.set(params.approvalKey, approval);
+	return approval;
+}
+function nativeHookRelayPermissionApprovalKey(params) {
+	return [
+		params.registration.relayId,
+		params.registration.runId,
+		params.request.toolCallId ?? permissionRequestFallbackKey(params.request)
+	].join(":");
+}
+function permissionRequestFallbackKey(request) {
+	const command = readOptionalString(request.toolInput.command);
+	if (command) return `${request.toolName}:command:${truncateText(command, 240)}`;
+	const keys = Object.keys(request.toolInput).toSorted().join(",");
+	return `${request.toolName}:keys:${truncateText(keys, 240)}`;
+}
+function consumeNativeHookRelayPermissionBudget(relayId, now = Date.now()) {
+	const windowStart = now - PERMISSION_APPROVAL_WINDOW_MS;
+	const timestamps = (permissionApprovalWindows.get(relayId) ?? []).filter((timestamp) => timestamp >= windowStart);
+	if (timestamps.length >= MAX_PERMISSION_APPROVALS_PER_WINDOW) {
+		permissionApprovalWindows.set(relayId, timestamps);
+		return false;
+	}
+	timestamps.push(now);
+	permissionApprovalWindows.set(relayId, timestamps);
+	return true;
+}
+function removeNativeHookRelayPermissionState(relayId) {
+	permissionApprovalWindows.delete(relayId);
+	for (const key of pendingPermissionApprovals.keys()) if (key.startsWith(`${relayId}:`)) pendingPermissionApprovals.delete(key);
+}
+function normalizeNativeHookInvocation(params) {
+	const metadata = getNativeHookRelayProviderAdapter(params.registration.provider).normalizeMetadata(params.rawPayload);
+	return {
+		provider: params.registration.provider,
+		relayId: params.registration.relayId,
+		event: params.event,
+		...metadata,
+		...params.registration.agentId ? { agentId: params.registration.agentId } : {},
+		sessionId: params.registration.sessionId,
+		...params.registration.sessionKey ? { sessionKey: params.registration.sessionKey } : {},
+		runId: params.registration.runId,
+		rawPayload: params.rawPayload,
+		receivedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+function getNativeHookRelayProviderAdapter(provider) {
+	return nativeHookRelayProviderAdapters[provider];
+}
+function normalizeCodexHookMetadata(rawPayload) {
+	const payload = isJsonObject(rawPayload) ? rawPayload : {};
+	const metadata = {};
+	const nativeEventName = readOptionalString(payload.hook_event_name);
+	if (nativeEventName) metadata.nativeEventName = nativeEventName;
+	const cwd = readOptionalString(payload.cwd);
+	if (cwd) metadata.cwd = cwd;
+	const model = readOptionalString(payload.model);
+	if (model) metadata.model = model;
+	const toolName = readOptionalString(payload.tool_name);
+	if (toolName) metadata.toolName = toolName;
+	const toolUseId = readOptionalString(payload.tool_use_id);
+	if (toolUseId) metadata.toolUseId = toolUseId;
+	return metadata;
+}
+function readCodexToolInput(rawPayload) {
+	const toolInput = (isJsonObject(rawPayload) ? rawPayload : {}).tool_input;
+	if (isJsonObject(toolInput)) return toolInput;
+	if (toolInput === void 0) return {};
+	return { value: toolInput };
+}
+function readCodexToolResponse(rawPayload) {
+	return (isJsonObject(rawPayload) ? rawPayload : {}).tool_response;
+}
+function normalizeNativeHookToolName(toolName) {
+	return normalizeToolName(toolName ?? "tool");
+}
+async function requestNativeHookRelayPermissionApproval(request) {
+	const timeoutMs = DEFAULT_PERMISSION_TIMEOUT_MS;
+	const requestResult = await callGatewayTool("plugin.approval.request", { timeoutMs: timeoutMs + 1e4 }, {
+		pluginId: `genesis-native-hook-relay-${request.provider}`,
+		title: truncateText(`${nativeHookRelayProviderDisplayName(request.provider)} permission request`, MAX_APPROVAL_TITLE_LENGTH),
+		description: truncateText(formatPermissionApprovalDescription(request), MAX_APPROVAL_DESCRIPTION_LENGTH),
+		severity: "warning",
+		toolName: request.toolName,
+		toolCallId: request.toolCallId,
+		agentId: request.agentId,
+		sessionKey: request.sessionKey,
+		timeoutMs,
+		twoPhase: true
+	}, { expectFinal: false });
+	const approvalId = requestResult?.id;
+	if (!approvalId) return "defer";
+	let decision;
+	if (Object.prototype.hasOwnProperty.call(requestResult ?? {}, "decision")) decision = requestResult.decision;
+	else decision = (await waitForNativeHookRelayApprovalDecision({
+		approvalId,
+		signal: request.signal,
+		timeoutMs
+	}))?.decision;
+	if (decision === PluginApprovalResolutions.ALLOW_ONCE || decision === PluginApprovalResolutions.ALLOW_ALWAYS) return "allow";
+	if (decision === PluginApprovalResolutions.DENY) return "deny";
+	return "defer";
+}
+async function waitForNativeHookRelayApprovalDecision(params) {
+	const waitPromise = callGatewayTool("plugin.approval.waitDecision", { timeoutMs: params.timeoutMs + 1e4 }, { id: params.approvalId });
+	if (!params.signal) return waitPromise;
+	let onAbort;
+	const abortPromise = new Promise((_, reject) => {
+		if (params.signal.aborted) {
+			reject(params.signal.reason);
+			return;
+		}
+		onAbort = () => reject(params.signal.reason);
+		params.signal.addEventListener("abort", onAbort, { once: true });
+	});
+	try {
+		return await Promise.race([waitPromise, abortPromise]);
+	} finally {
+		if (onAbort) params.signal.removeEventListener("abort", onAbort);
+	}
+}
+function formatPermissionApprovalDescription(request) {
+	return [
+		`Tool: ${sanitizeApprovalText(request.toolName)}`,
+		request.cwd ? `Cwd: ${sanitizeApprovalText(request.cwd)}` : void 0,
+		request.model ? `Model: ${sanitizeApprovalText(request.model)}` : void 0,
+		formatToolInputPreview(request.toolInput)
+	].filter((line) => Boolean(line)).join("\n");
+}
+function formatToolInputPreview(toolInput) {
+	const command = readOptionalString(toolInput.command);
+	if (command) return `Command: ${truncateText(sanitizeApprovalText(command), 240)}`;
+	const keys = Object.keys(toolInput).map(sanitizeApprovalText).filter(Boolean).toSorted();
+	if (!keys.length) return;
+	return `Input keys: ${keys.slice(0, 12).join(", ")}${keys.length > 12 ? ` (${keys.length - 12} omitted)` : ""}`;
+}
+function sanitizeApprovalText(value) {
+	let sanitized = "";
+	for (const char of value.replace(ANSI_ESCAPE_PATTERN, "")) {
+		const codePoint = char.codePointAt(0);
+		sanitized += codePoint != null && isUnsafeApprovalCodePoint(codePoint) ? " " : char;
+	}
+	return sanitized.replace(/\s+/g, " ").trim();
+}
+function isUnsafeApprovalCodePoint(codePoint) {
+	return codePoint >= 0 && codePoint <= 8 || codePoint === 11 || codePoint === 12 || codePoint >= 14 && codePoint <= 31 || codePoint >= 127 && codePoint <= 159 || codePoint >= 8234 && codePoint <= 8238 || codePoint >= 8294 && codePoint <= 8297;
+}
+function nativeHookRelayProviderDisplayName(provider) {
+	if (provider === "codex") return "Codex";
+	return provider;
+}
+function truncateText(value, maxLength) {
+	if (value.length <= maxLength) return value;
+	return `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+function resolveGenesisCliExecutable() {
+	const argvEntry = process.argv[1];
+	if (argvEntry) {
+		const resolved = path.resolve(argvEntry);
+		if (existsSync(resolved)) return resolved;
+	}
+	throw new Error("Cannot resolve Genesis CLI executable path for native hook relay");
+}
+function normalizeAllowedEvents(events) {
+	if (!events?.length) return NATIVE_HOOK_RELAY_EVENTS;
+	return [...new Set(events)];
+}
+function normalizePositiveInteger(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function shellQuoteArgs(args) {
+	return args.map((arg) => shellQuoteArg(arg, process.platform)).join(" ");
+}
+function shellQuoteArg(value, platform) {
+	if (/^[A-Za-z0-9_/:=.,@%+-]+$/.test(value)) return value;
+	if (platform === "win32") return `"${value.replaceAll("\"", "\\\"")}"`;
+	return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function readNativeHookRelayProvider(value) {
+	if (value === "codex") return value;
+	throw new Error("unsupported native hook relay provider");
+}
+function readNativeHookRelayEvent(value) {
+	if (value === "pre_tool_use" || value === "post_tool_use" || value === "permission_request") return value;
+	throw new Error("unsupported native hook relay event");
+}
+function readNonEmptyString(value, name) {
+	if (typeof value === "string" && value.trim()) return value.trim();
+	throw new Error(`native hook relay ${name} is required`);
+}
+function readOptionalString(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function isJsonValue(value) {
+	const stack = [{
+		value,
+		depth: 0
+	}];
+	let nodes = 0;
+	while (stack.length) {
+		const current = stack.pop();
+		nodes += 1;
+		if (nodes > MAX_NATIVE_HOOK_RELAY_JSON_NODES) return false;
+		if (current.depth > MAX_NATIVE_HOOK_RELAY_JSON_DEPTH) return false;
+		if (current.value === null || typeof current.value === "string") continue;
+		if (typeof current.value === "number") {
+			if (!Number.isFinite(current.value)) return false;
+			continue;
+		}
+		if (typeof current.value === "boolean") continue;
+		if (Array.isArray(current.value)) {
+			for (const item of current.value) stack.push({
+				value: item,
+				depth: current.depth + 1
+			});
+			continue;
+		}
+		if (!isJsonObject(current.value)) return false;
+		try {
+			for (const item of Object.values(current.value)) stack.push({
+				value: item,
+				depth: current.depth + 1
+			});
+		} catch {
+			return false;
+		}
+	}
+	return true;
+}
+function isJsonObject(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	try {
+		const prototype = Object.getPrototypeOf(value);
+		return prototype === Object.prototype || prototype === null;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { runAgentHarnessAfterToolCallHook as a, renderNativeHookRelayUnavailableResponse as i, invokeNativeHookRelay as n, runAgentHarnessBeforeMessageWriteHook as o, registerNativeHookRelay as r, buildNativeHookRelayCommand as t };

package/dist/nextcloud-talk-ByistOQj.js

@@ -0,0 +1,17 @@
+import "./auth-rate-limit-aUMFOR7H.js";
+import "./zod-schema.core-CoFhKG_K.js";
+import "./config-schema-jug-eHfF.js";
+import "./zod-schema.agent-runtime-BxiP7-C2.js";
+import "./fetch-guard-CsgToyd0.js";
+import "./setup-helpers-C31wmCh6.js";
+import "./secret-input-X94ng2dE.js";
+import "./dm-policy-shared-6bTNkZt-.js";
+import "./setup-wizard-helpers-2j--bU0j.js";
+import "./channel-reply-pipeline-BbFpiuUk.js";
+import "./channel-pairing-DQW7B5h7.js";
+import "./status-helpers-pM311_XZ.js";
+import "./webhook-ingress-D0_YpYZ3.js";
+import "./inbound-reply-dispatch-jQhsUF0f.js";
+import "./account-resolution-FMtyCeJh.js";
+import "./persistent-dedupe-Bxlz6pC3.js";
+export {};