@pixelzx/genesis 2026.5.3-5 → 2026.5.5

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

@@ -1,519 +0,0 @@
-import { t as createSubsystemLogger } from "./subsystem-DTMy5YmO.js";
-import { t as getGlobalHookRunner } from "./hook-runner-global-DA2gGjRr.js";
-import { i as PluginApprovalResolutions } from "./types-4ErQj1im.js";
-import { p as normalizeToolName } from "./tool-policy-DWE9-eQY.js";
-import { i as runBeforeToolCallHook, n as consumeAdjustedParamsForToolCall } from "./pi-tools.before-tool-call-DG7VVNBn.js";
-import { t as callGatewayTool } from "./gateway-D4iWwu3_.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-BuJVVP0J.js

@@ -1,17 +0,0 @@
-import "./auth-rate-limit-kdcjI6bF.js";
-import "./zod-schema.core--iz7S8Y4.js";
-import "./config-schema-BEt8F1Tk.js";
-import "./zod-schema.agent-runtime-DpkOCj_E.js";
-import "./fetch-guard-DKzLBD09.js";
-import "./setup-helpers-DdXv0uuQ.js";
-import "./secret-input-DnSXDYEn.js";
-import "./dm-policy-shared-CWi7ZZgc.js";
-import "./setup-wizard-helpers-bq7q4u8-.js";
-import "./channel-reply-pipeline-BgPhKdUO.js";
-import "./channel-pairing-B3r45ANt.js";
-import "./status-helpers-BPJZpVuU.js";
-import "./webhook-ingress-BET_Iso7.js";
-import "./inbound-reply-dispatch-DPf_IrbV.js";
-import "./account-resolution-CCoiqE4j.js";
-import "./persistent-dedupe-BTyTh8iP.js";
-export {};