ryco-cli 0.1.3 → 0.1.4

package/dist/Metrics-BCOc3Ml2.mjs

@@ -0,0 +1,356 @@
+#!/usr/bin/env node
+
+import { n as detectSourceControlProviderFromRemoteUrl } from "./sourceControl-iWG-m4wE.mjs";
+import * as Effect$1 from "effect/Effect";
+import { Cause, Context, Duration, Effect, Exit, FileSystem, Layer, Metric, Path, Schema } from "effect";
+import { dual } from "effect/Function";
+import * as Random$1 from "effect/Random";
+//#region src/config.ts
+/**
+* ServerConfig - Runtime configuration services.
+*
+* Defines process-level server configuration and networking helpers used by
+* startup and runtime layers.
+*
+* @module ServerConfig
+*/
+const DEFAULT_PORT = 3773;
+const RuntimeMode = Schema.Literals(["web", "desktop"]);
+Schema.Literals(["browser", "headless"]);
+const deriveServerPaths = Effect.fn(function* (baseDir, devUrl) {
+	const { join } = yield* Path.Path;
+	const stateDir = join(baseDir, devUrl !== void 0 ? "dev" : "userdata");
+	const dbPath = join(stateDir, "state.sqlite");
+	const attachmentsDir = join(stateDir, "attachments");
+	const logsDir = join(stateDir, "logs");
+	const providerLogsDir = join(logsDir, "provider");
+	const providerStatusCacheDir = join(baseDir, "caches");
+	return {
+		stateDir,
+		dbPath,
+		keybindingsConfigPath: join(stateDir, "keybindings.json"),
+		settingsPath: join(stateDir, "settings.json"),
+		providerStatusCacheDir,
+		worktreesDir: join(baseDir, "worktrees"),
+		attachmentsDir,
+		logsDir,
+		serverLogPath: join(logsDir, "server.log"),
+		serverTracePath: join(logsDir, "server.trace.ndjson"),
+		providerLogsDir,
+		providerEventLogPath: join(providerLogsDir, "events.log"),
+		terminalLogsDir: join(logsDir, "terminals"),
+		anonymousIdPath: join(stateDir, "anonymous-id"),
+		environmentIdPath: join(stateDir, "environment-id"),
+		serverRuntimeStatePath: join(stateDir, "server-runtime.json"),
+		secretsDir: join(stateDir, "secrets")
+	};
+});
+const ensureServerDirectories = Effect.fn(function* (derivedPaths) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const directories = [
+		derivedPaths.stateDir,
+		derivedPaths.logsDir,
+		derivedPaths.providerLogsDir,
+		derivedPaths.terminalLogsDir,
+		derivedPaths.attachmentsDir,
+		derivedPaths.worktreesDir,
+		path.dirname(derivedPaths.keybindingsConfigPath),
+		path.dirname(derivedPaths.settingsPath),
+		derivedPaths.providerStatusCacheDir,
+		path.dirname(derivedPaths.anonymousIdPath),
+		path.dirname(derivedPaths.serverRuntimeStatePath)
+	];
+	yield* Effect.all([...new Set(directories)].map((directory) => fs.makeDirectory(directory, { recursive: true })), { concurrency: "unbounded" });
+});
+/**
+* ServerConfig - Service tag for server runtime configuration.
+*/
+var ServerConfig = class ServerConfig extends Context.Service()("ryco/config/ServerConfig") {
+	static layerTest = (cwd, baseDirOrPrefix) => Layer.effect(ServerConfig, Effect.gen(function* () {
+		const devUrl = void 0;
+		const fs = yield* FileSystem.FileSystem;
+		const baseDir = typeof baseDirOrPrefix === "string" ? baseDirOrPrefix : yield* fs.makeTempDirectoryScoped({ prefix: baseDirOrPrefix.prefix });
+		const derivedPaths = yield* deriveServerPaths(baseDir, devUrl);
+		yield* ensureServerDirectories(derivedPaths);
+		return {
+			logLevel: "Error",
+			traceMinLevel: "Info",
+			traceTimingEnabled: true,
+			traceBatchWindowMs: 200,
+			traceMaxBytes: 10 * 1024 * 1024,
+			traceMaxFiles: 10,
+			otlpTracesUrl: void 0,
+			otlpMetricsUrl: void 0,
+			otlpExportIntervalMs: 1e4,
+			otlpServiceName: "ryco-server",
+			cwd,
+			baseDir,
+			...derivedPaths,
+			mode: "web",
+			autoBootstrapProjectFromCwd: false,
+			logWebSocketEvents: false,
+			tailscaleServeEnabled: false,
+			tailscaleServePort: 443,
+			port: 0,
+			host: void 0,
+			desktopBootstrapToken: void 0,
+			staticDir: void 0,
+			devUrl,
+			noBrowser: false,
+			startupPresentation: "browser"
+		};
+	}));
+};
+const resolveStaticDir = Effect.fn(function* () {
+	const { join, resolve } = yield* Path.Path;
+	const { exists } = yield* FileSystem.FileSystem;
+	const bundledClient = resolve(join(import.meta.dirname, "client"));
+	if (yield* exists(join(bundledClient, "index.html")).pipe(Effect.orElseSucceed(() => false))) return bundledClient;
+	const monorepoClient = resolve(join(import.meta.dirname, "../../web/dist"));
+	if (yield* exists(join(monorepoClient, "index.html")).pipe(Effect.orElseSucceed(() => false))) return monorepoClient;
+});
+//#endregion
+//#region src/observability/Attributes.ts
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function markSeen(value, seen) {
+	if (seen.has(value)) return true;
+	seen.add(value);
+	return false;
+}
+function normalizeJsonValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value ?? null;
+	if (typeof value === "bigint") return value.toString();
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
+	if (value instanceof Error) return {
+		name: value.name,
+		message: value.message,
+		...value.stack ? { stack: value.stack } : {}
+	};
+	if (Array.isArray(value)) {
+		if (markSeen(value, seen)) return "[Circular]";
+		return value.map((entry) => normalizeJsonValue(entry, seen));
+	}
+	if (value instanceof Map) {
+		if (markSeen(value, seen)) return "[Circular]";
+		return Object.fromEntries(Array.from(value.entries(), ([key, entryValue]) => [String(key), normalizeJsonValue(entryValue, seen)]));
+	}
+	if (value instanceof Set) {
+		if (markSeen(value, seen)) return "[Circular]";
+		return Array.from(value.values(), (entry) => normalizeJsonValue(entry, seen));
+	}
+	if (!isPlainObject(value)) return String(value);
+	if (markSeen(value, seen)) return "[Circular]";
+	return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [key, normalizeJsonValue(entryValue, seen)]));
+}
+function compactTraceAttributes(attributes) {
+	return Object.fromEntries(Object.entries(attributes).filter(([, value]) => value !== void 0).map(([key, value]) => [key, normalizeJsonValue(value)]));
+}
+function compactMetricAttributes(attributes) {
+	return Object.fromEntries(Object.entries(attributes).flatMap(([key, value]) => {
+		if (value === void 0 || value === null) return [];
+		if (typeof value === "string") return [[key, value]];
+		if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return [[key, String(value)]];
+		return [];
+	}));
+}
+function outcomeFromExit(exit) {
+	if (Exit.isSuccess(exit)) return "success";
+	return Cause.hasInterruptsOnly(exit.cause) ? "interrupt" : "failure";
+}
+function normalizeModelMetricLabel(model) {
+	const normalized = model?.trim().toLowerCase();
+	if (!normalized) return;
+	if (normalized.includes("gpt")) return "gpt";
+	if (normalized.includes("claude")) return "claude";
+	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() {
+	return `${WORKTREE_BRANCH_PREFIX}/${Effect$1.runSync(Random$1.nextUUIDv4).replace(/-/g, "").slice(0, 8).toLowerCase()}`;
+}
+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
+	};
+}
+//#endregion
+//#region src/observability/Metrics.ts
+const metricNames = {
+	rpcRequestsTotal: "ryco_rpc_requests_total",
+	rpcRequestDuration: "ryco_rpc_request_duration",
+	orchestrationCommandsTotal: "ryco_orchestration_commands_total",
+	orchestrationCommandDuration: "ryco_orchestration_command_duration",
+	orchestrationCommandAckDuration: "ryco_orchestration_command_ack_duration",
+	orchestrationEventsProcessedTotal: "ryco_orchestration_events_processed_total",
+	providerSessionsTotal: "ryco_provider_sessions_total",
+	providerTurnsTotal: "ryco_provider_turns_total",
+	providerTurnDuration: "ryco_provider_turn_duration",
+	providerRuntimeEventsTotal: "ryco_provider_runtime_events_total",
+	providerEventLogRecordsDroppedTotal: "ryco_provider_event_log_records_dropped_total",
+	startupCommandGateEnqueuesTotal: "ryco_startup_command_gate_enqueues_total",
+	startupCommandGateQueueDepth: "ryco_startup_command_gate_queue_depth",
+	startupCommandGateQueueHighWater: "ryco_startup_command_gate_queue_high_water",
+	startupCommandGateQueueWaitDuration: "ryco_startup_command_gate_queue_wait_duration",
+	providerStartupAdmissionTotal: "ryco_provider_startup_admission_total",
+	providerStartupQueueDepth: "ryco_provider_startup_queue_depth",
+	providerStartupQueueHighWater: "ryco_provider_startup_queue_high_water",
+	providerStartupQueueWaitDuration: "ryco_provider_startup_queue_wait_duration",
+	gitCommandsTotal: "ryco_git_commands_total",
+	gitCommandDuration: "ryco_git_command_duration",
+	terminalSessionsTotal: "ryco_terminal_sessions_total",
+	terminalRestartsTotal: "ryco_terminal_restarts_total"
+};
+const rpcRequestsTotal = Metric.counter(metricNames.rpcRequestsTotal, { description: "Total RPC requests handled by the websocket RPC server." });
+const rpcRequestDuration = Metric.timer(metricNames.rpcRequestDuration, { description: "RPC request handling duration." });
+const orchestrationCommandsTotal = Metric.counter(metricNames.orchestrationCommandsTotal, { description: "Total orchestration commands dispatched." });
+const orchestrationCommandDuration = Metric.timer(metricNames.orchestrationCommandDuration, { description: "Orchestration command dispatch duration." });
+const orchestrationCommandAckDuration = Metric.timer(metricNames.orchestrationCommandAckDuration, { description: "Time from orchestration command dispatch to the first committed domain event emitted for that command." });
+const orchestrationEventsProcessedTotal = Metric.counter(metricNames.orchestrationEventsProcessedTotal, { description: "Total orchestration intent events processed by runtime reactors." });
+const providerSessionsTotal = Metric.counter(metricNames.providerSessionsTotal, { description: "Total provider session lifecycle operations." });
+const providerTurnsTotal = Metric.counter(metricNames.providerTurnsTotal, { description: "Total provider turn lifecycle operations." });
+const providerTurnDuration = Metric.timer(metricNames.providerTurnDuration, { description: "Provider turn request duration." });
+const providerRuntimeEventsTotal = Metric.counter(metricNames.providerRuntimeEventsTotal, { description: "Total canonical provider runtime events processed." });
+const providerEventLogRecordsDroppedTotal = Metric.counter(metricNames.providerEventLogRecordsDroppedTotal, { description: "Total provider observability log records dropped by bounded logging queues." });
+const startupCommandGateEnqueuesTotal = Metric.counter(metricNames.startupCommandGateEnqueuesTotal, { description: "Total startup command gate enqueue attempts by outcome." });
+const startupCommandGateQueueDepth = Metric.gauge(metricNames.startupCommandGateQueueDepth, { description: "Current number of commands waiting for startup command readiness." });
+const startupCommandGateQueueHighWater = Metric.gauge(metricNames.startupCommandGateQueueHighWater, { description: "Highest observed startup command gate queue depth." });
+const startupCommandGateQueueWaitDuration = Metric.timer(metricNames.startupCommandGateQueueWaitDuration, { description: "Time startup commands spent waiting for command readiness." });
+const providerStartupAdmissionTotal = Metric.counter(metricNames.providerStartupAdmissionTotal, { description: "Total provider startup admission attempts by outcome." });
+const providerStartupQueueDepth = Metric.gauge(metricNames.providerStartupQueueDepth, { description: "Current number of provider session starts in admission per provider instance." });
+const providerStartupQueueHighWater = Metric.gauge(metricNames.providerStartupQueueHighWater, { description: "Highest observed provider startup admission depth per provider instance." });
+const providerStartupQueueWaitDuration = Metric.timer(metricNames.providerStartupQueueWaitDuration, { description: "Time provider session starts spent waiting for startup admission." });
+const gitCommandsTotal = Metric.counter(metricNames.gitCommandsTotal, { description: "Total git commands executed by the server runtime." });
+const gitCommandDuration = Metric.timer(metricNames.gitCommandDuration, { description: "Git command execution duration." });
+const terminalSessionsTotal = Metric.counter(metricNames.terminalSessionsTotal, { description: "Total terminal sessions started." });
+const terminalRestartsTotal = Metric.counter(metricNames.terminalRestartsTotal, { description: "Total terminal restart requests handled." });
+const metricAttributes = (attributes) => Object.entries(compactMetricAttributes(attributes));
+const increment = (metric, attributes, amount = 1) => Metric.update(Metric.withAttributes(metric, metricAttributes(attributes)), amount);
+const withMetricsImpl = (effect, options) => Effect.gen(function* () {
+	const startedAt = Date.now();
+	const exit = yield* Effect.exit(effect);
+	const duration = Duration.millis(Math.max(0, Date.now() - startedAt));
+	const baseAttributes = typeof options.attributes === "function" ? options.attributes() : options.attributes ?? {};
+	if (options.timer) yield* Metric.update(Metric.withAttributes(options.timer, metricAttributes(baseAttributes)), duration);
+	if (options.counter) {
+		const outcome = outcomeFromExit(exit);
+		yield* Metric.update(Metric.withAttributes(options.counter, metricAttributes({
+			...baseAttributes,
+			outcome,
+			...options.outcomeAttributes ? options.outcomeAttributes(outcome) : {}
+		})), 1);
+	}
+	if (Exit.isSuccess(exit)) return exit.value;
+	return yield* Effect.failCause(exit.cause);
+});
+const withMetrics = dual(2, withMetricsImpl);
+const providerMetricAttributes = (provider, extra) => compactMetricAttributes({
+	provider,
+	...extra
+});
+const providerTurnMetricAttributes = (input) => {
+	const modelFamily = normalizeModelMetricLabel(input.model);
+	return compactMetricAttributes({
+		provider: input.provider,
+		...modelFamily ? { modelFamily } : {},
+		...input.extra
+	});
+};
+//#endregion
+export { buildTemporaryWorktreeBranchName as A, outcomeFromExit as B, startupCommandGateQueueDepth as C, terminalSessionsTotal as D, terminalRestartsTotal as E, normalizeGitRemoteUrl as F, ensureServerDirectories as G, RuntimeMode as H, resolveAutoFeatureBranchName as I, resolveStaticDir as K, sanitizeBranchFragment as L, detectSourceControlProviderFromGitRemoteUrl as M, isTemporaryWorktreeBranch as N, withMetrics as O, mergeGitStatusParts as P, sanitizeFeatureBranchName as R, startupCommandGateEnqueuesTotal as S, startupCommandGateQueueWaitDuration as T, ServerConfig as U, DEFAULT_PORT as V, deriveServerPaths as W, providerTurnDuration as _, orchestrationCommandAckDuration as a, rpcRequestDuration as b, orchestrationEventsProcessedTotal as c, providerRuntimeEventsTotal as d, providerSessionsTotal as f, providerStartupQueueWaitDuration as g, providerStartupQueueHighWater as h, metricAttributes as i, dedupeRemoteBranchesWithLocalMatches as j, WORKTREE_BRANCH_PREFIX as k, providerEventLogRecordsDroppedTotal as l, providerStartupQueueDepth as m, gitCommandsTotal as n, orchestrationCommandDuration as o, providerStartupAdmissionTotal as p, increment as r, orchestrationCommandsTotal as s, gitCommandDuration as t, providerMetricAttributes as u, providerTurnMetricAttributes as v, startupCommandGateQueueHighWater as w, rpcRequestsTotal as x, providerTurnsTotal as y, compactTraceAttributes as z };