ryco-cli 0.1.25 → 0.1.26

package/dist/GrokDriver-CDcWkiAi.mjs

@@ -0,0 +1,552 @@
+#!/usr/bin/env node
+
+import { Nr as GrokSettings, To as ProviderDriverKind, cr as TextGenerationError } from "./src-DtEOcXdl.mjs";
+import "./Metrics-C-3MahDy.mjs";
+import { m as sanitizeFeatureBranchName, p as sanitizeBranchFragment } from "./git-C4iJMbBu.mjs";
+import { $ as buildCommitMessagePrompt, At as providerModelsFromSettings, Dr as normalizeModelSlug, Dt as isCommandMissingCause, Q as buildBranchNamePrompt, Ut as ProviderDriverError, W as AcpSessionRuntime, Z as validateRankInboxThreadsResult, at as buildThreadTitlePrompt, br as createModelCapabilities, ct as sanitizeCommitSubject, et as buildIssueContentPolishPrompt, fr as resolveProviderMaintenanceCapabilitiesEffect, gt as mergeProviderInstanceEnvironment, it as buildThreadPriorityPrompt, jt as spawnAndCollect, k as ProviderEventLoggers, kt as parseGenericCliVersion, lt as sanitizePrTitle, mr as ServerSettingsService, nt as buildPrContentPrompt, or as enrichProviderSnapshotWithVersionAdvisory, ot as extractJsonObject, sr as makeManualOnlyProviderMaintenanceCapabilities, tt as buildIssueContentTitlePrompt, ur as makeStaticProviderMaintenanceResolver, ut as sanitizeThreadTitle, wt as buildServerProvider } from "./bin.mjs";
+import { i as currentAcpModelIdFromSessionSetup, n as makeXAiPromptCompletionRuntime, r as applyAcpModelSelection, t as makeAcpAdapter } from "./AcpAdapter-BemMQNbj.mjs";
+import { t as defaultProviderContinuationIdentity } from "./ProviderDriver-kCV60GKk.mjs";
+import { t as makeManagedServerProvider } from "./makeManagedServerProvider-BINne1KE.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { HttpClient } from "effect/unstable/http";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import "effect/Scope";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import * as Option from "effect/Option";
+import * as Ref from "effect/Ref";
+import * as Stream from "effect/Stream";
+import * as Duration from "effect/Duration";
+import * as DateTime from "effect/DateTime";
+import "effect/FileSystem";
+import "effect/Path";
+import * as Result from "effect/Result";
+//#region src/provider/acp/GrokAcpSupport.ts
+const GROK_API_KEY_ENV = "XAI_API_KEY";
+const GROK_OAUTH2_REFERRER_ENV = "GROK_OAUTH2_REFERRER";
+const RYCO_OAUTH_REFERRER = "ryco";
+const GROK_AUTH_METHOD_API_KEY = "xai.api_key";
+const GROK_AUTH_METHOD_CACHED_TOKEN = "cached_token";
+const GROK_DRIVER_KIND = ProviderDriverKind.make("grok");
+function buildGrokAcpSpawnInput(grokSettings, cwd, environment) {
+	return {
+		command: grokSettings?.binaryPath || "grok",
+		args: ["agent", "stdio"],
+		cwd,
+		env: {
+			...environment,
+			[GROK_OAUTH2_REFERRER_ENV]: RYCO_OAUTH_REFERRER
+		}
+	};
+}
+function resolveGrokAuthMethodId(environment) {
+	return environment?.[GROK_API_KEY_ENV]?.trim() ? GROK_AUTH_METHOD_API_KEY : GROK_AUTH_METHOD_CACHED_TOKEN;
+}
+const makeGrokAcpRuntime = (input) => Effect.gen(function* () {
+	const acpContext = yield* Layer.build(AcpSessionRuntime.layer({
+		...input,
+		spawn: buildGrokAcpSpawnInput(input.grokSettings, input.cwd, input.environment),
+		authMethodId: resolveGrokAuthMethodId(input.environment)
+	}).pipe(Layer.provide(Layer.succeed(ChildProcessSpawner.ChildProcessSpawner, input.childProcessSpawner))));
+	const runtime = yield* Effect.service(AcpSessionRuntime).pipe(Effect.provide(acpContext));
+	return yield* makeXAiPromptCompletionRuntime(runtime);
+});
+function resolveGrokAcpBaseModelId(model) {
+	const trimmed = model?.trim();
+	const base = trimmed && trimmed.length > 0 ? trimmed : "grok-build";
+	return normalizeModelSlug(base, GROK_DRIVER_KIND) ?? "grok-build";
+}
+//#endregion
+//#region src/textGeneration/GrokTextGeneration.ts
+const GROK_TIMEOUT_MS = 18e4;
+function mapGrokAcpError(operation, detail, cause) {
+	return new TextGenerationError({
+		operation,
+		detail,
+		...cause !== void 0 ? { cause } : {}
+	});
+}
+function isTextGenerationError(error) {
+	return typeof error === "object" && error !== null && "_tag" in error && error._tag === "TextGenerationError";
+}
+const makeGrokTextGeneration = Effect.fn("makeGrokTextGeneration")(function* (grokSettings, environment = process.env) {
+	const commandSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const runGrokJson = ({ operation, cwd, prompt, outputSchemaJson, modelSelection }) => Effect.gen(function* () {
+		const resolvedModel = resolveGrokAcpBaseModelId(modelSelection.model);
+		const outputRef = yield* Ref.make("");
+		const runtime = yield* makeGrokAcpRuntime({
+			grokSettings,
+			environment,
+			childProcessSpawner: commandSpawner,
+			cwd,
+			clientInfo: {
+				name: "ryco-git-text",
+				version: "0.0.0"
+			}
+		});
+		yield* runtime.handleSessionUpdate((notification) => {
+			const update = notification.update;
+			if (update.sessionUpdate !== "agent_message_chunk") return Effect.void;
+			const content = update.content;
+			if (content.type !== "text") return Effect.void;
+			return Ref.update(outputRef, (current) => current + content.text);
+		});
+		const promptResult = yield* Effect.gen(function* () {
+			const started = yield* runtime.start();
+			yield* applyAcpModelSelection({
+				runtime,
+				currentModelId: currentAcpModelIdFromSessionSetup(started.sessionSetupResult),
+				requestedModelId: resolvedModel,
+				mapError: (cause) => mapGrokAcpError(operation, "Failed to set Grok ACP base model for text generation.", cause)
+			});
+			return yield* runtime.prompt({ prompt: [{
+				type: "text",
+				text: prompt
+			}] });
+		}).pipe(Effect.timeoutOption(GROK_TIMEOUT_MS), Effect.flatMap(Option.match({
+			onNone: () => Effect.fail(new TextGenerationError({
+				operation,
+				detail: "Grok ACP request timed out."
+			})),
+			onSome: (value) => Effect.succeed(value)
+		})), Effect.mapError((cause) => isTextGenerationError(cause) ? cause : mapGrokAcpError(operation, "Grok ACP request failed.", cause)));
+		const trimmed = (yield* Ref.get(outputRef)).trim();
+		if (!trimmed) return yield* new TextGenerationError({
+			operation,
+			detail: promptResult.stopReason === "cancelled" ? "Grok ACP request was cancelled." : "Grok Agent returned empty output."
+		});
+		return yield* Schema.decodeEffect(Schema.fromJsonString(outputSchemaJson))(extractJsonObject(trimmed)).pipe(Effect.catchTag("SchemaError", (cause) => Effect.fail(new TextGenerationError({
+			operation,
+			detail: "Grok Agent returned invalid structured output.",
+			cause
+		}))));
+	}).pipe(Effect.mapError((cause) => isTextGenerationError(cause) ? cause : mapGrokAcpError(operation, "Grok ACP text generation failed.", cause)), Effect.scoped);
+	return {
+		generateCommitMessage: Effect.fn("GrokTextGeneration.generateCommitMessage")(function* (input) {
+			const { prompt, outputSchema } = buildCommitMessagePrompt({
+				branch: input.branch,
+				stagedSummary: input.stagedSummary,
+				stagedPatch: input.stagedPatch,
+				includeBranch: input.includeBranch === true
+			});
+			const generated = yield* runGrokJson({
+				operation: "generateCommitMessage",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				modelSelection: input.modelSelection
+			});
+			return {
+				subject: sanitizeCommitSubject(generated.subject),
+				body: generated.body.trim(),
+				..."branch" in generated && typeof generated.branch === "string" ? { branch: sanitizeFeatureBranchName(generated.branch) } : {}
+			};
+		}),
+		generatePrContent: Effect.fn("GrokTextGeneration.generatePrContent")(function* (input) {
+			const { prompt, outputSchema } = buildPrContentPrompt({
+				baseBranch: input.baseBranch,
+				headBranch: input.headBranch,
+				commitSummary: input.commitSummary,
+				diffSummary: input.diffSummary,
+				diffPatch: input.diffPatch
+			});
+			const generated = yield* runGrokJson({
+				operation: "generatePrContent",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				modelSelection: input.modelSelection
+			});
+			return {
+				title: sanitizePrTitle(generated.title),
+				body: generated.body.trim()
+			};
+		}),
+		generateBranchName: Effect.fn("GrokTextGeneration.generateBranchName")(function* (input) {
+			const { prompt, outputSchema } = buildBranchNamePrompt({
+				message: input.message,
+				attachments: input.attachments
+			});
+			const generated = yield* runGrokJson({
+				operation: "generateBranchName",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				modelSelection: input.modelSelection
+			});
+			return { branch: sanitizeBranchFragment(generated.branch) };
+		}),
+		generateThreadTitle: Effect.fn("GrokTextGeneration.generateThreadTitle")(function* (input) {
+			const { prompt, outputSchema } = buildThreadTitlePrompt({
+				message: input.message,
+				attachments: input.attachments
+			});
+			const generated = yield* runGrokJson({
+				operation: "generateThreadTitle",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				modelSelection: input.modelSelection
+			});
+			return { title: sanitizeThreadTitle(generated.title) };
+		}),
+		generateIssueContent: Effect.fn("GrokTextGeneration.generateIssueContent")(function* (input) {
+			if (input.mode === "polish") {
+				const { prompt, outputSchema } = buildIssueContentPolishPrompt({
+					rough: input.rough,
+					...input.currentTitle ? { currentTitle: input.currentTitle } : {},
+					...input.customInstructions ? { customInstructions: input.customInstructions } : {}
+				});
+				const decoded = yield* runGrokJson({
+					operation: "generateIssueContent",
+					cwd: input.cwd,
+					prompt,
+					outputSchemaJson: outputSchema,
+					modelSelection: input.modelSelection
+				});
+				return {
+					title: decoded.title.trim(),
+					body: decoded.body.trim()
+				};
+			}
+			const { prompt, outputSchema } = buildIssueContentTitlePrompt({ body: input.body });
+			return { title: (yield* runGrokJson({
+				operation: "generateIssueContent",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				modelSelection: input.modelSelection
+			})).title.trim() };
+		}),
+		rankInboxThreads: Effect.fn("GrokTextGeneration.rankInboxThreads")(function* (input) {
+			const { prompt, outputSchema } = buildThreadPriorityPrompt({ serializedCandidates: input.chunk.serializedCandidates });
+			const generated = yield* runGrokJson({
+				operation: "rankInboxThreads",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				modelSelection: input.modelSelection
+			});
+			return yield* validateRankInboxThreadsResult(input, generated.rankings);
+		}),
+		answerSideQuestion: (_input) => Effect.fail(new TextGenerationError({
+			operation: "answerSideQuestion",
+			detail: "Grok does not provide an enforceable tool-free side question mode. Select Codex, Claude, or GitHub Copilot for side chat."
+		}))
+	};
+});
+//#endregion
+//#region src/provider/Layers/GrokAdapter.ts
+function makeGrokAdapter(grokSettings, options) {
+	return makeAcpAdapter({
+		...options,
+		provider: ProviderDriverKind.make("grok"),
+		normalizeModel: resolveGrokAcpBaseModelId,
+		xaiExtensions: true,
+		makeRuntime: (input) => makeGrokAcpRuntime({
+			...input,
+			grokSettings,
+			...options?.environment ? { environment: options.environment } : {}
+		})
+	});
+}
+//#endregion
+//#region src/provider/Layers/GrokProvider.ts
+const GROK_PRESENTATION = {
+	displayName: "Grok",
+	badgeLabel: "Early Access",
+	showInteractionModeToggle: false
+};
+const PROVIDER = ProviderDriverKind.make("grok");
+const EMPTY_CAPABILITIES = createModelCapabilities({ optionDescriptors: [] });
+const VERSION_PROBE_TIMEOUT_MS = 4e3;
+const GROK_ACP_MODEL_DISCOVERY_TIMEOUT_MS = 15e3;
+const GROK_BUILT_IN_MODELS = [{
+	slug: "grok-build",
+	name: "Grok Build",
+	isCustom: false,
+	capabilities: EMPTY_CAPABILITIES
+}];
+function buildInitialGrokProviderSnapshot(grokSettings) {
+	const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const models = grokModelsFromSettings(grokSettings.customModels);
+	if (!grokSettings.enabled) return buildServerProvider({
+		presentation: GROK_PRESENTATION,
+		enabled: false,
+		checkedAt,
+		models,
+		probe: {
+			installed: false,
+			version: null,
+			status: "warning",
+			auth: { status: "unknown" },
+			message: "Grok is disabled in Ryco settings."
+		}
+	});
+	return buildServerProvider({
+		presentation: GROK_PRESENTATION,
+		enabled: true,
+		checkedAt,
+		models,
+		probe: {
+			installed: true,
+			version: null,
+			status: "warning",
+			auth: { status: "unknown" },
+			message: "Checking Grok CLI availability..."
+		}
+	});
+}
+function grokModelsFromSettings(customModels, builtInModels = GROK_BUILT_IN_MODELS) {
+	return providerModelsFromSettings(builtInModels, PROVIDER, customModels ?? [], EMPTY_CAPABILITIES);
+}
+function buildGrokDiscoveredModelsFromSessionModelState(modelState) {
+	if (!modelState || modelState.availableModels.length === 0) return [];
+	const seen = /* @__PURE__ */ new Set();
+	return modelState.availableModels.map((model) => {
+		const slug = resolveGrokAcpBaseModelId(model.modelId);
+		if (!slug || seen.has(slug)) return;
+		seen.add(slug);
+		return {
+			slug,
+			name: model.name.trim() || slug,
+			isCustom: false,
+			capabilities: EMPTY_CAPABILITIES
+		};
+	}).filter((model) => model !== void 0);
+}
+const discoverGrokModelsViaAcp = (grokSettings, environment = process.env) => Effect.gen(function* () {
+	const childProcessSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	return buildGrokDiscoveredModelsFromSessionModelState((yield* (yield* makeGrokAcpRuntime({
+		grokSettings,
+		environment,
+		childProcessSpawner,
+		cwd: process.cwd(),
+		clientInfo: {
+			name: "ryco-provider-probe",
+			version: "0.0.0"
+		}
+	})).start()).sessionSetupResult.models);
+}).pipe(Effect.scoped);
+const runGrokVersionCommand = (grokSettings, environment = process.env) => {
+	const command = grokSettings.binaryPath || "grok";
+	return spawnAndCollect(command, ChildProcess.make(command, ["--version"], {
+		env: environment,
+		shell: process.platform === "win32"
+	}));
+};
+const checkGrokProviderStatus = Effect.fn("checkGrokProviderStatus")(function* (grokSettings, environment = process.env) {
+	const checkedAt = DateTime.formatIso(yield* DateTime.now);
+	const fallbackModels = grokModelsFromSettings(grokSettings.customModels);
+	if (!grokSettings.enabled) return buildServerProvider({
+		presentation: GROK_PRESENTATION,
+		enabled: false,
+		checkedAt,
+		models: fallbackModels,
+		probe: {
+			installed: false,
+			version: null,
+			status: "warning",
+			auth: { status: "unknown" },
+			message: "Grok is disabled in Ryco settings."
+		}
+	});
+	const versionResult = yield* runGrokVersionCommand(grokSettings, environment).pipe(Effect.timeoutOption(VERSION_PROBE_TIMEOUT_MS), Effect.result);
+	if (Result.isFailure(versionResult)) {
+		const error = versionResult.failure;
+		yield* Effect.logWarning("Grok CLI health check failed.", { errorTag: error.name });
+		return buildServerProvider({
+			presentation: GROK_PRESENTATION,
+			enabled: grokSettings.enabled,
+			checkedAt,
+			models: fallbackModels,
+			probe: {
+				installed: !isCommandMissingCause(error),
+				version: null,
+				status: "error",
+				auth: { status: "unknown" },
+				message: isCommandMissingCause(error) ? "Grok CLI (`grok`) is not installed or not on PATH." : "Failed to execute Grok CLI health check."
+			}
+		});
+	}
+	if (Option.isNone(versionResult.success)) return buildServerProvider({
+		presentation: GROK_PRESENTATION,
+		enabled: grokSettings.enabled,
+		checkedAt,
+		models: fallbackModels,
+		probe: {
+			installed: true,
+			version: null,
+			status: "error",
+			auth: { status: "unknown" },
+			message: "Grok CLI is installed but timed out while running `grok --version`."
+		}
+	});
+	const versionOutput = versionResult.success.value;
+	const version = parseGenericCliVersion(`${versionOutput.stdout}\n${versionOutput.stderr}`);
+	if (versionOutput.code !== 0) {
+		yield* Effect.logWarning("Grok CLI version probe exited with a non-zero status.", {
+			exitCode: versionOutput.code,
+			stdoutLength: versionOutput.stdout.length,
+			stderrLength: versionOutput.stderr.length
+		});
+		return buildServerProvider({
+			presentation: GROK_PRESENTATION,
+			enabled: grokSettings.enabled,
+			checkedAt,
+			models: fallbackModels,
+			probe: {
+				installed: true,
+				version,
+				status: "error",
+				auth: { status: "unknown" },
+				message: "Grok CLI is installed but failed to run."
+			}
+		});
+	}
+	const discoveryExit = yield* discoverGrokModelsViaAcp(grokSettings, environment).pipe(Effect.timeoutOption(GROK_ACP_MODEL_DISCOVERY_TIMEOUT_MS), Effect.exit);
+	if (Exit.isFailure(discoveryExit)) {
+		yield* Effect.logWarning("Grok ACP model discovery failed", { cause: Cause.pretty(discoveryExit.cause) });
+		return buildServerProvider({
+			presentation: GROK_PRESENTATION,
+			enabled: grokSettings.enabled,
+			checkedAt,
+			models: fallbackModels,
+			probe: {
+				installed: true,
+				version,
+				status: "error",
+				auth: { status: "unknown" },
+				message: "Grok CLI is installed but ACP startup failed. Check server logs for details."
+			}
+		});
+	}
+	if (Option.isNone(discoveryExit.value)) {
+		yield* Effect.logWarning(`Grok ACP model discovery timed out after ${GROK_ACP_MODEL_DISCOVERY_TIMEOUT_MS}ms.`);
+		return buildServerProvider({
+			presentation: GROK_PRESENTATION,
+			enabled: grokSettings.enabled,
+			checkedAt,
+			models: fallbackModels,
+			probe: {
+				installed: true,
+				version,
+				status: "error",
+				auth: { status: "unknown" },
+				message: `Grok CLI is installed but ACP startup timed out after ${GROK_ACP_MODEL_DISCOVERY_TIMEOUT_MS}ms.`
+			}
+		});
+	}
+	const discoveredModels = discoveryExit.value.value;
+	const models = discoveredModels.length > 0 ? grokModelsFromSettings(grokSettings.customModels, discoveredModels) : fallbackModels;
+	return buildServerProvider({
+		presentation: GROK_PRESENTATION,
+		enabled: grokSettings.enabled,
+		checkedAt,
+		models,
+		probe: {
+			installed: true,
+			version,
+			status: "ready",
+			auth: { status: "unknown" }
+		}
+	});
+});
+const enrichGrokSnapshot = (input) => {
+	const { snapshot, publishSnapshot } = input;
+	return enrichProviderSnapshotWithVersionAdvisory(snapshot, input.maintenanceCapabilities).pipe(Effect.provideService(HttpClient.HttpClient, input.httpClient), Effect.provideService(ServerSettingsService, input.serverSettings), Effect.flatMap((enrichedSnapshot) => publishSnapshot(enrichedSnapshot)), Effect.catchCause((cause) => Effect.logWarning("Grok version advisory enrichment failed", { cause: Cause.pretty(cause) })), Effect.asVoid);
+};
+//#endregion
+//#region src/provider/Drivers/GrokDriver.ts
+const decodeGrokSettings = Schema.decodeSync(GrokSettings);
+const DRIVER_KIND = ProviderDriverKind.make("grok");
+const SNAPSHOT_REFRESH_INTERVAL = Duration.minutes(5);
+const UPDATE = makeStaticProviderMaintenanceResolver(makeManualOnlyProviderMaintenanceCapabilities({
+	provider: DRIVER_KIND,
+	packageName: null
+}));
+const withInstanceIdentity = (input) => (snapshot) => ({
+	...snapshot,
+	instanceId: input.instanceId,
+	driver: DRIVER_KIND,
+	...input.displayName ? { displayName: input.displayName } : {},
+	...input.accentColor ? { accentColor: input.accentColor } : {},
+	continuation: { groupKey: input.continuationGroupKey }
+});
+const GrokDriver = {
+	driverKind: DRIVER_KIND,
+	metadata: {
+		displayName: "Grok",
+		supportsMultipleInstances: true
+	},
+	configSchema: GrokSettings,
+	defaultConfig: () => decodeGrokSettings({}),
+	create: ({ instanceId, displayName, accentColor, environment, enabled, config }) => Effect.gen(function* () {
+		const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+		const httpClient = yield* HttpClient.HttpClient;
+		const serverSettings = yield* ServerSettingsService;
+		const eventLoggers = yield* ProviderEventLoggers;
+		const processEnv = mergeProviderInstanceEnvironment(environment);
+		const continuationIdentity = defaultProviderContinuationIdentity({
+			driverKind: DRIVER_KIND,
+			instanceId
+		});
+		const stampIdentity = withInstanceIdentity({
+			instanceId,
+			displayName,
+			accentColor,
+			continuationGroupKey: continuationIdentity.continuationKey
+		});
+		const effectiveConfig = {
+			...config,
+			enabled
+		};
+		const maintenanceCapabilities = yield* resolveProviderMaintenanceCapabilitiesEffect(UPDATE, {
+			binaryPath: effectiveConfig.binaryPath,
+			env: processEnv
+		});
+		const adapter = yield* makeGrokAdapter(effectiveConfig, {
+			environment: processEnv,
+			...eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {},
+			instanceId
+		});
+		const textGeneration = yield* makeGrokTextGeneration(effectiveConfig, processEnv);
+		const checkProvider = checkGrokProviderStatus(effectiveConfig, processEnv).pipe(Effect.map(stampIdentity), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner));
+		const snapshot = yield* makeManagedServerProvider({
+			maintenanceCapabilities,
+			getSettings: Effect.succeed(effectiveConfig),
+			streamSettings: Stream.never,
+			haveSettingsChanged: () => false,
+			initialSnapshot: (settings) => stampIdentity(buildInitialGrokProviderSnapshot(settings)),
+			checkProvider,
+			enrichSnapshot: ({ snapshot: currentSnapshot, publishSnapshot }) => enrichGrokSnapshot({
+				snapshot: currentSnapshot,
+				maintenanceCapabilities,
+				publishSnapshot,
+				httpClient,
+				serverSettings
+			}),
+			refreshInterval: SNAPSHOT_REFRESH_INTERVAL
+		}).pipe(Effect.mapError((cause) => new ProviderDriverError({
+			driver: DRIVER_KIND,
+			instanceId,
+			detail: `Failed to build Grok snapshot: ${cause.message ?? String(cause)}`,
+			cause
+		})));
+		return {
+			instanceId,
+			driverKind: DRIVER_KIND,
+			continuationIdentity,
+			displayName,
+			accentColor,
+			enabled,
+			snapshot,
+			adapter,
+			textGeneration
+		};
+	})
+};
+//#endregion
+export { GrokDriver };

package/dist/{Metrics-a1h4iBQi.mjs → Metrics-C-3MahDy.mjs}

@@ -1,12 +1,9 @@
 #!/usr/bin/env node
 
-import { n as detectSourceControlProviderFromRemoteUrl } from "./sourceControl-BiEBxN01.mjs";
-import * as Effect$1 from "effect/Effect";
 import { Cause, Context, DateTime, Duration, Effect, Exit, FileSystem, Layer, Metric, Path, Schema } from "effect";
 import path from "node:path";
 import { createHash, timingSafeEqual } from "node:crypto";
 import { dual } from "effect/Function";
-import * as Random from "effect/Random";
 //#region ../../node_modules/.bun/cborg@6.1.2/node_modules/cborg/lib/is.js
 const objectTypeNames = [
 	"Object",
@@ -2799,109 +2796,6 @@ function normalizeModelMetricLabel(model) {
 	if (normalized.includes("gemini")) return "gemini";
 	return "other";
 }
-//#endregion
-//#region ../../packages/shared/src/git.ts
-const WORKTREE_BRANCH_PREFIX = "ryco";
-const TEMP_WORKTREE_BRANCH_PATTERN = new RegExp(`^(?:${WORKTREE_BRANCH_PREFIX}|ryco)\\/[0-9a-f]{8}$`);
-/**
-* Sanitize an arbitrary string into a valid, lowercase git refName fragment.
-* Strips quotes, collapses separators, limits to 64 chars.
-*/
-function sanitizeBranchFragment(raw) {
-	const branchFragment = raw.trim().toLowerCase().replace(/['"`]/g, "").replace(/^[./\s_-]+|[./\s_-]+$/g, "").replace(/[^a-z0-9/_-]+/g, "-").replace(/\/+/g, "/").replace(/-+/g, "-").replace(/^[./_-]+|[./_-]+$/g, "").slice(0, 64).replace(/[./_-]+$/g, "");
-	return branchFragment.length > 0 ? branchFragment : "update";
-}
-/**
-* Sanitize a string into a `feature/…` refName name.
-* Preserves an existing `feature/` prefix or slash-separated namespace.
-*/
-function sanitizeFeatureBranchName(raw) {
-	const sanitized = sanitizeBranchFragment(raw);
-	if (sanitized.includes("/")) return sanitized.startsWith("feature/") ? sanitized : `feature/${sanitized}`;
-	return `feature/${sanitized}`;
-}
-const AUTO_FEATURE_BRANCH_FALLBACK = "feature/update";
-/**
-* Resolve a unique `feature/…` refName name that doesn't collide with
-* any existing refName. Appends a numeric suffix when needed.
-*/
-function resolveAutoFeatureBranchName(existingBranchNames, preferredBranch) {
-	const preferred = preferredBranch?.trim();
-	const resolvedBase = sanitizeFeatureBranchName(preferred && preferred.length > 0 ? preferred : AUTO_FEATURE_BRANCH_FALLBACK);
-	const existingNames = new Set(existingBranchNames.map((refName) => refName.toLowerCase()));
-	if (!existingNames.has(resolvedBase)) return resolvedBase;
-	let suffix = 2;
-	while (existingNames.has(`${resolvedBase}-${suffix}`)) suffix += 1;
-	return `${resolvedBase}-${suffix}`;
-}
-/**
-* Strip the remote prefix from a remote ref such as `origin/feature/demo`.
-*/
-function deriveLocalBranchNameFromRemoteRef(branchName) {
-	const firstSeparatorIndex = branchName.indexOf("/");
-	if (firstSeparatorIndex <= 0 || firstSeparatorIndex === branchName.length - 1) return branchName;
-	return branchName.slice(firstSeparatorIndex + 1);
-}
-function buildTemporaryWorktreeBranchName() {
-	const token = Effect$1.runSync(Random.nextIntBetween(0, 4294967295)).toString(16).padStart(8, "0");
-	return `${WORKTREE_BRANCH_PREFIX}/${token}`;
-}
-function isTemporaryWorktreeBranch(refName) {
-	return TEMP_WORKTREE_BRANCH_PATTERN.test(refName.trim().toLowerCase());
-}
-/**
-* Normalize a git remote URL into a stable comparison key.
-*/
-function normalizeGitRemoteUrl(value) {
-	const normalized = value.trim().replace(/\/+$/g, "").replace(/\.git$/i, "").toLowerCase();
-	if (/^(?:ssh|https?|git):\/\//i.test(normalized)) try {
-		const url = new URL(normalized);
-		const repositoryPath = url.pathname.split("/").filter((segment) => segment.length > 0).join("/");
-		if (url.hostname && repositoryPath.includes("/")) return `${url.hostname}/${repositoryPath}`;
-	} catch {
-		return normalized;
-	}
-	const scpStyleHostAndPath = /^git@([^:/\s]+)[:/]([^/\s]+(?:\/[^/\s]+)+)$/i.exec(normalized);
-	if (scpStyleHostAndPath?.[1] && scpStyleHostAndPath[2]) return `${scpStyleHostAndPath[1]}/${scpStyleHostAndPath[2]}`;
-	return normalized;
-}
-function deriveLocalBranchNameCandidatesFromRemoteRef(branchName, remoteName) {
-	const candidates = /* @__PURE__ */ new Set();
-	const firstSlashCandidate = deriveLocalBranchNameFromRemoteRef(branchName);
-	if (firstSlashCandidate.length > 0) candidates.add(firstSlashCandidate);
-	if (remoteName) {
-		const remotePrefix = `${remoteName}/`;
-		if (branchName.startsWith(remotePrefix) && branchName.length > remotePrefix.length) candidates.add(branchName.slice(remotePrefix.length));
-	}
-	return [...candidates];
-}
-/**
-* Hide `origin/*` remote refs when a matching local refName already exists.
-*/
-function dedupeRemoteBranchesWithLocalMatches(refs) {
-	const localBranchNames = new Set(refs.filter((refName) => !refName.isRemote).map((refName) => refName.name));
-	return refs.filter((refName) => {
-		if (!refName.isRemote) return true;
-		if (refName.remoteName !== "origin") return true;
-		return !deriveLocalBranchNameCandidatesFromRemoteRef(refName.name, refName.remoteName).some((candidate) => localBranchNames.has(candidate));
-	});
-}
-function detectSourceControlProviderFromGitRemoteUrl(remoteUrl) {
-	return detectSourceControlProviderFromRemoteUrl(remoteUrl);
-}
-const EMPTY_GIT_STATUS_REMOTE = {
-	hasUpstream: false,
-	aheadCount: 0,
-	behindCount: 0,
-	aheadOfDefaultCount: 0,
-	pr: null
-};
-function mergeGitStatusParts(local, remote) {
-	return {
-		...local,
-		...remote ?? EMPTY_GIT_STATUS_REMOTE
-	};
-}
 const DEFAULT_ROLLING_WINDOW_MS = 3e5;
 var RollingDurationWindow = class {
 	maxSamples;
@@ -3112,4 +3006,4 @@ const providerTurnMetricAttributes = (input) => {
 	});
 };
 //#endregion
-export { normalizeGitRemoteUrl as $, runtimeQueueBlockedDuration as A, startupCommandGateQueueHighWater as B, providerStartupQueueHighWater as C, decode as Ct, providerTurnsTotal as D, providerTurnMetricAttributes as E, Type as Et, runtimeQueueHighWater as F, LocalDiagnosticsMetrics as G, terminalRestartsTotal as H, runtimeQueueOverflowsTotal as I, buildTemporaryWorktreeBranchName as J, LocalDiagnosticsMetricsLive as K, runtimeQueueRecoveriesTotal as L, runtimeQueueDepth as M, runtimeQueueDequeuesTotal as N, rpcRequestDuration as O, runtimeQueueEnqueuesTotal as P, mergeGitStatusParts as Q, startupCommandGateEnqueuesTotal as R, providerStartupQueueDepth as S, Tokeniser as St, providerTurnDuration as T, rfc8949EncodeOptions as Tt, terminalSessionsTotal as U, startupCommandGateQueueWaitDuration as V, withMetrics as W, detectSourceControlProviderFromGitRemoteUrl as X, dedupeRemoteBranchesWithLocalMatches as Y, isTemporaryWorktreeBranch as Z, providerRuntimeEventsTotal as _, encodeNodeKeyRotationTranscript as _t, contextHandoffsTotal as a, DEFAULT_PORT as at, providerStaleStopTimeoutsTotal as b, formatNodePublicKeyFingerprint as bt, increment as c, deriveServerPaths as ct, orchestrationCommandAckDuration as d, resolveManagedWorktreesRoot as dt, resolveAutoFeatureBranchName as et, orchestrationCommandDuration as f, resolveNodeE2eePolicyConfig as ft, providerMetricAttributes as g, encodeNodeAuthenticationTranscript as gt, providerEventLogRecordsDroppedTotal as h, encodeNativeNodeClaimTranscript as ht, contextHandoffPreparationDuration as i, outcomeFromExit as it, runtimeQueueCoalescedTotal as j, rpcRequestsTotal as k, metricAttributes as l, ensureServerDirectories as lt, orchestrationEventsProcessedTotal as m, canonicalizeHubOrigin as mt, contextHandoffContextEntriesTotal as n, sanitizeFeatureBranchName as nt, gitCommandDuration as o, RuntimeMode as ot, orchestrationCommandsTotal as p, resolveStaticDir as pt, WORKTREE_BRANCH_PREFIX as q, contextHandoffDispatchDuration as r, compactTraceAttributes as rt, gitCommandsTotal as s, ServerConfig as st, contextHandoffContextBytesTotal as t, sanitizeBranchFragment as tt, metricNames as u, resolveHubConnectorConfig as ut, providerRuntimeStaleEventsTotal as v, equalNodeIdentityBytes as vt, providerStartupQueueWaitDuration as w, encode as wt, providerStartupAdmissionTotal as x, normalizeHubNodeName as xt, providerSessionsTotal as y, fingerprintNodePublicKey as yt, startupCommandGateQueueDepth as z };
+export { ensureServerDirectories as $, runtimeQueueBlockedDuration as A, startupCommandGateQueueHighWater as B, providerStartupQueueHighWater as C, providerTurnsTotal as D, providerTurnMetricAttributes as E, runtimeQueueHighWater as F, LocalDiagnosticsMetrics as G, terminalRestartsTotal as H, runtimeQueueOverflowsTotal as I, outcomeFromExit as J, LocalDiagnosticsMetricsLive as K, runtimeQueueRecoveriesTotal as L, runtimeQueueDepth as M, runtimeQueueDequeuesTotal as N, rpcRequestDuration as O, runtimeQueueEnqueuesTotal as P, deriveServerPaths as Q, startupCommandGateEnqueuesTotal as R, providerStartupQueueDepth as S, providerTurnDuration as T, terminalSessionsTotal as U, startupCommandGateQueueWaitDuration as V, withMetrics as W, RuntimeMode as X, DEFAULT_PORT as Y, ServerConfig as Z, providerRuntimeEventsTotal as _, contextHandoffsTotal as a, encodeNativeNodeClaimTranscript as at, providerStaleStopTimeoutsTotal as b, increment as c, equalNodeIdentityBytes as ct, orchestrationCommandAckDuration as d, normalizeHubNodeName as dt, resolveHubConnectorConfig as et, orchestrationCommandDuration as f, Tokeniser as ft, providerMetricAttributes as g, Type as gt, providerEventLogRecordsDroppedTotal as h, rfc8949EncodeOptions as ht, contextHandoffPreparationDuration as i, canonicalizeHubOrigin as it, runtimeQueueCoalescedTotal as j, rpcRequestsTotal as k, metricAttributes as l, fingerprintNodePublicKey as lt, orchestrationEventsProcessedTotal as m, encode as mt, contextHandoffContextEntriesTotal as n, resolveNodeE2eePolicyConfig as nt, gitCommandDuration as o, encodeNodeAuthenticationTranscript as ot, orchestrationCommandsTotal as p, decode as pt, compactTraceAttributes as q, contextHandoffDispatchDuration as r, resolveStaticDir as rt, gitCommandsTotal as s, encodeNodeKeyRotationTranscript as st, contextHandoffContextBytesTotal as t, resolveManagedWorktreesRoot as tt, metricNames as u, formatNodePublicKeyFingerprint as ut, providerRuntimeStaleEventsTotal as v, providerStartupQueueWaitDuration as w, providerStartupAdmissionTotal as x, providerSessionsTotal as y, startupCommandGateQueueDepth as z };