@pixelzx/genesis 2026.6.6-1 → 2026.6.7

package/dist/image-generation-provider-eiDfurMp.js

@@ -0,0 +1,157 @@
+import { c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-DPP_aYVc.js";
+import { r as assertOkOrThrowHttpError } from "./provider-http-errors-CHlOQSL-.js";
+import { a as postJsonRequest, d as resolveProviderOperationTimeoutMs, n as createProviderOperationDeadline, u as resolveProviderHttpRequestConfig } from "./shared-dK9azfzw.js";
+import "./text-runtime-Dd2bva2m.js";
+import { t as isProviderApiKeyConfigured } from "./provider-auth-H9DyFjvJ.js";
+import "./provider-http-jBjkpqsS.js";
+import { a as resolveApiKeyForProvider } from "./provider-auth-runtime-BAtD4Xlo.js";
+import { c as XAI_IMAGE_MODELS, i as XAI_DEFAULT_IMAGE_MODEL, t as XAI_BASE_URL } from "./model-definitions-taVnM0qU.js";
+//#region extensions/xai/image-generation-provider.ts
+const DEFAULT_OUTPUT_MIME = "image/png";
+const DEFAULT_TIMEOUT_MS = 6e4;
+const XAI_SUPPORTED_ASPECT_RATIOS = [
+	"1:1",
+	"16:9",
+	"9:16",
+	"4:3",
+	"3:4",
+	"2:3",
+	"3:2"
+];
+function toDataUrl(buffer, mimeType) {
+	return `data:${mimeType};base64,${buffer.toString("base64")}`;
+}
+function resolveImageForEdit(input) {
+	if (!input) throw new Error("xAI image edit requires an input image.");
+	const url = normalizeOptionalString(input.url);
+	if (url) return url;
+	if (!input.buffer) throw new Error("xAI image edit input is missing both URL and buffer data.");
+	const mime = normalizeOptionalString(input.mimeType) ?? "image/png";
+	return toDataUrl(input.buffer, mime);
+}
+function isEdit(req) {
+	return (req.inputImages?.length ?? 0) > 0;
+}
+function resolveXaiImageBaseUrl(req) {
+	return normalizeOptionalString(req.cfg?.models?.providers?.xai?.baseUrl) ?? "https://api.x.ai/v1";
+}
+function buildBody(req, edit) {
+	const model = normalizeOptionalString(req.model) ?? "grok-imagine-image";
+	const count = req.count ?? 1;
+	const body = {
+		model,
+		prompt: req.prompt,
+		n: Math.min(count, 4),
+		response_format: "b64_json"
+	};
+	const aspect = normalizeOptionalString(req.aspectRatio);
+	if (aspect && XAI_SUPPORTED_ASPECT_RATIOS.includes(aspect)) body.aspect_ratio = aspect;
+	const resolution = normalizeOptionalLowercaseString(req.resolution);
+	if (resolution) body.resolution = resolution;
+	if (edit) {
+		const inputImages = req.inputImages ?? [];
+		if (inputImages.length > 1) body.images = inputImages.map((input) => ({
+			url: resolveImageForEdit(input),
+			type: "image_url"
+		}));
+		else body.image = {
+			url: resolveImageForEdit(inputImages[0]),
+			type: "image_url"
+		};
+	}
+	return body;
+}
+function buildXaiImageGenerationProvider() {
+	return {
+		id: "xai",
+		label: "xAI",
+		defaultModel: XAI_DEFAULT_IMAGE_MODEL,
+		models: [...XAI_IMAGE_MODELS],
+		isConfigured: ({ agentDir }) => isProviderApiKeyConfigured({
+			provider: "xai",
+			agentDir
+		}),
+		capabilities: {
+			generate: {
+				maxCount: 4,
+				supportsAspectRatio: true,
+				supportsResolution: true,
+				supportsSize: false
+			},
+			edit: {
+				enabled: true,
+				maxCount: 4,
+				maxInputImages: 5,
+				supportsAspectRatio: true,
+				supportsResolution: true,
+				supportsSize: false
+			},
+			geometry: {
+				aspectRatios: [...XAI_SUPPORTED_ASPECT_RATIOS],
+				resolutions: ["1K", "2K"]
+			}
+		},
+		async generateImage(req) {
+			const edit = isEdit(req);
+			const auth = await resolveApiKeyForProvider({
+				provider: "xai",
+				cfg: req.cfg,
+				agentDir: req.agentDir,
+				store: req.authStore
+			});
+			if (!auth.apiKey) throw new Error("xAI API key missing");
+			const fetchFn = fetch;
+			const deadline = createProviderOperationDeadline({
+				timeoutMs: req.timeoutMs,
+				label: edit ? "xAI image edit" : "xAI image generation"
+			});
+			const { baseUrl: resolvedBaseUrl, allowPrivateNetwork, headers, dispatcherPolicy } = resolveProviderHttpRequestConfig({
+				baseUrl: resolveXaiImageBaseUrl(req),
+				defaultBaseUrl: XAI_BASE_URL,
+				allowPrivateNetwork: false,
+				defaultHeaders: {
+					Authorization: `Bearer ${auth.apiKey}`,
+					"Content-Type": "application/json"
+				},
+				provider: "xai",
+				capability: "image",
+				transport: "http"
+			});
+			const body = buildBody(req, edit);
+			const { response, release } = await postJsonRequest({
+				url: `${resolvedBaseUrl}${edit ? "/images/edits" : "/images/generations"}`,
+				headers,
+				body,
+				timeoutMs: resolveProviderOperationTimeoutMs({
+					deadline,
+					defaultTimeoutMs: DEFAULT_TIMEOUT_MS
+				}),
+				fetchFn,
+				allowPrivateNetwork,
+				dispatcherPolicy
+			});
+			try {
+				await assertOkOrThrowHttpError(response, edit ? "xAI image edit failed" : "xAI image generation failed");
+				return {
+					images: ((await response.json()).data ?? []).flatMap((item, idx) => {
+						if (!item) return [];
+						const b64 = normalizeOptionalString(item.b64_json);
+						if (!b64) return [];
+						const mimeType = normalizeOptionalString(item.mime_type) ?? DEFAULT_OUTPUT_MIME;
+						return [{
+							buffer: Buffer.from(b64, "base64"),
+							mimeType,
+							fileName: `image-${idx + 1}.${mimeType.split("/")[1] || "png"}`,
+							...item.revised_prompt ? { revisedPrompt: normalizeOptionalString(item.revised_prompt) } : {}
+						}];
+					}),
+					model: normalizeOptionalString(req.model) ?? "grok-imagine-image"
+				};
+			} finally {
+				await release();
+			}
+		}
+	};
+}
+//#endregion
+export { buildXaiImageGenerationProvider as t };

package/dist/image-generation-provider-iM6hlpJY.js

@@ -0,0 +1,63 @@
+import { a as isComfyCapabilityConfigured, s as runComfyWorkflow, t as DEFAULT_COMFY_MODEL } from "./workflow-runtime-BrBSvDJz.js";
+//#region extensions/comfy/image-generation-provider.ts
+function buildComfyImageGenerationProvider() {
+	return {
+		id: "comfy",
+		label: "ComfyUI",
+		defaultModel: DEFAULT_COMFY_MODEL,
+		models: [DEFAULT_COMFY_MODEL],
+		isConfigured: ({ cfg, agentDir }) => isComfyCapabilityConfigured({
+			cfg,
+			agentDir,
+			capability: "image"
+		}),
+		capabilities: {
+			generate: {
+				maxCount: 1,
+				supportsSize: false,
+				supportsAspectRatio: false,
+				supportsResolution: false
+			},
+			edit: {
+				enabled: true,
+				maxCount: 1,
+				maxInputImages: 1,
+				supportsSize: false,
+				supportsAspectRatio: false,
+				supportsResolution: false
+			}
+		},
+		async generateImage(req) {
+			if ((req.inputImages?.length ?? 0) > 1) throw new Error("Comfy image generation currently supports at most one reference image");
+			const result = await runComfyWorkflow({
+				cfg: req.cfg,
+				agentDir: req.agentDir,
+				authStore: req.authStore,
+				prompt: req.prompt,
+				model: req.model,
+				timeoutMs: req.timeoutMs,
+				capability: "image",
+				outputKinds: ["images"],
+				inputImage: req.inputImages?.[0]
+			});
+			return {
+				images: result.assets.map((asset) => ({
+					buffer: asset.buffer,
+					mimeType: asset.mimeType,
+					fileName: asset.fileName,
+					metadata: {
+						nodeId: asset.nodeId,
+						promptId: result.promptId
+					}
+				})),
+				model: result.model,
+				metadata: {
+					promptId: result.promptId,
+					outputNodeIds: result.outputNodeIds
+				}
+			};
+		}
+	};
+}
+//#endregion
+export { buildComfyImageGenerationProvider as t };

package/dist/inbound-reply-dispatch-Cj041nYj.js

@@ -0,0 +1,73 @@
+import { n as createNormalizedOutboundDeliverer } from "./reply-payload-BXIttfWn.js";
+import { c as withReplyDispatcher, s as dispatchReplyFromConfig } from "./dispatch-Dd327enz.js";
+import { t as createChannelReplyPipeline } from "./channel-reply-pipeline-C6vxIEb-.js";
+//#region src/plugin-sdk/inbound-reply-dispatch.ts
+/** Run `dispatchReplyFromConfig` with a dispatcher that always gets its settled callback. */
+async function dispatchReplyFromConfigWithSettledDispatcher(params) {
+	return await withReplyDispatcher({
+		dispatcher: params.dispatcher,
+		onSettled: params.onSettled,
+		run: () => dispatchReplyFromConfig({
+			ctx: params.ctxPayload,
+			cfg: params.cfg,
+			dispatcher: params.dispatcher,
+			replyOptions: params.replyOptions,
+			configOverride: params.configOverride
+		})
+	});
+}
+/** Assemble the common inbound reply dispatch dependencies for a resolved route. */
+function buildInboundReplyDispatchBase(params) {
+	return {
+		cfg: params.cfg,
+		channel: params.channel,
+		accountId: params.accountId,
+		agentId: params.route.agentId,
+		routeSessionKey: params.route.sessionKey,
+		storePath: params.storePath,
+		ctxPayload: params.ctxPayload,
+		recordInboundSession: params.core.channel.session.recordInboundSession,
+		dispatchReplyWithBufferedBlockDispatcher: params.core.channel.reply.dispatchReplyWithBufferedBlockDispatcher
+	};
+}
+/** Resolve the shared dispatch base and immediately record + dispatch one inbound reply turn. */
+async function dispatchInboundReplyWithBase(params) {
+	await recordInboundSessionAndDispatchReply({
+		...buildInboundReplyDispatchBase(params),
+		deliver: params.deliver,
+		onRecordError: params.onRecordError,
+		onDispatchError: params.onDispatchError,
+		replyOptions: params.replyOptions
+	});
+}
+/** Record the inbound session first, then dispatch the reply using normalized outbound delivery. */
+async function recordInboundSessionAndDispatchReply(params) {
+	await params.recordInboundSession({
+		storePath: params.storePath,
+		sessionKey: params.ctxPayload.SessionKey ?? params.routeSessionKey,
+		ctx: params.ctxPayload,
+		onRecordError: params.onRecordError
+	});
+	const { onModelSelected, ...replyPipeline } = createChannelReplyPipeline({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		channel: params.channel,
+		accountId: params.accountId
+	});
+	const deliver = createNormalizedOutboundDeliverer(params.deliver);
+	await params.dispatchReplyWithBufferedBlockDispatcher({
+		ctx: params.ctxPayload,
+		cfg: params.cfg,
+		dispatcherOptions: {
+			...replyPipeline,
+			deliver,
+			onError: params.onDispatchError
+		},
+		replyOptions: {
+			...params.replyOptions,
+			onModelSelected
+		}
+	});
+}
+//#endregion
+export { recordInboundSessionAndDispatchReply as i, dispatchInboundReplyWithBase as n, dispatchReplyFromConfigWithSettledDispatcher as r, buildInboundReplyDispatchBase as t };

package/dist/inbound.runtime-BFDKTetv.js

@@ -0,0 +1,3 @@
+import "./paths-CV1IubzZ.js";
+import "./store-CEFH-fGo.js";
+export {};

package/dist/inbound.runtime-C9MPsVfj.js

@@ -0,0 +1,4 @@
+import { u as resolveStorePath } from "./paths-CV1IubzZ.js";
+import { a as updateLastRoute, r as recordSessionMetaFromInbound } from "./store-CEFH-fGo.js";
+import "./inbound.runtime-BFDKTetv.js";
+export { recordSessionMetaFromInbound, resolveStorePath, updateLastRoute };

package/dist/inbound.runtime.js

@@ -1 +1 @@
-export * from "./inbound.runtime-BsJCJ9wE.js";
+export * from "./inbound.runtime-C9MPsVfj.js";

package/dist/index.js

@@ -27,7 +27,7 @@ let runExec;
 let saveSessionStore;
 let waitForever;
 async function loadLegacyCliDeps() {
-	const { runCli } = await import("./run-main-C4eOl9O3.js");
+	const { runCli } = await import("./run-main-DlCyw-yJ.js");
 	return { runCli };
 }
 async function runLegacyCliEntry(argv = process.argv, deps) {
@@ -35,7 +35,7 @@ async function runLegacyCliEntry(argv = process.argv, deps) {
 	await runCli(argv);
 }
 const isMain = isMainModule({ currentFile: fileURLToPath(import.meta.url) });
-if (!isMain) ({applyTemplate, createDefaultDeps, deriveSessionKey, describePortOwner, ensureBinary, ensurePortAvailable, getReplyFromConfig, handlePortError, loadConfig, loadSessionStore, monitorWebChannel, normalizeE164, PortInUseError, promptYesNo, resolveSessionKey, resolveStorePath, runCommandWithTimeout, runExec, saveSessionStore, waitForever} = await import("./library-BpP85Umq.js"));
+if (!isMain) ({applyTemplate, createDefaultDeps, deriveSessionKey, describePortOwner, ensureBinary, ensurePortAvailable, getReplyFromConfig, handlePortError, loadConfig, loadSessionStore, monitorWebChannel, normalizeE164, PortInUseError, promptYesNo, resolveSessionKey, resolveStorePath, runCommandWithTimeout, runExec, saveSessionStore, waitForever} = await import("./library-B5XEbilF.js"));
 if (isMain) {
 	const { restoreTerminalState } = await import("./restore-BI6Ocy0f.js");
 	installUnhandledRejectionHandler();

package/dist/infra-runtime-D9uudHda.js

@@ -0,0 +1,39 @@
+import "./errors-CufR9eHH.js";
+import "./env-DgbHOvMC.js";
+import "./file-lock-CKcG3jTd.js";
+import "./heartbeat-summary-DZn9OIvg.js";
+import "./ssrf-FLmnjVdI.js";
+import "./undici-global-dispatcher-B-SxsD7j.js";
+import "./fetch-guard-CHbFjcDr.js";
+import "./fs-safe-2qh6MzsS.js";
+import "./exec-approvals-D46yYaX9.js";
+import "./proxy-fetch-D-A48sDA.js";
+import { n as drainPendingDeliveries$1 } from "./delivery-queue-C7I6zdVJ.js";
+import "./system-events-_jEHE6Qp.js";
+import "./retry-Bx-5vPDB.js";
+import "./secret-file-DeXm1iwT.js";
+import "./http-body-lzZef-oj.js";
+import "./exec-approval-reply-BVINNdDT.js";
+import "./approval-native-runtime-BCglJkGQ.js";
+import "./exec-approval-command-display-sHtiIeDj.js";
+import "./exec-approval-session-target-BclZJwRq.js";
+import "./heartbeat-visibility-B7U_PmMP.js";
+import "./transport-ready-BMP3Wuuo.js";
+import "./identity-C_yP71Yw.js";
+import "./retry-policy-DCqrJ9cx.js";
+import "./ssrf-policy-klk3nkr1.js";
+//#region src/plugin-sdk/infra-runtime.ts
+let outboundDeliverRuntimePromise = null;
+async function loadOutboundDeliverRuntime() {
+	outboundDeliverRuntimePromise ??= import("./deliver-runtime-5H2EYniG.js");
+	return await outboundDeliverRuntimePromise;
+}
+async function drainPendingDeliveries(opts) {
+	const deliver = opts.deliver ?? (await loadOutboundDeliverRuntime()).deliverOutboundPayloads;
+	await drainPendingDeliveries$1({
+		...opts,
+		deliver
+	});
+}
+//#endregion
+export { drainPendingDeliveries as t };

package/dist/init-BIbgrtP4.js

@@ -0,0 +1,59 @@
+import { r as registerContextEngineForOwner } from "./registry-DAnIkg-h.js";
+import { n as delegateCompactionToRuntime } from "./delegate-0l_cL2en.js";
+//#region src/context-engine/legacy.ts
+/**
+* LegacyContextEngine wraps the existing compaction behavior behind the
+* ContextEngine interface, preserving 100% backward compatibility.
+*
+* - ingest: no-op (SessionManager handles message persistence)
+* - assemble: pass-through (existing sanitize/validate/limit pipeline in attempt.ts handles this)
+* - compact: delegates to compactEmbeddedPiSessionDirect
+*/
+var LegacyContextEngine = class {
+	constructor() {
+		this.info = {
+			id: "legacy",
+			name: "Legacy Context Engine",
+			version: "1.0.0"
+		};
+	}
+	async ingest(_params) {
+		return { ingested: false };
+	}
+	async assemble(params) {
+		return {
+			messages: params.messages,
+			estimatedTokens: 0
+		};
+	}
+	async afterTurn(_params) {}
+	async compact(params) {
+		return await delegateCompactionToRuntime(params);
+	}
+	async dispose() {}
+};
+//#endregion
+//#region src/context-engine/legacy.registration.ts
+function registerLegacyContextEngine() {
+	registerContextEngineForOwner("legacy", async () => new LegacyContextEngine(), "core", { allowSameOwnerRefresh: true });
+}
+//#endregion
+//#region src/context-engine/init.ts
+/**
+* Ensures all built-in context engines are registered exactly once.
+*
+* The legacy engine is always registered as a safe fallback so that
+* `resolveContextEngine()` can resolve the default "legacy" slot without
+* callers needing to remember manual registration.
+*
+* Additional engines are registered by their own plugins via
+* `api.registerContextEngine()` during plugin load.
+*/
+let initialized = false;
+function ensureContextEnginesInitialized() {
+	if (initialized) return;
+	initialized = true;
+	registerLegacyContextEngine();
+}
+//#endregion
+export { ensureContextEnginesInitialized as t };

package/dist/install-signal-cli-DX67z7U-.js

@@ -0,0 +1,202 @@
+import { i as formatErrorMessage } from "./errors-CufR9eHH.js";
+import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-DPP_aYVc.js";
+import { t as CONFIG_DIR } from "./utils-CWrkFsp0.js";
+import { n as resolvePreferredGenesisTmpDir } from "./tmp-genesis-dir-h5HSqKoN.js";
+import "./text-runtime-Dd2bva2m.js";
+import "./error-runtime-QklRpjU7.js";
+import { t as runPluginCommandWithTimeout } from "./run-command-Dd58DEnj.js";
+import { o as extractArchive } from "./archive-DQTlkN3s.js";
+import { t as resolveBrewExecutable } from "./brew-BX4oWgyb.js";
+import "./setup-tools-B3kHWu80.js";
+import { createWriteStream } from "node:fs";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
+import { pipeline } from "node:stream/promises";
+import { request } from "node:https";
+//#region extensions/signal/src/install-signal-cli.ts
+/** @internal Exported for testing. */
+async function extractSignalCliArchive(archivePath, installRoot, timeoutMs) {
+	await extractArchive({
+		archivePath,
+		destDir: installRoot,
+		timeoutMs
+	});
+}
+/** @internal Exported for testing. */
+function looksLikeArchive(name) {
+	return name.endsWith(".tar.gz") || name.endsWith(".tgz") || name.endsWith(".zip");
+}
+/**
+* Pick a native release asset from the official GitHub releases.
+*
+* The official signal-cli releases only publish native (GraalVM) binaries for
+* x86-64 Linux.  On architectures where no native asset is available this
+* returns `undefined` so the caller can fall back to a different install
+* strategy (e.g. Homebrew).
+*/
+/** @internal Exported for testing. */
+function pickAsset(assets, platform, arch) {
+	const archives = assets.filter((asset) => Boolean(asset.name && asset.browser_download_url)).filter((a) => looksLikeArchive(normalizeLowercaseStringOrEmpty(a.name)));
+	const byName = (pattern) => archives.find((asset) => pattern.test(normalizeLowercaseStringOrEmpty(asset.name)));
+	if (platform === "linux") {
+		if (arch === "x64") return byName(/linux-native/) || byName(/linux/) || archives[0];
+		return;
+	}
+	if (platform === "darwin") return byName(/macos|osx|darwin/) || archives[0];
+	if (platform === "win32") return byName(/windows|win/) || archives[0];
+	return archives[0];
+}
+async function downloadToFile(url, dest, maxRedirects = 5) {
+	await new Promise((resolve, reject) => {
+		const req = request(url, (res) => {
+			if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400) {
+				const location = res.headers.location;
+				if (!location || maxRedirects <= 0) {
+					reject(/* @__PURE__ */ new Error("Redirect loop or missing Location header"));
+					return;
+				}
+				const redirectUrl = new URL(location, url).href;
+				resolve(downloadToFile(redirectUrl, dest, maxRedirects - 1));
+				return;
+			}
+			if (!res.statusCode || res.statusCode >= 400) {
+				reject(/* @__PURE__ */ new Error(`HTTP ${res.statusCode ?? "?"} downloading file`));
+				return;
+			}
+			pipeline(res, createWriteStream(dest)).then(resolve).catch(reject);
+		});
+		req.on("error", reject);
+		req.end();
+	});
+}
+async function findSignalCliBinary(root) {
+	const candidates = [];
+	const enqueue = async (dir, depth) => {
+		if (depth > 3) return;
+		const entries = await fs$1.readdir(dir, { withFileTypes: true }).catch(() => []);
+		for (const entry of entries) {
+			const full = path.join(dir, entry.name);
+			if (entry.isDirectory()) await enqueue(full, depth + 1);
+			else if (entry.isFile() && entry.name === "signal-cli") candidates.push(full);
+		}
+	};
+	await enqueue(root, 0);
+	return candidates[0] ?? null;
+}
+async function resolveBrewSignalCliPath(brewExe) {
+	try {
+		const result = await runPluginCommandWithTimeout({
+			argv: [
+				brewExe,
+				"--prefix",
+				"signal-cli"
+			],
+			timeoutMs: 1e4
+		});
+		if (result.code === 0 && result.stdout.trim()) {
+			const prefix = result.stdout.trim();
+			const candidate = path.join(prefix, "bin", "signal-cli");
+			try {
+				await fs$1.access(candidate);
+				return candidate;
+			} catch {
+				return findSignalCliBinary(prefix);
+			}
+		}
+	} catch {}
+	return null;
+}
+async function installSignalCliViaBrew(runtime) {
+	const brewExe = resolveBrewExecutable();
+	if (!brewExe) return {
+		ok: false,
+		error: `No native signal-cli build is available for ${process.arch}. Install Homebrew (https://brew.sh) and try again, or install signal-cli manually.`
+	};
+	runtime.log(`Installing signal-cli via Homebrew (${brewExe})…`);
+	const result = await runPluginCommandWithTimeout({
+		argv: [
+			brewExe,
+			"install",
+			"signal-cli"
+		],
+		timeoutMs: 15 * 6e4
+	});
+	if (result.code !== 0) return {
+		ok: false,
+		error: `brew install signal-cli failed (exit ${result.code}): ${result.stderr.trim().slice(0, 200)}`
+	};
+	const cliPath = await resolveBrewSignalCliPath(brewExe);
+	if (!cliPath) return {
+		ok: false,
+		error: "brew install succeeded but signal-cli binary was not found."
+	};
+	let version;
+	try {
+		version = (await runPluginCommandWithTimeout({
+			argv: [cliPath, "--version"],
+			timeoutMs: 1e4
+		})).stdout.trim().replace(/^signal-cli\s+/, "") || void 0;
+	} catch {}
+	return {
+		ok: true,
+		cliPath,
+		version
+	};
+}
+async function installSignalCliFromRelease(runtime) {
+	const response = await fetch("https://api.github.com/repos/AsamK/signal-cli/releases/latest", { headers: {
+		"User-Agent": "genesis",
+		Accept: "application/vnd.github+json"
+	} });
+	if (!response.ok) return {
+		ok: false,
+		error: `Failed to fetch release info (${response.status})`
+	};
+	const payload = await response.json();
+	const version = payload.tag_name?.replace(/^v/, "") ?? "unknown";
+	const asset = pickAsset(payload.assets ?? [], process.platform, process.arch);
+	if (!asset) return {
+		ok: false,
+		error: "No compatible release asset found for this platform."
+	};
+	const tmpDir = await fs$1.mkdtemp(path.join(resolvePreferredGenesisTmpDir(), "genesis-signal-"));
+	const archivePath = path.join(tmpDir, asset.name);
+	runtime.log(`Downloading signal-cli ${version} (${asset.name})…`);
+	await downloadToFile(asset.browser_download_url, archivePath);
+	const installRoot = path.join(CONFIG_DIR, "tools", "signal-cli", version);
+	await fs$1.mkdir(installRoot, { recursive: true });
+	if (!looksLikeArchive(normalizeLowercaseStringOrEmpty(asset.name))) return {
+		ok: false,
+		error: `Unsupported archive type: ${asset.name}`
+	};
+	try {
+		await extractSignalCliArchive(archivePath, installRoot, 6e4);
+	} catch (err) {
+		const message = formatErrorMessage(err);
+		return {
+			ok: false,
+			error: `Failed to extract ${asset.name}: ${message}`
+		};
+	}
+	const cliPath = await findSignalCliBinary(installRoot);
+	if (!cliPath) return {
+		ok: false,
+		error: `signal-cli binary not found after extracting ${asset.name}`
+	};
+	await fs$1.chmod(cliPath, 493).catch(() => {});
+	return {
+		ok: true,
+		cliPath,
+		version
+	};
+}
+async function installSignalCli(runtime) {
+	if (process.platform === "win32") return {
+		ok: false,
+		error: "Signal CLI auto-install is not supported on Windows yet."
+	};
+	if (process.platform !== "linux" || process.arch === "x64") return installSignalCliFromRelease(runtime);
+	return installSignalCliViaBrew(runtime);
+}
+//#endregion
+export { pickAsset as i, installSignalCli as n, looksLikeArchive as r, extractSignalCliArchive as t };