@pixelzx/genesis 2026.5.10-6 → 2026.5.14

package/dist/nodes-utils-BQt-uuAy.js

@@ -1,84 +0,0 @@
-import { s as normalizeOptionalLowercaseString } from "./string-coerce-C1IzJjqi.js";
-import { t as callGatewayTool } from "./gateway-y4hbduse.js";
-import { i as parsePairingList, n as resolveNodeIdFromNodeList, r as parseNodeList, t as resolveNodeFromNodeList } from "./node-resolve-BkIWTwFE.js";
-//#region src/agents/tools/nodes-utils.ts
-function messageFromError(error) {
-	if (error instanceof Error) return error.message;
-	if (typeof error === "string") return error;
-	if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") return error.message;
-	if (typeof error === "object" && error !== null) try {
-		return JSON.stringify(error);
-	} catch {
-		return "";
-	}
-	return "";
-}
-function shouldFallbackToPairList(error) {
-	const message = normalizeOptionalLowercaseString(messageFromError(error)) ?? "";
-	if (!message.includes("node.list")) return false;
-	return message.includes("unknown method") || message.includes("method not found") || message.includes("not implemented") || message.includes("unsupported");
-}
-async function loadNodes(opts) {
-	try {
-		return parseNodeList(await callGatewayTool("node.list", opts, {}));
-	} catch (error) {
-		if (!shouldFallbackToPairList(error)) throw error;
-		const { paired } = parsePairingList(await callGatewayTool("node.pair.list", opts, {}));
-		return paired.map((n) => ({
-			nodeId: n.nodeId,
-			displayName: n.displayName,
-			platform: n.platform,
-			remoteIp: n.remoteIp
-		}));
-	}
-}
-function isLocalMacNode(node) {
-	return normalizeOptionalLowercaseString(node.platform)?.startsWith("mac") === true && typeof node.nodeId === "string" && node.nodeId.startsWith("mac-");
-}
-function compareDefaultNodeOrder(a, b) {
-	const aConnectedAt = Number.isFinite(a.connectedAtMs) ? a.connectedAtMs ?? 0 : -1;
-	const bConnectedAt = Number.isFinite(b.connectedAtMs) ? b.connectedAtMs ?? 0 : -1;
-	if (aConnectedAt !== bConnectedAt) return bConnectedAt - aConnectedAt;
-	return a.nodeId.localeCompare(b.nodeId);
-}
-function selectDefaultNodeFromList(nodes, options = {}) {
-	const capability = options.capability?.trim();
-	const withCapability = capability ? nodes.filter((n) => Array.isArray(n.caps) ? n.caps.includes(capability) : true) : nodes;
-	if (withCapability.length === 0) return null;
-	const connected = withCapability.filter((n) => n.connected);
-	const candidates = connected.length > 0 ? connected : withCapability;
-	if (candidates.length === 1) return candidates[0];
-	if (options.preferLocalMac ?? true) {
-		const local = candidates.filter(isLocalMacNode);
-		if (local.length === 1) return local[0];
-	}
-	if ((options.fallback ?? "none") === "none") return null;
-	return [...candidates].toSorted(compareDefaultNodeOrder)[0] ?? null;
-}
-function pickDefaultNode(nodes) {
-	return selectDefaultNodeFromList(nodes, {
-		capability: "canvas",
-		fallback: "first",
-		preferLocalMac: true
-	});
-}
-async function listNodes(opts) {
-	return loadNodes(opts);
-}
-function resolveNodeIdFromList(nodes, query, allowDefault = false) {
-	return resolveNodeIdFromNodeList(nodes, query, {
-		allowDefault,
-		pickDefaultNode
-	});
-}
-async function resolveNodeId(opts, query, allowDefault = false) {
-	return (await resolveNode(opts, query, allowDefault)).nodeId;
-}
-async function resolveNode(opts, query, allowDefault = false) {
-	return resolveNodeFromNodeList(await loadNodes(opts), query, {
-		allowDefault,
-		pickDefaultNode
-	});
-}
-//#endregion
-export { selectDefaultNodeFromList as a, resolveNodeIdFromList as i, resolveNode as n, resolveNodeId as r, listNodes as t };

package/dist/nodes.helpers-CR-REmRH.js

@@ -1,34 +0,0 @@
-import { c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
-import { gn as errorShape, hn as ErrorCodes, t as formatValidationErrors } from "./protocol-D7tGgtdQ.js";
-import { t as formatForLog } from "./ws-log-BG1U86rU.js";
-//#region src/gateway/server-methods/nodes.helpers.ts
-function respondInvalidParams(params) {
-	params.respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid ${params.method} params: ${formatValidationErrors(params.validator.errors)}`));
-}
-async function respondUnavailableOnThrow(respond, fn) {
-	try {
-		await fn();
-	} catch (err) {
-		respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
-	}
-}
-function safeParseJson(value) {
-	const trimmed = normalizeOptionalString(value);
-	if (!trimmed) return;
-	try {
-		return JSON.parse(trimmed);
-	} catch {
-		return { payloadJSON: value };
-	}
-}
-function respondUnavailableOnNodeInvokeError(respond, res) {
-	if (res.ok) return true;
-	const nodeError = res.error && typeof res.error === "object" ? res.error : null;
-	const nodeCode = normalizeOptionalString(nodeError?.code) ?? "";
-	const nodeMessage = normalizeOptionalString(nodeError?.message) ?? "node invoke failed";
-	const message = nodeCode ? `${nodeCode}: ${nodeMessage}` : nodeMessage;
-	respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, message, { details: { nodeError: res.error ?? null } }));
-	return false;
-}
-//#endregion
-export { safeParseJson as i, respondUnavailableOnNodeInvokeError as n, respondUnavailableOnThrow as r, respondInvalidParams as t };

package/dist/notify-jWXMxIvz.js

@@ -1,315 +0,0 @@
-import { i as formatErrorMessage } from "./errors-Jbvi20TW.js";
-import { c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
-import "./text-runtime-COlr0gTx.js";
-import "./error-runtime-DkAvS9GZ.js";
-import { l as listDevicePairing } from "./device-pairing-CiGNjA8A.js";
-import "./api-CKLPVXxC.js";
-import { promises } from "node:fs";
-import path from "node:path";
-//#region extensions/device-pair/notify.ts
-const NOTIFY_STATE_FILE = "device-pair-notify.json";
-const NOTIFY_POLL_INTERVAL_MS = 1e4;
-const NOTIFY_MAX_SEEN_AGE_MS = 1440 * 60 * 1e3;
-function formatStringList(values) {
-	if (!Array.isArray(values) || values.length === 0) return "none";
-	const normalized = values.map((value) => value.trim()).filter((value) => value.length > 0);
-	return normalized.length > 0 ? normalized.join(", ") : "none";
-}
-function formatRoleList(request) {
-	const role = normalizeOptionalString(request.role);
-	if (role) return role;
-	return formatStringList(request.roles);
-}
-function formatScopeList(request) {
-	return formatStringList(request.scopes);
-}
-function formatPendingRequests(pending) {
-	if (pending.length === 0) return "No pending device pairing requests.";
-	const lines = ["Pending device pairing requests:"];
-	for (const req of pending) {
-		const label = normalizeOptionalString(req.displayName) || req.deviceId;
-		const platform = normalizeOptionalString(req.platform);
-		const ip = normalizeOptionalString(req.remoteIp);
-		const parts = [
-			`- ${req.requestId}`,
-			label ? `name=${label}` : null,
-			platform ? `platform=${platform}` : null,
-			`role=${formatRoleList(req)}`,
-			`scopes=${formatScopeList(req)}`,
-			ip ? `ip=${ip}` : null
-		].filter(Boolean);
-		lines.push(parts.join(" · "));
-	}
-	return lines.join("\n");
-}
-function resolveNotifyStatePath(stateDir) {
-	return path.join(stateDir, NOTIFY_STATE_FILE);
-}
-function normalizeNotifyState(raw) {
-	const root = typeof raw === "object" && raw !== null ? raw : {};
-	const subscribersRaw = Array.isArray(root.subscribers) ? root.subscribers : [];
-	const notifiedRaw = typeof root.notifiedRequestIds === "object" && root.notifiedRequestIds !== null ? root.notifiedRequestIds : {};
-	const subscribers = [];
-	for (const item of subscribersRaw) {
-		if (typeof item !== "object" || item === null) continue;
-		const record = item;
-		const to = normalizeOptionalString(record.to) ?? "";
-		if (!to) continue;
-		const accountId = normalizeOptionalString(record.accountId) ?? void 0;
-		const messageThreadId = typeof record.messageThreadId === "string" ? normalizeOptionalString(record.messageThreadId) || void 0 : typeof record.messageThreadId === "number" && Number.isFinite(record.messageThreadId) ? Math.trunc(record.messageThreadId) : void 0;
-		const mode = record.mode === "once" ? "once" : "persistent";
-		const addedAtMs = typeof record.addedAtMs === "number" && Number.isFinite(record.addedAtMs) ? Math.trunc(record.addedAtMs) : Date.now();
-		subscribers.push({
-			to,
-			accountId,
-			messageThreadId,
-			mode,
-			addedAtMs
-		});
-	}
-	const notifiedRequestIds = {};
-	for (const [requestId, ts] of Object.entries(notifiedRaw)) {
-		const normalizedRequestId = normalizeOptionalString(requestId);
-		if (!normalizedRequestId) continue;
-		if (typeof ts !== "number" || !Number.isFinite(ts) || ts <= 0) continue;
-		notifiedRequestIds[normalizedRequestId] = Math.trunc(ts);
-	}
-	return {
-		subscribers,
-		notifiedRequestIds
-	};
-}
-async function readNotifyState(filePath) {
-	try {
-		const content = await promises.readFile(filePath, "utf8");
-		return normalizeNotifyState(JSON.parse(content));
-	} catch {
-		return {
-			subscribers: [],
-			notifiedRequestIds: {}
-		};
-	}
-}
-async function writeNotifyState(filePath, state) {
-	await promises.mkdir(path.dirname(filePath), { recursive: true });
-	const content = JSON.stringify(state, null, 2);
-	await promises.writeFile(filePath, `${content}\n`, "utf8");
-}
-function notifySubscriberKey(subscriber) {
-	return JSON.stringify([
-		subscriber.to,
-		subscriber.accountId ?? "",
-		normalizeNotifyThreadKey(subscriber.messageThreadId)
-	]);
-}
-function normalizeNotifyThreadKey(messageThreadId) {
-	if (typeof messageThreadId === "number" && Number.isFinite(messageThreadId)) return String(Math.trunc(messageThreadId));
-	if (typeof messageThreadId !== "string") return "";
-	const normalized = normalizeOptionalString(messageThreadId);
-	if (!normalized) return "";
-	if (!/^-?\d+$/u.test(normalized)) return normalized;
-	try {
-		return BigInt(normalized).toString();
-	} catch {
-		return normalized;
-	}
-}
-function resolveNotifyTarget(ctx) {
-	const to = normalizeOptionalString(ctx.senderId) || normalizeOptionalString(ctx.from) || normalizeOptionalString(ctx.to) || "";
-	if (!to) return null;
-	return {
-		to,
-		...ctx.accountId ? { accountId: ctx.accountId } : {},
-		...ctx.messageThreadId != null ? { messageThreadId: ctx.messageThreadId } : {}
-	};
-}
-function upsertNotifySubscriber(subscribers, target, mode) {
-	const key = notifySubscriberKey(target);
-	const index = subscribers.findIndex((entry) => notifySubscriberKey(entry) === key);
-	const next = {
-		...target,
-		mode,
-		addedAtMs: Date.now()
-	};
-	if (index === -1) {
-		subscribers.push(next);
-		return true;
-	}
-	if (subscribers[index]?.mode === mode) return false;
-	subscribers[index] = next;
-	return true;
-}
-function buildPairingRequestNotificationText(request) {
-	const label = normalizeOptionalString(request.displayName) || request.deviceId;
-	const platform = normalizeOptionalString(request.platform);
-	const ip = normalizeOptionalString(request.remoteIp);
-	const role = formatRoleList(request);
-	const scopes = formatScopeList(request);
-	return [
-		"📲 New device pairing request",
-		`ID: ${request.requestId}`,
-		`Name: ${label}`,
-		...platform ? [`Platform: ${platform}`] : [],
-		`Role: ${role}`,
-		`Scopes: ${scopes}`,
-		...ip ? [`IP: ${ip}`] : [],
-		"",
-		`Approve: /pair approve ${request.requestId}`,
-		"List pending: /pair pending"
-	].join("\n");
-}
-function requestTimestampMs(request) {
-	if (typeof request.ts !== "number" || !Number.isFinite(request.ts)) return null;
-	const ts = Math.trunc(request.ts);
-	return ts > 0 ? ts : null;
-}
-function shouldNotifySubscriberForRequest(subscriber, request) {
-	if (subscriber.mode !== "once") return true;
-	const ts = requestTimestampMs(request);
-	if (ts == null) return false;
-	return ts >= subscriber.addedAtMs;
-}
-async function notifySubscriber(params) {
-	const send = (await params.api.runtime.channel.outbound.loadAdapter("telegram"))?.sendText;
-	if (!send) {
-		params.api.logger.warn("device-pair: telegram outbound adapter unavailable for pairing notifications");
-		return false;
-	}
-	try {
-		await send({
-			cfg: params.api.config,
-			to: params.subscriber.to,
-			text: params.text,
-			...params.subscriber.accountId ? { accountId: params.subscriber.accountId } : {},
-			...params.subscriber.messageThreadId != null ? { threadId: params.subscriber.messageThreadId } : {}
-		});
-		return true;
-	} catch (err) {
-		params.api.logger.warn(`device-pair: failed to send pairing notification to ${params.subscriber.to}: ${formatErrorMessage(err)}`);
-		return false;
-	}
-}
-async function notifyPendingPairingRequests(params) {
-	const state = await readNotifyState(params.statePath);
-	const pending = (await listDevicePairing()).pending;
-	const now = Date.now();
-	const pendingIds = new Set(pending.map((entry) => entry.requestId));
-	let changed = false;
-	for (const [requestId, ts] of Object.entries(state.notifiedRequestIds)) if (!pendingIds.has(requestId) || now - ts > NOTIFY_MAX_SEEN_AGE_MS) {
-		delete state.notifiedRequestIds[requestId];
-		changed = true;
-	}
-	if (state.subscribers.length > 0) {
-		const oneShotDelivered = /* @__PURE__ */ new Set();
-		for (const request of pending) {
-			if (state.notifiedRequestIds[request.requestId]) continue;
-			const text = buildPairingRequestNotificationText(request);
-			let delivered = false;
-			for (const subscriber of state.subscribers) {
-				if (!shouldNotifySubscriberForRequest(subscriber, request)) continue;
-				const sent = await notifySubscriber({
-					api: params.api,
-					subscriber,
-					text
-				});
-				delivered = delivered || sent;
-				if (sent && subscriber.mode === "once") oneShotDelivered.add(notifySubscriberKey(subscriber));
-			}
-			if (delivered) {
-				state.notifiedRequestIds[request.requestId] = now;
-				changed = true;
-			}
-		}
-		if (oneShotDelivered.size > 0) {
-			const initialCount = state.subscribers.length;
-			state.subscribers = state.subscribers.filter((subscriber) => !oneShotDelivered.has(notifySubscriberKey(subscriber)));
-			if (state.subscribers.length !== initialCount) changed = true;
-		}
-	}
-	if (changed) await writeNotifyState(params.statePath, state);
-}
-async function armPairNotifyOnce(params) {
-	if (params.ctx.channel !== "telegram") return false;
-	const target = resolveNotifyTarget(params.ctx);
-	if (!target) return false;
-	const statePath = resolveNotifyStatePath(params.api.runtime.state.resolveStateDir());
-	const state = await readNotifyState(statePath);
-	let changed = false;
-	if (upsertNotifySubscriber(state.subscribers, target, "once")) changed = true;
-	if (changed) await writeNotifyState(statePath, state);
-	return true;
-}
-async function handleNotifyCommand(params) {
-	if (params.ctx.channel !== "telegram") return { text: "Pairing notifications are currently supported only on Telegram." };
-	const target = resolveNotifyTarget(params.ctx);
-	if (!target) return { text: "Could not resolve Telegram target for this chat." };
-	const statePath = resolveNotifyStatePath(params.api.runtime.state.resolveStateDir());
-	const state = await readNotifyState(statePath);
-	const targetKey = notifySubscriberKey(target);
-	const current = state.subscribers.find((entry) => notifySubscriberKey(entry) === targetKey);
-	if (params.action === "on" || params.action === "enable") {
-		if (upsertNotifySubscriber(state.subscribers, target, "persistent")) await writeNotifyState(statePath, state);
-		return { text: "✅ Pair request notifications enabled for this Telegram chat.\nI will ping here when a new device pairing request arrives." };
-	}
-	if (params.action === "off" || params.action === "disable") {
-		const currentIndex = state.subscribers.findIndex((entry) => notifySubscriberKey(entry) === targetKey);
-		if (currentIndex !== -1) {
-			state.subscribers.splice(currentIndex, 1);
-			await writeNotifyState(statePath, state);
-		}
-		return { text: "✅ Pair request notifications disabled for this Telegram chat." };
-	}
-	if (params.action === "once" || params.action === "arm") {
-		await armPairNotifyOnce({
-			api: params.api,
-			ctx: params.ctx
-		});
-		return { text: "✅ One-shot pairing notification armed for this Telegram chat.\nI will notify on the next new pairing request, then auto-disable." };
-	}
-	if (params.action === "status" || params.action === "") {
-		const pending = await listDevicePairing();
-		const enabled = Boolean(current);
-		const mode = current?.mode ?? "off";
-		return { text: [
-			`Pair request notifications: ${enabled ? "enabled" : "disabled"} for this chat.`,
-			`Mode: ${mode}`,
-			`Subscribers: ${state.subscribers.length}`,
-			`Pending requests: ${pending.pending.length}`,
-			"",
-			"Use /pair notify on|off|once"
-		].join("\n") };
-	}
-	return { text: "Usage: /pair notify on|off|once|status" };
-}
-function registerPairingNotifierService(api) {
-	let notifyInterval = null;
-	api.registerService({
-		id: "device-pair-notifier",
-		start: async (ctx) => {
-			const statePath = resolveNotifyStatePath(ctx.stateDir);
-			const tick = async () => {
-				await notifyPendingPairingRequests({
-					api,
-					statePath
-				});
-			};
-			await tick().catch((err) => {
-				api.logger.warn(`device-pair: initial notify poll failed: ${formatErrorMessage(err)}`);
-			});
-			notifyInterval = setInterval(() => {
-				tick().catch((err) => {
-					api.logger.warn(`device-pair: notify poll failed: ${formatErrorMessage(err)}`);
-				});
-			}, NOTIFY_POLL_INTERVAL_MS);
-			notifyInterval.unref?.();
-		},
-		stop: async () => {
-			if (notifyInterval) {
-				clearInterval(notifyInterval);
-				notifyInterval = null;
-			}
-		}
-	});
-}
-//#endregion
-export { registerPairingNotifierService as i, formatPendingRequests as n, handleNotifyCommand as r, armPairNotifyOnce as t };

package/dist/onboard-aFjTZo55.js

@@ -1,2 +0,0 @@
-import { t as setupWizardCommand } from "./onboard-vwvBfbu_.js";
-export { setupWizardCommand };

package/dist/onboard-helpers-Clk6YSB9.js

@@ -1,6 +0,0 @@
-import { t as randomToken } from "./random-token-B_Oj5J92.js";
-import { t as resolveControlUiLinks } from "./control-ui-links-BvGEIgO7.js";
-import { t as detectBinary } from "./detect-binary-Dp1j8RBD.js";
-import { i as resolveBrowserOpenCommand, n as openUrl, r as openUrlInBackground, t as detectBrowserOpenSupport } from "./browser-open-Deu6w4qr.js";
-import { a as guardCancel, c as normalizeGatewayTokenInput, d as resolveNodeManagerOptions, f as summarizeExistingConfig, i as formatControlUiSshHint, l as printWizardHeader, m as waitForGatewayReachable, n as applyWizardMetadata, o as handleReset, p as validateGatewayPasswordInput, r as ensureWorkspaceAndSessions, s as moveToTrash, t as DEFAULT_WORKSPACE, u as probeGatewayReachable } from "./onboard-helpers-WR8JC0sA.js";
-export { DEFAULT_WORKSPACE, applyWizardMetadata, detectBinary, detectBrowserOpenSupport, ensureWorkspaceAndSessions, formatControlUiSshHint, guardCancel, handleReset, moveToTrash, normalizeGatewayTokenInput, openUrl, openUrlInBackground, printWizardHeader, probeGatewayReachable, randomToken, resolveBrowserOpenCommand, resolveControlUiLinks, resolveNodeManagerOptions, summarizeExistingConfig, validateGatewayPasswordInput, waitForGatewayReachable };

package/dist/onboard-helpers-WR8JC0sA.js

@@ -1,204 +0,0 @@
-import { c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
-import { _ as shortenHomePath, f as resolveConfigDir, g as shortenHomeInString, v as sleep } from "./utils-DaGfogP-.js";
-import { o as resolveConfigPath } from "./paths-DmR9mjUX.js";
-import { n as VERSION } from "./version-BoqlEm3e.js";
-import { r as runCommandWithTimeout } from "./exec-CKo0c2Rj.js";
-import { n as resolveAgentModelPrimaryValue } from "./model-input-BkKFdMSQ.js";
-import { n as DEFAULT_AGENT_WORKSPACE_DIR, u as ensureAgentWorkspace } from "./workspace-DkmPqUjp.js";
-import { a as probeGateway } from "./probe-Be9MFi-d.js";
-import { r as normalizeControlUiBasePath } from "./control-ui-shared-BdBCVxcc.js";
-import "./control-ui-links-BvGEIgO7.js";
-import { l as resolveSessionTranscriptsDirForAgent } from "./paths-DD6L4IvS.js";
-import "./detect-binary-Dp1j8RBD.js";
-import { r as stylePromptTitle } from "./prompt-style-CUl1QYpa.js";
-import "./browser-open-Deu6w4qr.js";
-import path from "node:path";
-import fs from "node:fs/promises";
-import { inspect } from "node:util";
-import { cancel, isCancel } from "@clack/prompts";
-//#region src/commands/onboard-helpers.ts
-function guardCancel(value, runtime) {
-	if (isCancel(value)) {
-		cancel(stylePromptTitle("Setup cancelled.") ?? "Setup cancelled.");
-		runtime.exit(0);
-		throw new Error("unreachable");
-	}
-	return value;
-}
-function summarizeExistingConfig(config) {
-	const rows = [];
-	const defaults = config.agents?.defaults;
-	if (defaults?.workspace) rows.push(shortenHomeInString(`workspace: ${defaults.workspace}`));
-	if (defaults?.model) {
-		const model = resolveAgentModelPrimaryValue(defaults.model);
-		if (model) rows.push(shortenHomeInString(`model: ${model}`));
-	}
-	if (config.gateway?.mode) rows.push(shortenHomeInString(`gateway.mode: ${config.gateway.mode}`));
-	if (typeof config.gateway?.port === "number") rows.push(shortenHomeInString(`gateway.port: ${config.gateway.port}`));
-	if (config.gateway?.bind) rows.push(shortenHomeInString(`gateway.bind: ${config.gateway.bind}`));
-	if (config.gateway?.remote?.url) rows.push(shortenHomeInString(`gateway.remote.url: ${config.gateway.remote.url}`));
-	if (config.skills?.install?.nodeManager) rows.push(shortenHomeInString(`skills.nodeManager: ${config.skills.install.nodeManager}`));
-	return rows.length ? rows.join("\n") : "No key settings detected.";
-}
-function normalizeGatewayTokenInput(value) {
-	if (typeof value !== "string") return "";
-	const trimmed = value.trim();
-	if (trimmed === "undefined" || trimmed === "null") return "";
-	return trimmed;
-}
-function validateGatewayPasswordInput(value) {
-	if (typeof value !== "string") return "Required";
-	const trimmed = value.trim();
-	if (!trimmed) return "Required";
-	if (trimmed === "undefined" || trimmed === "null") return "Cannot be the literal string \"undefined\" or \"null\"";
-}
-function printWizardHeader(runtime) {
-	const header = [
-		"  ____                           _",
-		" / ___| ___ _ __   ___  ___ ___(_)___",
-		"| |  _ / _ \\ '_ \\ / _ \\/ __/ __| / __|",
-		"| |_| |  __/ | | |  __/\\__ \\__ \\ \\__ \\",
-		" \\____|\\___|_| |_|\\___||___/___/_|___/",
-		"",
-		"             GENESIS ONBOARDING"
-	].join("\n");
-	runtime.log(header);
-}
-function applyWizardMetadata(cfg, params) {
-	const commit = normalizeOptionalString(process.env.GIT_COMMIT) ?? normalizeOptionalString(process.env.GIT_SHA);
-	return {
-		...cfg,
-		wizard: {
-			...cfg.wizard,
-			lastRunAt: (/* @__PURE__ */ new Date()).toISOString(),
-			lastRunVersion: VERSION,
-			lastRunCommit: commit,
-			lastRunCommand: params.command,
-			lastRunMode: params.mode
-		}
-	};
-}
-function formatControlUiSshHint(params) {
-	const basePath = normalizeControlUiBasePath(params.basePath);
-	const uiPath = basePath ? `${basePath}/` : "/";
-	const localUrl = `http://localhost:${params.port}${uiPath}`;
-	const authedUrl = params.token ? `${localUrl}#token=${encodeURIComponent(params.token)}` : void 0;
-	const sshTarget = resolveSshTargetHint();
-	return [
-		"No GUI detected. Open from your computer:",
-		`ssh -N -L ${params.port}:127.0.0.1:${params.port} ${sshTarget}`,
-		"Then open:",
-		localUrl,
-		authedUrl,
-		"Docs:",
-		"https://docs.genesis.ai/gateway/remote",
-		"https://docs.genesis.ai/web/control-ui"
-	].filter(Boolean).join("\n");
-}
-function resolveSshTargetHint() {
-	return `${process.env.USER || process.env.LOGNAME || "user"}@${(process.env.SSH_CONNECTION?.trim().split(/\s+/))?.[2] ?? "<host>"}`;
-}
-async function ensureWorkspaceAndSessions(workspaceDir, runtime, options) {
-	const ws = await ensureAgentWorkspace({
-		dir: workspaceDir,
-		ensureBootstrapFiles: !options?.skipBootstrap
-	});
-	runtime.log(`Workspace OK: ${shortenHomePath(ws.dir)}`);
-	const sessionsDir = resolveSessionTranscriptsDirForAgent(options?.agentId);
-	await fs.mkdir(sessionsDir, { recursive: true });
-	runtime.log(`Sessions OK: ${shortenHomePath(sessionsDir)}`);
-}
-function resolveNodeManagerOptions() {
-	return [
-		{
-			value: "npm",
-			label: "npm"
-		},
-		{
-			value: "pnpm",
-			label: "pnpm"
-		},
-		{
-			value: "bun",
-			label: "bun"
-		}
-	];
-}
-async function moveToTrash(pathname, runtime) {
-	if (!pathname) return;
-	try {
-		await fs.access(pathname);
-	} catch {
-		return;
-	}
-	try {
-		await runCommandWithTimeout(["trash", pathname], { timeoutMs: 5e3 });
-		runtime.log(`Moved to Trash: ${shortenHomePath(pathname)}`);
-	} catch {
-		runtime.log(`Failed to move to Trash (manual delete): ${shortenHomePath(pathname)}`);
-	}
-}
-async function handleReset(scope, workspaceDir, runtime) {
-	await moveToTrash(resolveConfigPath(), runtime);
-	if (scope === "config") return;
-	await moveToTrash(path.join(resolveConfigDir(), "credentials"), runtime);
-	await moveToTrash(resolveSessionTranscriptsDirForAgent(), runtime);
-	if (scope === "full") await moveToTrash(workspaceDir, runtime);
-}
-async function probeGatewayReachable(params) {
-	const url = params.url.trim();
-	const timeoutMs = params.timeoutMs ?? 1500;
-	try {
-		const probe = await probeGateway({
-			url,
-			timeoutMs,
-			auth: {
-				token: params.token,
-				password: params.password
-			},
-			detailLevel: "none"
-		});
-		return probe.ok ? { ok: true } : {
-			ok: false,
-			detail: probe.error ?? void 0
-		};
-	} catch (err) {
-		return {
-			ok: false,
-			detail: summarizeError(err)
-		};
-	}
-}
-async function waitForGatewayReachable(params) {
-	const deadlineMs = params.deadlineMs ?? 15e3;
-	const pollMs = params.pollMs ?? 400;
-	const probeTimeoutMs = params.probeTimeoutMs ?? 1500;
-	const startedAt = Date.now();
-	let lastDetail;
-	while (Date.now() - startedAt < deadlineMs) {
-		const probe = await probeGatewayReachable({
-			url: params.url,
-			token: params.token,
-			password: params.password,
-			timeoutMs: probeTimeoutMs
-		});
-		if (probe.ok) return probe;
-		lastDetail = probe.detail;
-		await sleep(pollMs);
-	}
-	return {
-		ok: false,
-		detail: lastDetail
-	};
-}
-function summarizeError(err) {
-	let raw = "unknown error";
-	if (err instanceof Error) raw = err.message || raw;
-	else if (typeof err === "string") raw = err || raw;
-	else if (err !== void 0) raw = inspect(err, { depth: 2 });
-	const line = raw.split("\n").map((s) => s.trim()).find(Boolean) ?? raw;
-	return line.length > 120 ? `${line.slice(0, 119)}…` : line;
-}
-const DEFAULT_WORKSPACE = DEFAULT_AGENT_WORKSPACE_DIR;
-//#endregion
-export { guardCancel as a, normalizeGatewayTokenInput as c, resolveNodeManagerOptions as d, summarizeExistingConfig as f, formatControlUiSshHint as i, printWizardHeader as l, waitForGatewayReachable as m, applyWizardMetadata as n, handleReset as o, validateGatewayPasswordInput as p, ensureWorkspaceAndSessions as r, moveToTrash as s, DEFAULT_WORKSPACE as t, probeGatewayReachable as u };

package/dist/onboard-interactive-CDL7gkJZ.js

@@ -1,24 +0,0 @@
-import { t as restoreTerminalState } from "./restore-Ca_QrWKB.js";
-import { n as defaultRuntime } from "./runtime-CQ7eH0le.js";
-import { t as WizardCancelledError } from "./prompts-Sujn_7Nr.js";
-import { t as createClackPrompter } from "./clack-prompter-_dvl41zo.js";
-import { t as runSetupWizard } from "./setup-B6pSihNi.js";
-//#region src/commands/onboard-interactive.ts
-async function runInteractiveSetup(opts, runtime = defaultRuntime) {
-	const prompter = createClackPrompter();
-	let exitCode = null;
-	try {
-		await runSetupWizard(opts, runtime, prompter);
-	} catch (err) {
-		if (err instanceof WizardCancelledError) {
-			exitCode = 1;
-			return;
-		}
-		throw err;
-	} finally {
-		restoreTerminalState("setup finish", { resumeStdinIfPaused: false });
-		if (exitCode !== null) runtime.exit(exitCode);
-	}
-}
-//#endregion
-export { runInteractiveSetup };