@pixelzx/genesis 2026.6.13-beta.3 → 2026.6.13

package/dist/client-G9bp9IBR.js

@@ -0,0 +1,138 @@
+import { i as formatErrorMessage } from "./errors-CufR9eHH.js";
+import { r as fetchWithTimeout } from "./fetch-timeout-DeWZqKPs.js";
+import { a as generateSecureUuid } from "./secure-random-XRbPM_Nv.js";
+import "./text-runtime-CFgLIdKf.js";
+import "./core-cFPca6I1.js";
+import "./error-runtime-QklRpjU7.js";
+import { t as resolveFetch } from "./fetch-DmZyJaGn.js";
+import "./fetch-runtime-BJH-YxsD.js";
+//#region extensions/signal/src/client.ts
+const DEFAULT_TIMEOUT_MS = 1e4;
+function normalizeBaseUrl(url) {
+	const trimmed = url.trim();
+	if (!trimmed) throw new Error("Signal base URL is required");
+	if (/^https?:\/\//i.test(trimmed)) return trimmed.replace(/\/+$/, "");
+	return `http://${trimmed}`.replace(/\/+$/, "");
+}
+function getRequiredFetch() {
+	const fetchImpl = resolveFetch();
+	if (!fetchImpl) throw new Error("fetch is not available");
+	return fetchImpl;
+}
+function parseSignalRpcResponse(text, status) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch (err) {
+		throw new Error(`Signal RPC returned malformed JSON (status ${status})`, { cause: err });
+	}
+	if (!parsed || typeof parsed !== "object") throw new Error(`Signal RPC returned invalid response envelope (status ${status})`);
+	const rpc = parsed;
+	const hasResult = Object.hasOwn(rpc, "result");
+	if (!rpc.error && !hasResult) throw new Error(`Signal RPC returned invalid response envelope (status ${status})`);
+	return rpc;
+}
+async function signalRpcRequest(method, params, opts) {
+	const baseUrl = normalizeBaseUrl(opts.baseUrl);
+	const id = generateSecureUuid();
+	const body = JSON.stringify({
+		jsonrpc: "2.0",
+		method,
+		params,
+		id
+	});
+	const res = await fetchWithTimeout(`${baseUrl}/api/v1/rpc`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body
+	}, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS, getRequiredFetch());
+	if (res.status === 201) return;
+	const text = await res.text();
+	if (!text) throw new Error(`Signal RPC empty response (status ${res.status})`);
+	const parsed = parseSignalRpcResponse(text, res.status);
+	if (parsed.error) {
+		const code = parsed.error.code ?? "unknown";
+		const msg = parsed.error.message ?? "Signal RPC error";
+		throw new Error(`Signal RPC ${code}: ${msg}`);
+	}
+	return parsed.result;
+}
+async function signalCheck(baseUrl, timeoutMs = DEFAULT_TIMEOUT_MS) {
+	const normalized = normalizeBaseUrl(baseUrl);
+	try {
+		const res = await fetchWithTimeout(`${normalized}/api/v1/check`, { method: "GET" }, timeoutMs, getRequiredFetch());
+		if (!res.ok) return {
+			ok: false,
+			status: res.status,
+			error: `HTTP ${res.status}`
+		};
+		return {
+			ok: true,
+			status: res.status,
+			error: null
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			status: null,
+			error: formatErrorMessage(err)
+		};
+	}
+}
+async function streamSignalEvents(params) {
+	const baseUrl = normalizeBaseUrl(params.baseUrl);
+	const url = new URL(`${baseUrl}/api/v1/events`);
+	if (params.account) url.searchParams.set("account", params.account);
+	const fetchImpl = resolveFetch();
+	if (!fetchImpl) throw new Error("fetch is not available");
+	const res = await fetchImpl(url, {
+		method: "GET",
+		headers: { Accept: "text/event-stream" },
+		signal: params.abortSignal
+	});
+	if (!res.ok || !res.body) throw new Error(`Signal SSE failed (${res.status} ${res.statusText || "error"})`);
+	const reader = res.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let currentEvent = {};
+	const flushEvent = () => {
+		if (!currentEvent.data && !currentEvent.event && !currentEvent.id) return;
+		params.onEvent({
+			event: currentEvent.event,
+			data: currentEvent.data,
+			id: currentEvent.id
+		});
+		currentEvent = {};
+	};
+	while (true) {
+		const { value, done } = await reader.read();
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+		let lineEnd = buffer.indexOf("\n");
+		while (lineEnd !== -1) {
+			let line = buffer.slice(0, lineEnd);
+			buffer = buffer.slice(lineEnd + 1);
+			if (line.endsWith("\r")) line = line.slice(0, -1);
+			if (line === "") {
+				flushEvent();
+				lineEnd = buffer.indexOf("\n");
+				continue;
+			}
+			if (line.startsWith(":")) {
+				lineEnd = buffer.indexOf("\n");
+				continue;
+			}
+			const [rawField, ...rest] = line.split(":");
+			const field = rawField.trim();
+			const rawValue = rest.join(":");
+			const value = rawValue.startsWith(" ") ? rawValue.slice(1) : rawValue;
+			if (field === "event") currentEvent.event = value;
+			else if (field === "data") currentEvent.data = currentEvent.data ? `${currentEvent.data}\n${value}` : value;
+			else if (field === "id") currentEvent.id = value;
+			lineEnd = buffer.indexOf("\n");
+		}
+	}
+	flushEvent();
+}
+//#endregion
+export { signalRpcRequest as n, streamSignalEvents as r, signalCheck as t };

package/dist/command-auth-C6emi1Rr.js

@@ -0,0 +1,76 @@
+import "./command-registration-mlnPpG9c.js";
+import "./command-detection-BkVdiL8h.js";
+import "./commands-registry-uwVdlY7n.js";
+import { o as resolveDmGroupAccessWithLists } from "./dm-policy-shared-Di2wRDuS.js";
+import "./command-auth-C8YZ7xNT.js";
+import "./stored-model-override-D8Y2JQgL.js";
+import { n as buildCommandsMessagePaginated$1, r as buildHelpMessage$1, t as buildCommandsMessage$1 } from "./command-status-builders-D-B587D9.js";
+import "./direct-dm-DIod6mar.js";
+import "./skill-commands-GmJ-uKh9.js";
+import "./commands-models-BCinNqYY.js";
+//#region src/plugin-sdk/command-auth.ts
+/** Fast-path DM command authorization when only policy and sender allowlist state matter. */
+function resolveDirectDmAuthorizationOutcome(params) {
+	if (params.isGroup) return "allowed";
+	if (params.dmPolicy === "disabled") return "disabled";
+	if (params.dmPolicy !== "open" && !params.senderAllowedForCommands) return "unauthorized";
+	return "allowed";
+}
+/** Runtime-backed wrapper around sender command authorization for grouped helper surfaces. */
+async function resolveSenderCommandAuthorizationWithRuntime(params) {
+	return resolveSenderCommandAuthorization({
+		...params,
+		shouldComputeCommandAuthorized: params.runtime.shouldComputeCommandAuthorized,
+		resolveCommandAuthorizedFromAuthorizers: params.runtime.resolveCommandAuthorizedFromAuthorizers
+	});
+}
+/** Compute effective allowlists and command authorization for one inbound sender. */
+async function resolveSenderCommandAuthorization(params) {
+	const shouldComputeAuth = params.shouldComputeCommandAuthorized(params.rawBody, params.cfg);
+	const storeAllowFrom = !params.isGroup && params.dmPolicy !== "allowlist" && (params.dmPolicy !== "open" || shouldComputeAuth) ? await params.readAllowFromStore().catch(() => []) : [];
+	const access = resolveDmGroupAccessWithLists({
+		isGroup: params.isGroup,
+		dmPolicy: params.dmPolicy,
+		groupPolicy: "allowlist",
+		allowFrom: params.configuredAllowFrom,
+		groupAllowFrom: params.configuredGroupAllowFrom ?? [],
+		storeAllowFrom,
+		isSenderAllowed: (allowFrom) => params.isSenderAllowed(params.senderId, allowFrom)
+	});
+	const effectiveAllowFrom = access.effectiveAllowFrom;
+	const effectiveGroupAllowFrom = access.effectiveGroupAllowFrom;
+	const useAccessGroups = params.cfg.commands?.useAccessGroups !== false;
+	const senderAllowedForCommands = params.isSenderAllowed(params.senderId, params.isGroup ? effectiveGroupAllowFrom : effectiveAllowFrom);
+	const ownerAllowedForCommands = params.isSenderAllowed(params.senderId, effectiveAllowFrom);
+	const groupAllowedForCommands = params.isSenderAllowed(params.senderId, effectiveGroupAllowFrom);
+	return {
+		shouldComputeAuth,
+		effectiveAllowFrom,
+		effectiveGroupAllowFrom,
+		senderAllowedForCommands,
+		commandAuthorized: shouldComputeAuth ? params.resolveCommandAuthorizedFromAuthorizers({
+			useAccessGroups,
+			authorizers: [{
+				configured: effectiveAllowFrom.length > 0,
+				allowed: ownerAllowedForCommands
+			}, {
+				configured: effectiveGroupAllowFrom.length > 0,
+				allowed: groupAllowedForCommands
+			}]
+		}) : void 0
+	};
+}
+/** @deprecated Use `genesis/plugin-sdk/command-status` instead. */
+function buildCommandsMessage(...args) {
+	return buildCommandsMessage$1(...args);
+}
+/** @deprecated Use `genesis/plugin-sdk/command-status` instead. */
+function buildCommandsMessagePaginated(...args) {
+	return buildCommandsMessagePaginated$1(...args);
+}
+/** @deprecated Use `genesis/plugin-sdk/command-status` instead. */
+function buildHelpMessage(...args) {
+	return buildHelpMessage$1(...args);
+}
+//#endregion
+export { resolveSenderCommandAuthorization as a, resolveDirectDmAuthorizationOutcome as i, buildCommandsMessagePaginated as n, resolveSenderCommandAuthorizationWithRuntime as o, buildHelpMessage as r, buildCommandsMessage as t };

package/dist/command-config-resolution-CY8Uap6U.js

@@ -0,0 +1,2 @@
+import { t as resolveCommandConfigWithSecrets } from "./command-config-resolution-Dkkd_zz7.js";
+export { resolveCommandConfigWithSecrets };

package/dist/command-config-resolution-Dkkd_zz7.js

@@ -0,0 +1,23 @@
+import { t as applyPluginAutoEnable } from "./plugin-auto-enable-B82mLI9l.js";
+import { t as resolveCommandSecretRefsViaGateway } from "./command-secret-gateway-BxGIG8ny.js";
+//#region src/cli/command-config-resolution.ts
+async function resolveCommandConfigWithSecrets(params) {
+	const { resolvedConfig, diagnostics } = await resolveCommandSecretRefsViaGateway({
+		config: params.config,
+		commandName: params.commandName,
+		targetIds: params.targetIds,
+		...params.mode ? { mode: params.mode } : {},
+		...params.allowedPaths ? { allowedPaths: params.allowedPaths } : {}
+	});
+	if (params.runtime) for (const entry of diagnostics) params.runtime.log(`[secrets] ${entry}`);
+	return {
+		resolvedConfig,
+		effectiveConfig: params.autoEnable ? applyPluginAutoEnable({
+			config: resolvedConfig,
+			env: params.env ?? process.env
+		}).config : resolvedConfig,
+		diagnostics
+	};
+}
+//#endregion
+export { resolveCommandConfigWithSecrets as t };

package/dist/command-config-resolution.runtime-B03wRV-i.js

@@ -0,0 +1,2 @@
+import { t as resolveCommandConfigWithSecrets } from "./command-config-resolution-Dkkd_zz7.js";
+export { resolveCommandConfigWithSecrets };

package/dist/command-config-resolution.runtime.js

@@ -1 +1 @@
-export * from "./command-config-resolution.runtime-D6U--833.js";
+export * from "./command-config-resolution.runtime-B03wRV-i.js";

package/dist/command-registry-BdXEbnVK.js

@@ -0,0 +1,9 @@
+import { n as registerCoreCliCommands } from "./command-registry-core-X1IeFtlC.js";
+import { n as registerSubCliCommands } from "./register.subclis-DLvpHAI3.js";
+//#region src/cli/program/command-registry.ts
+function registerProgramCommands(program, ctx, argv = process.argv) {
+	registerCoreCliCommands(program, ctx, argv);
+	registerSubCliCommands(program, argv);
+}
+//#endregion
+export { registerProgramCommands as t };

package/dist/command-registry-BwJ8YzAH.js

@@ -0,0 +1,4 @@
+import "./core-command-descriptors-BiPkn7W6.js";
+import { t as registerCoreCliByName } from "./command-registry-core-X1IeFtlC.js";
+import "./command-registry-BdXEbnVK.js";
+export { registerCoreCliByName };

package/dist/command-registry-core-X1IeFtlC.js

@@ -0,0 +1,106 @@
+import { t as resolveCliArgvInvocation } from "./argv-invocation-DXsyrCs-.js";
+import { n as shouldRegisterPrimaryCommandOnly } from "./command-registration-policy-B4JbZBuv.js";
+import { a as defineImportedCommandGroupSpec, i as buildCommandGroupEntries, o as defineImportedProgramCommandGroupSpecs } from "./register.subclis-core-DuiCves5.js";
+import { t as getCoreCliCommandDescriptors } from "./core-command-descriptors-BiPkn7W6.js";
+import { i as registerCommandGroups, r as registerCommandGroupByName } from "./register-command-groups-CiwXGeh-.js";
+//#region src/cli/program/command-registry-core.ts
+function withProgramOnlySpecs(specs) {
+	return specs.map((spec) => ({
+		commandNames: spec.commandNames,
+		register: async ({ program }) => {
+			await spec.register(program);
+		}
+	}));
+}
+const coreEntrySpecs = [
+	...withProgramOnlySpecs(defineImportedProgramCommandGroupSpecs([
+		{
+			commandNames: ["setup"],
+			loadModule: () => import("./register.setup-DAoIkDtN.js"),
+			exportName: "registerSetupCommand"
+		},
+		{
+			commandNames: ["onboard"],
+			loadModule: () => import("./register.onboard-1xQPe7tH.js"),
+			exportName: "registerOnboardCommand"
+		},
+		{
+			commandNames: ["configure"],
+			loadModule: () => import("./register.configure-BLcph6ME.js"),
+			exportName: "registerConfigureCommand"
+		},
+		{
+			commandNames: ["config"],
+			loadModule: () => import("./config-cli-B4sSTkyr.js"),
+			exportName: "registerConfigCli"
+		},
+		{
+			commandNames: ["backup"],
+			loadModule: () => import("./register.backup-DXkrJ0h9.js"),
+			exportName: "registerBackupCommand"
+		},
+		{
+			commandNames: ["migrate"],
+			loadModule: () => import("./register.migrate-CAAtwK3f.js"),
+			exportName: "registerMigrateCommand"
+		},
+		{
+			commandNames: [
+				"doctor",
+				"dashboard",
+				"reset",
+				"uninstall"
+			],
+			loadModule: () => import("./register.maintenance-CPYg-yEz.js"),
+			exportName: "registerMaintenanceCommands"
+		}
+	])),
+	defineImportedCommandGroupSpec(["message"], () => import("./register.message-CficlkIg.js"), (mod, { program, ctx }) => {
+		mod.registerMessageCommands(program, ctx);
+	}),
+	...withProgramOnlySpecs(defineImportedProgramCommandGroupSpecs([{
+		commandNames: ["mcp"],
+		loadModule: () => import("./mcp-cli-Cq3kJYFy.js"),
+		exportName: "registerMcpCli"
+	}])),
+	defineImportedCommandGroupSpec(["agent", "agents"], () => import("./register.agent-CtzP54VE.js"), (mod, { program, ctx }) => {
+		mod.registerAgentCommands(program, { agentChannelOptions: ctx.agentChannelOptions });
+	}),
+	...withProgramOnlySpecs(defineImportedProgramCommandGroupSpecs([{
+		commandNames: ["wallet"],
+		loadModule: () => import("./register.wallet-B_m0R3GX.js"),
+		exportName: "registerWalletCommand"
+	}])),
+	...withProgramOnlySpecs(defineImportedProgramCommandGroupSpecs([{
+		commandNames: [
+			"status",
+			"health",
+			"sessions",
+			"tasks"
+		],
+		loadModule: () => import("./register.status-health-sessions-0WKthgEo.js"),
+		exportName: "registerStatusHealthSessionsCommands"
+	}]))
+];
+function resolveCoreCommandGroups(ctx, argv) {
+	return buildCommandGroupEntries(getCoreCliCommandDescriptors(), coreEntrySpecs, (register) => async (program) => {
+		await register({
+			program,
+			ctx,
+			argv
+		});
+	});
+}
+async function registerCoreCliByName(program, ctx, name, argv = process.argv) {
+	return registerCommandGroupByName(program, resolveCoreCommandGroups(ctx, argv), name);
+}
+function registerCoreCliCommands(program, ctx, argv) {
+	const { primary } = resolveCliArgvInvocation(argv);
+	registerCommandGroups(program, resolveCoreCommandGroups(ctx, argv), {
+		eager: false,
+		primary,
+		registerPrimaryOnly: Boolean(primary && shouldRegisterPrimaryCommandOnly(argv))
+	});
+}
+//#endregion
+export { registerCoreCliCommands as n, registerCoreCliByName as t };