@pixelzx/genesis 2026.6.6-1 → 2026.6.7

package/dist/onboard-a4m7JstV.js

@@ -0,0 +1,316 @@
+import { i as formatErrorMessage } from "./errors-CufR9eHH.js";
+import { c as normalizeOptionalString, d as normalizeStringifiedOptionalString } from "./string-coerce-DPP_aYVc.js";
+import { n as fetchWithSsrFGuard } from "./fetch-guard-CHbFjcDr.js";
+import "./text-runtime-Dd2bva2m.js";
+import "./error-runtime-QklRpjU7.js";
+import "./ssrf-runtime-CetK5Qy_.js";
+import { n as DEFAULT_API, p as extractFoundryEndpoint, r as DEFAULT_GPT5_API, u as buildFoundryProviderBaseUrl, v as requiresFoundryMaxCompletionTokens, w as usesFoundryResponsesByDefault } from "./shared-CTrgq8xV.js";
+import { a as getAccessTokenResult, n as azLoginDeviceCodeWithOptions, r as execAz, s as getLoggedInAccount, t as azLoginDeviceCode } from "./cli-Ct2Cgbp8.js";
+//#region extensions/microsoft-foundry/onboard.ts
+function listFoundryResources(subscriptionId) {
+	try {
+		const accounts = JSON.parse(execAz([
+			"cognitiveservices",
+			"account",
+			"list",
+			...subscriptionId ? ["--subscription", subscriptionId] : [],
+			"--query",
+			"[].{id:id,name:name,kind:kind,location:location,resourceGroup:resourceGroup,endpoint:properties.endpoint,customSubdomain:properties.customSubDomainName,projects:properties.associatedProjects}",
+			"--output",
+			"json"
+		]));
+		const resources = [];
+		for (const account of accounts) {
+			if (!account.resourceGroup) continue;
+			if (account.kind === "OpenAI") {
+				const endpoint = extractFoundryEndpoint(account.endpoint);
+				if (!endpoint) continue;
+				resources.push({
+					id: account.id,
+					accountName: account.name,
+					kind: "OpenAI",
+					location: account.location,
+					resourceGroup: account.resourceGroup,
+					endpoint,
+					projects: []
+				});
+				continue;
+			}
+			if (account.kind !== "AIServices") continue;
+			const customSubdomain = normalizeOptionalString(account.customSubdomain);
+			const endpoint = customSubdomain ? `https://${customSubdomain}.services.ai.azure.com` : void 0;
+			if (!endpoint) continue;
+			resources.push({
+				id: account.id,
+				accountName: account.name,
+				kind: "AIServices",
+				location: account.location,
+				resourceGroup: account.resourceGroup,
+				endpoint,
+				projects: Array.isArray(account.projects) ? account.projects.filter((project) => typeof project === "string") : []
+			});
+		}
+		return resources;
+	} catch {
+		return [];
+	}
+}
+function listResourceDeployments(resource, subscriptionId) {
+	try {
+		return JSON.parse(execAz([
+			"cognitiveservices",
+			"account",
+			"deployment",
+			"list",
+			...subscriptionId ? ["--subscription", subscriptionId] : [],
+			"-g",
+			resource.resourceGroup,
+			"-n",
+			resource.accountName,
+			"--query",
+			"[].{name:name,modelName:properties.model.name,modelVersion:properties.model.version,state:properties.provisioningState,sku:sku.name}",
+			"--output",
+			"json"
+		])).filter((deployment) => deployment.state === "Succeeded");
+	} catch {
+		return [];
+	}
+}
+function buildCreateFoundryHint(selectedSub) {
+	return [
+		`No Azure AI Foundry or Azure OpenAI resources were found in subscription ${selectedSub.name} (${selectedSub.id}).`,
+		"Create one in Azure AI Foundry or Azure Portal, then rerun onboard.",
+		"Azure AI Foundry: https://ai.azure.com",
+		"Azure OpenAI docs: https://learn.microsoft.com/azure/ai-foundry/openai/how-to/create-resource"
+	].join("\n");
+}
+async function selectFoundryResource(ctx, selectedSub) {
+	const resources = listFoundryResources(selectedSub.id);
+	if (resources.length === 0) throw new Error(buildCreateFoundryHint(selectedSub));
+	if (resources.length === 1) {
+		const only = resources[0];
+		await ctx.prompter.note(`Using ${only.kind === "AIServices" ? "Azure AI Foundry" : "Azure OpenAI"} resource: ${only.accountName}`, "Foundry Resource");
+		return only;
+	}
+	const selectedResourceId = await ctx.prompter.select({
+		message: "Select Azure AI Foundry / Azure OpenAI resource",
+		options: resources.map((resource) => ({
+			value: resource.id,
+			label: `${resource.accountName} (${resource.kind === "AIServices" ? "Azure AI Foundry" : "Azure OpenAI"}${resource.location ? `, ${resource.location}` : ""})`,
+			hint: [`RG: ${resource.resourceGroup}`, resource.projects.length > 0 ? `${resource.projects.length} project(s)` : void 0].filter(Boolean).join(" | ")
+		}))
+	});
+	return resources.find((resource) => resource.id === selectedResourceId) ?? resources[0];
+}
+async function selectFoundryDeployment(ctx, resource, deployments) {
+	if (deployments.length === 0) throw new Error([`No model deployments were found in ${resource.accountName}.`, "Deploy a model in Azure AI Foundry or Azure OpenAI, then rerun onboard."].join("\n"));
+	if (deployments.length === 1) {
+		const only = deployments[0];
+		await ctx.prompter.note(`Using deployment: ${only.name}`, "Model Deployment");
+		return only;
+	}
+	const selectedDeploymentName = await ctx.prompter.select({
+		message: "Select model deployment",
+		options: deployments.map((deployment) => ({
+			value: deployment.name,
+			label: deployment.name,
+			hint: [
+				deployment.modelName,
+				deployment.modelVersion,
+				deployment.sku
+			].filter(Boolean).join(" | ")
+		}))
+	});
+	return deployments.find((deployment) => deployment.name === selectedDeploymentName) ?? deployments[0];
+}
+async function promptFoundryApi(ctx, initialApi) {
+	return await ctx.prompter.select({
+		message: "Select request API",
+		options: [{
+			value: DEFAULT_GPT5_API,
+			label: "Responses API",
+			hint: "Recommended for Azure OpenAI GPT, o-series, and Codex deployments"
+		}, {
+			value: "openai-completions",
+			label: "Chat Completions API",
+			hint: "Use for Foundry models that only expose chat/completions semantics"
+		}],
+		initialValue: initialApi
+	});
+}
+async function promptFoundryModelFamily(ctx) {
+	return await ctx.prompter.select({
+		message: "Model family",
+		options: [{
+			value: "reasoning-family",
+			label: "GPT-5 series / o-series / Codex",
+			hint: "Use for Azure OpenAI reasoning and Codex deployments"
+		}, {
+			value: "other-chat",
+			label: "Other chat model",
+			hint: "Use for other chat/completions style Foundry models"
+		}],
+		initialValue: "reasoning-family"
+	});
+}
+async function promptEndpointAndModelBase(ctx, options) {
+	const endpoint = (await ctx.prompter.text({
+		message: "Microsoft Foundry endpoint URL",
+		placeholder: "https://xxx.openai.azure.com or https://xxx.services.ai.azure.com",
+		...options?.endpointInitialValue ? { initialValue: options.endpointInitialValue } : {},
+		validate: (v) => {
+			const val = normalizeStringifiedOptionalString(v) ?? "";
+			if (!val) return "Endpoint URL is required";
+			return URL.canParse(val) ? void 0 : "Invalid URL";
+		}
+	})).trim();
+	const modelId = (await ctx.prompter.text({
+		message: "Default model/deployment name",
+		...options?.modelInitialValue ? { initialValue: options.modelInitialValue } : {},
+		placeholder: "gpt-4o",
+		validate: (v) => {
+			if (!(normalizeStringifiedOptionalString(v) ?? "")) return "Model ID is required";
+		}
+	})).trim();
+	const familyChoice = await promptFoundryModelFamily(ctx);
+	const resolvedModelName = familyChoice === "reasoning-family" ? usesFoundryResponsesByDefault(modelId) || requiresFoundryMaxCompletionTokens(modelId) ? modelId : "gpt-5" : void 0;
+	const api = await promptFoundryApi(ctx, familyChoice === "reasoning-family" ? DEFAULT_GPT5_API : DEFAULT_API);
+	return {
+		endpoint,
+		modelId,
+		...resolvedModelName ? { modelNameHint: resolvedModelName } : {},
+		api
+	};
+}
+async function promptEndpointAndModelManually(ctx) {
+	return promptEndpointAndModelBase(ctx);
+}
+async function promptApiKeyEndpointAndModel(ctx) {
+	return promptEndpointAndModelBase(ctx, {
+		endpointInitialValue: process.env.AZURE_OPENAI_ENDPOINT,
+		modelInitialValue: "gpt-4o"
+	});
+}
+function buildFoundryConnectionTest(params) {
+	const baseUrl = buildFoundryProviderBaseUrl(params.endpoint, params.modelId, params.modelNameHint, params.api);
+	if (params.api === "openai-responses") return {
+		url: `${baseUrl}/responses`,
+		body: {
+			model: params.modelId,
+			input: "hi",
+			max_output_tokens: 16
+		}
+	};
+	return {
+		url: `${baseUrl}/chat/completions`,
+		body: {
+			model: params.modelId,
+			messages: [{
+				role: "user",
+				content: "hi"
+			}],
+			max_tokens: 1
+		}
+	};
+}
+function extractTenantSuggestions(rawMessage) {
+	const suggestions = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const match of rawMessage.matchAll(/([0-9a-fA-F-]{36})(?:\s+'([^'\r\n]+)')?/g)) {
+		const id = normalizeOptionalString(match[1]);
+		if (!id || seen.has(id)) continue;
+		seen.add(id);
+		suggestions.push({
+			id,
+			...normalizeOptionalString(match[2]) ? { label: normalizeOptionalString(match[2]) } : {}
+		});
+	}
+	return suggestions;
+}
+function isValidTenantIdentifier(value) {
+	const trimmed = normalizeOptionalString(value) ?? "";
+	if (!trimmed) return false;
+	const isTenantUuid = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(trimmed);
+	const isTenantDomain = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)+$/.test(trimmed);
+	return isTenantUuid || isTenantDomain;
+}
+async function promptTenantId(ctx, params) {
+	const suggestionLines = params?.suggestions && params.suggestions.length > 0 ? params.suggestions.map((entry) => `- ${entry.id}${entry.label ? ` (${entry.label})` : ""}`) : [];
+	if (params?.reason || suggestionLines.length > 0) await ctx.prompter.note([
+		params?.reason,
+		suggestionLines.length > 0 ? "Suggested tenants:" : void 0,
+		...suggestionLines
+	].filter(Boolean).join("\n"), "Azure Tenant");
+	return (await ctx.prompter.text({
+		message: params?.required ? "Azure tenant ID" : "Azure tenant ID (optional)",
+		placeholder: params?.suggestions?.[0]?.id ?? "00000000-0000-0000-0000-000000000000",
+		validate: (value) => {
+			const trimmed = normalizeStringifiedOptionalString(value) ?? "";
+			if (!trimmed) return params?.required ? "Tenant ID is required" : void 0;
+			return isValidTenantIdentifier(trimmed) ? void 0 : "Enter a valid tenant ID or tenant domain";
+		}
+	})).trim() || void 0;
+}
+async function loginWithTenantFallback(ctx) {
+	try {
+		await azLoginDeviceCode();
+		return { account: getLoggedInAccount() };
+	} catch (error) {
+		const message = formatErrorMessage(error);
+		if (!(/AADSTS\d+/i.test(message) || /no subscriptions found/i.test(message) || /Please provide a valid tenant/i.test(message) || /tenant.*not found/i.test(message))) throw error;
+		const tenantId = await promptTenantId(ctx, {
+			suggestions: extractTenantSuggestions(message),
+			required: true,
+			reason: "Azure login needs a tenant-scoped retry. This often happens when your tenant requires MFA or your account has no Azure subscriptions."
+		});
+		await azLoginDeviceCodeWithOptions({
+			tenantId,
+			allowNoSubscriptions: true
+		});
+		return {
+			account: getLoggedInAccount(),
+			tenantId
+		};
+	}
+}
+async function testFoundryConnection(params) {
+	try {
+		const { accessToken } = getAccessTokenResult({
+			subscriptionId: params.subscriptionId,
+			tenantId: params.tenantId
+		});
+		const testRequest = buildFoundryConnectionTest({
+			endpoint: params.endpoint,
+			modelId: params.modelId,
+			modelNameHint: params.modelNameHint,
+			api: params.api
+		});
+		const { response: res, release } = await fetchWithSsrFGuard({
+			url: testRequest.url,
+			init: {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${accessToken}`,
+					"Content-Type": "application/json"
+				},
+				body: JSON.stringify(testRequest.body)
+			},
+			timeoutMs: 15e3
+		});
+		try {
+			if (res.status === 400) {
+				const body = await res.text().catch(() => "");
+				await params.ctx.prompter.note(`Endpoint is reachable but returned 400 Bad Request - check your deployment name and API version.\n${body.slice(0, 200)}`, "Connection Test");
+			} else if (!res.ok) {
+				const body = await res.text().catch(() => "");
+				await params.ctx.prompter.note(`Warning: test request returned ${res.status}. ${body.slice(0, 200)}\nProceeding anyway - you can fix the endpoint later.`, "Connection Test");
+			} else await params.ctx.prompter.note("Connection test successful!", "✓");
+		} finally {
+			await release();
+		}
+	} catch (err) {
+		await params.ctx.prompter.note(`Warning: connection test failed: ${String(err)}\nProceeding anyway.`, "Connection Test");
+	}
+}
+//#endregion
+export { listFoundryResources as a, promptApiKeyEndpointAndModel as c, selectFoundryDeployment as d, selectFoundryResource as f, isValidTenantIdentifier as i, promptEndpointAndModelManually as l, buildFoundryConnectionTest as n, listResourceDeployments as o, testFoundryConnection as p, extractTenantSuggestions as r, loginWithTenantFallback as s, buildCreateFoundryHint as t, promptTenantId as u };

package/dist/onboard-fjFU-IEN.js

@@ -0,0 +1,70 @@
+import { n as defaultRuntime } from "./runtime-DDkDH9fa.js";
+import { t as formatCliCommand } from "./command-format-B3Q5KD9o.js";
+import { t as assertSupportedRuntime } from "./runtime-guard-B2AXF2AU.js";
+import { u as readConfigFileSnapshot } from "./io-BbxW7tf4.js";
+import "./config-De9ZYLYC.js";
+import { i as resolveDeprecatedAuthChoiceReplacement, n as isDeprecatedAuthChoice, r as normalizeLegacyOnboardAuthChoice, t as formatDeprecatedNonInteractiveAuthChoiceError } from "./auth-choice-legacy-C_zh8bzv.js";
+//#region src/commands/onboard.ts
+const VALID_RESET_SCOPES = new Set([
+	"config",
+	"config+creds+sessions",
+	"full"
+]);
+async function setupWizardCommand(opts, runtime = defaultRuntime) {
+	assertSupportedRuntime(runtime);
+	const originalAuthChoice = opts.authChoice;
+	const normalizedAuthChoice = normalizeLegacyOnboardAuthChoice(originalAuthChoice, { env: process.env });
+	if (opts.nonInteractive && isDeprecatedAuthChoice(originalAuthChoice, { env: process.env })) {
+		runtime.error(formatDeprecatedNonInteractiveAuthChoiceError(originalAuthChoice, { env: process.env }));
+		runtime.exit(1);
+		return;
+	}
+	if (isDeprecatedAuthChoice(originalAuthChoice, { env: process.env })) runtime.log(resolveDeprecatedAuthChoiceReplacement(originalAuthChoice, { env: process.env }).message);
+	const flow = opts.flow === "manual" ? "advanced" : opts.flow;
+	const normalizedOpts = normalizedAuthChoice === opts.authChoice && flow === opts.flow ? opts : {
+		...opts,
+		authChoice: normalizedAuthChoice,
+		flow
+	};
+	if (normalizedOpts.secretInputMode && normalizedOpts.secretInputMode !== "plaintext" && normalizedOpts.secretInputMode !== "ref") {
+		runtime.error("Invalid --secret-input-mode. Use \"plaintext\" or \"ref\".");
+		runtime.exit(1);
+		return;
+	}
+	if (normalizedOpts.resetScope && !VALID_RESET_SCOPES.has(normalizedOpts.resetScope)) {
+		runtime.error("Invalid --reset-scope. Use \"config\", \"config+creds+sessions\", or \"full\".");
+		runtime.exit(1);
+		return;
+	}
+	if (normalizedOpts.nonInteractive && normalizedOpts.acceptRisk !== true) {
+		runtime.error([
+			"Non-interactive setup requires explicit risk acknowledgement.",
+			"Read: https://genesis.pixelzx.com/docs/security",
+			`Re-run with: ${formatCliCommand("genesis onboard --non-interactive --accept-risk ...")}`
+		].join("\n"));
+		runtime.exit(1);
+		return;
+	}
+	if (normalizedOpts.reset) {
+		const [{ DEFAULT_WORKSPACE, handleReset }, { resolveUserPath }] = await Promise.all([import("./onboard-helpers-R0vTUoOE.js"), import("./utils-BAyCAHkY.js")]);
+		const snapshot = await readConfigFileSnapshot();
+		const baseConfig = snapshot.valid ? snapshot.sourceConfig ?? snapshot.config : {};
+		const workspaceDefault = normalizedOpts.workspace ?? baseConfig.agents?.defaults?.workspace ?? DEFAULT_WORKSPACE;
+		await handleReset(normalizedOpts.resetScope ?? "config+creds+sessions", resolveUserPath(workspaceDefault), runtime);
+	}
+	if (process.platform === "win32") runtime.log([
+		"Windows detected - Genesis runs great on WSL2!",
+		"Native Windows might be trickier.",
+		"Quick setup: wsl --install (one command, one reboot)",
+		"Guide: https://genesis.pixelzx.com/docs/windows"
+	].join("\n"));
+	if (normalizedOpts.nonInteractive) {
+		const { runNonInteractiveSetup } = await import("./onboard-non-interactive-DjfjLqF7.js");
+		await runNonInteractiveSetup(normalizedOpts, runtime);
+		return;
+	}
+	const { runInteractiveSetup } = await import("./onboard-interactive-D4Hr2vB6.js");
+	await runInteractiveSetup(normalizedOpts, runtime);
+}
+//#endregion
+export { setupWizardCommand as t };

package/dist/onboard-helpers-CFVEw4kg.js

@@ -0,0 +1,204 @@
+import { c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
+import { _ as shortenHomePath, f as resolveConfigDir, g as shortenHomeInString, v as sleep } from "./utils-CWrkFsp0.js";
+import { o as resolveConfigPath } from "./paths-Bv2rGpO9.js";
+import { n as VERSION } from "./version-qod78efn.js";
+import { r as runCommandWithTimeout } from "./exec-BbrLAvgI.js";
+import { n as resolveAgentModelPrimaryValue } from "./model-input-gXkzehoL.js";
+import { n as DEFAULT_AGENT_WORKSPACE_DIR, u as ensureAgentWorkspace } from "./workspace-CbdFyQfr.js";
+import { a as probeGateway } from "./probe--ur8kCb3.js";
+import { r as normalizeControlUiBasePath } from "./control-ui-shared-DMYCWX54.js";
+import "./control-ui-links-C-bMAXFT.js";
+import { l as resolveSessionTranscriptsDirForAgent } from "./paths-CV1IubzZ.js";
+import "./detect-binary-Beap22jY.js";
+import { r as stylePromptTitle } from "./prompt-style-q-APyeiS.js";
+import "./browser-open-CVjFSPS0.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://genesis.pixelzx.com/docs/gateway/remote",
+		"https://genesis.pixelzx.com/docs/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-helpers-R0vTUoOE.js

@@ -0,0 +1,6 @@
+import { t as randomToken } from "./random-token-CC24wPn8.js";
+import { t as resolveControlUiLinks } from "./control-ui-links-C-bMAXFT.js";
+import { t as detectBinary } from "./detect-binary-Beap22jY.js";
+import { i as resolveBrowserOpenCommand, n as openUrl, r as openUrlInBackground, t as detectBrowserOpenSupport } from "./browser-open-CVjFSPS0.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-CFVEw4kg.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-interactive-D4Hr2vB6.js

@@ -0,0 +1,24 @@
+import { t as restoreTerminalState } from "./restore-BXwuqZZE.js";
+import { n as defaultRuntime } from "./runtime-DDkDH9fa.js";
+import { t as WizardCancelledError } from "./prompts-R5pfGZbV.js";
+import { t as createClackPrompter } from "./clack-prompter-Bz5V6HwL.js";
+import { t as runSetupWizard } from "./setup-CcVU94hA.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 };