@clinebot/core 0.0.35 → 0.0.37

package/src/runtime/host.ts

@@ -1,42 +1,18 @@
-import { spawn } from "node:child_process";
-import { closeSync, existsSync, mkdirSync, openSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { getRpcServerDefaultAddress, getRpcServerHealth } from "@clinebot/rpc";
-import {
-	augmentNodeCommandForDebug,
-	withResolvedClineBuildEnv,
-} from "@clinebot/shared";
-import {
-	resolveClineDataDir,
-	resolveSessionDataDir,
-} from "@clinebot/shared/storage";
 import type { ClineCoreOptions } from "../ClineCore";
+import {
+	ensureCompatibleLocalHubUrl,
+	resolveCompatibleLocalHubUrl,
+} from "../hub/client";
+import { prewarmDetachedHubServer } from "../hub/daemon";
 import { SqliteSessionStore } from "../services/storage/sqlite-session-store";
 import { resolveCoreDistinctId } from "../services/telemetry/distinct-id";
 import { FileSessionService } from "../session/file-session-service";
-import { RpcCoreSessionService } from "../session/rpc-session-service";
 import { CoreSessionService } from "../session/session-service";
+import { HubRuntimeHost } from "../transports/hub";
 import { LocalRuntimeHost } from "../transports/local";
-import { RpcRuntimeHost } from "../transports/rpc";
-import {
-	ensureRpcRuntimeAddress,
-	RPC_BUILD_ID_ENV,
-	RPC_DISCOVERY_PATH_ENV,
-	RPC_OWNER_ID_ENV,
-	RPC_STARTUP_LOCK_BYPASS_ENV,
-	type RpcOwnerContext,
-	resolveRpcOwnerContext,
-} from "./rpc-runtime-ensure";
-import { tryAcquireRpcSpawnLease } from "./rpc-spawn-lease";
+import { RemoteRuntimeHost } from "../transports/remote";
 import type { RuntimeHost, RuntimeHostMode } from "./runtime-host";
 
-const DEFAULT_RPC_ADDRESS =
-	process.env.CLINE_RPC_ADDRESS?.trim() || getRpcServerDefaultAddress();
-
-function requiresLocalRuntimeHost(options: ClineCoreOptions): boolean {
-	return !!options.defaultToolExecutors || !!options.teamToolsFactory;
-}
-
 function resolveConfiguredBackendMode(
 	options: ClineCoreOptions,
 ): RuntimeHostMode {
@@ -47,151 +23,41 @@ function resolveConfiguredBackendMode(
 		return "local";
 	}
 	const raw = process.env.CLINE_SESSION_BACKEND_MODE?.trim().toLowerCase();
-	if (raw === "rpc" || raw === "local") {
+	if (raw === "local" || raw === "hub" || raw === "remote") {
 		return raw;
 	}
 	return "auto";
 }
 
-export type SessionBackend =
-	| RpcCoreSessionService
-	| CoreSessionService
-	| FileSessionService;
+export type SessionBackend = CoreSessionService | FileSessionService;
 
 let cachedBackend: SessionBackend | undefined;
 let backendInitPromise: Promise<SessionBackend> | undefined;
 
-async function reconcileDeadSessionsIfSupported(
-	backend: SessionBackend,
-): Promise<void> {
-	const service = backend as SessionBackend & {
-		reconcileDeadSessions?: (limit?: number) => Promise<number>;
-	};
-	await service.reconcileDeadSessions?.().catch(() => {});
-}
-
-function openRpcSidecarLogFile(): { fd: number; logPath: string } | undefined {
-	try {
-		const logPath = join(resolveClineDataDir(), "logs", "rpc-sidecar.log");
-		mkdirSync(dirname(logPath), { recursive: true });
-		return { fd: openSync(logPath, "a"), logPath };
-	} catch {
-		return undefined;
-	}
-}
-
-function startRpcServerInBackground(
-	address: string,
-	owner: RpcOwnerContext,
-	logger?: ClineCoreOptions["logger"],
+function prewarmLocalHubIfNeeded(
+	configuredMode: RuntimeHostMode,
+	options: ClineCoreOptions,
 ): void {
-	const lease = tryAcquireRpcSpawnLease(address);
-	if (!lease) {
-		logger?.log("RPC sidecar spawn skipped", {
-			address,
-			reason: "spawn_lease_unavailable",
-			severity: "warn",
-		});
-		return;
-	}
-	const launcher = process.execPath;
-	const entryArg = process.argv[1]?.trim();
-	if (!entryArg) {
-		lease.release();
-		logger?.error?.("RPC sidecar spawn aborted", {
-			address,
-			reason: "missing_process_entry_arg",
-		});
+	if (configuredMode !== "auto" && configuredMode !== "hub") {
 		return;
 	}
-	const entry = resolve(process.cwd(), entryArg);
-	if (!existsSync(entry)) {
-		lease.release();
-		logger?.error?.("RPC sidecar spawn aborted", {
-			address,
-			reason: "entrypoint_missing",
-			entryPath: entry,
-		});
+	if (options.hub?.endpoint?.trim()) {
 		return;
 	}
-	const conditionsArg = process.execArgv.find((arg) =>
-		arg.startsWith("--conditions="),
+	prewarmDetachedHubServer(
+		options.hub?.workspaceRoot?.trim() ||
+			options.hub?.cwd?.trim() ||
+			process.cwd(),
 	);
-	const command = augmentNodeCommandForDebug(
-		[
-			launcher,
-			...(conditionsArg ? [conditionsArg] : []),
-			entry,
-			"rpc",
-			"start",
-			"--address",
-			address,
-		],
-		{ debugRole: "rpc" },
-	);
-	const sidecarLog = openRpcSidecarLogFile();
-	logger?.log("Launching detached RPC sidecar", {
-		address,
-		command: command.join(" "),
-		commandArgs: command.slice(1),
-		executable: command[0] ?? launcher,
-		entryPath: entry,
-		cwd: process.cwd(),
-		logPath: sidecarLog?.logPath,
-	});
-	try {
-		const child = spawn(command[0] ?? launcher, command.slice(1), {
-			detached: true,
-			stdio: sidecarLog ? ["ignore", sidecarLog.fd, sidecarLog.fd] : "ignore",
-			env: {
-				...withResolvedClineBuildEnv(process.env),
-				[RPC_STARTUP_LOCK_BYPASS_ENV]: "1",
-				[RPC_OWNER_ID_ENV]: owner.ownerId,
-				[RPC_BUILD_ID_ENV]: owner.buildId,
-				[RPC_DISCOVERY_PATH_ENV]: owner.discoveryPath,
-				CLINE_NO_INTERACTIVE: "1",
-			},
-			cwd: process.cwd(),
-		});
-		logger?.log("Detached RPC sidecar spawned", {
-			address,
-			childPid: child.pid,
-			logPath: sidecarLog?.logPath,
-		});
-		child.unref();
-		setTimeout(() => lease.release(), 10_000).unref();
-	} catch (error) {
-		lease.release();
-		logger?.error?.("RPC sidecar spawn failed", {
-			address,
-			logPath: sidecarLog?.logPath,
-			error,
-		});
-		throw error;
-	} finally {
-		if (sidecarLog) {
-			closeSync(sidecarLog.fd);
-		}
-	}
 }
 
-async function tryConnectRpcBackend(
-	address: string,
-	options: ClineCoreOptions,
-): Promise<RpcCoreSessionService | undefined> {
-	try {
-		const health = await getRpcServerHealth(address);
-		if (!health) {
-			return undefined;
-		}
-		return new RpcCoreSessionService({
-			address,
-			sessionsDir: resolveSessionDataDir(),
-			messagesArtifactUploader: options.messagesArtifactUploader,
-		});
-	} catch {
-		return undefined;
-	}
+async function reconcileDeadSessionsIfSupported(
+	backend: SessionBackend,
+): Promise<void> {
+	const service = backend as SessionBackend & {
+		reconcileDeadSessions?: (limit?: number) => Promise<number>;
+	};
+	await service.reconcileDeadSessions?.().catch(() => {});
 }
 
 function createLocalBackend(options: ClineCoreOptions): SessionBackend {
@@ -202,7 +68,7 @@ function createLocalBackend(options: ClineCoreOptions): SessionBackend {
 			messagesArtifactUploader: options.messagesArtifactUploader,
 		});
 	} catch {
-		// Fallback to file-based session service if SQLite is unavailable (e.g. due to missing native bindings on certain platforms)
+		// Fallback to file-based session service if SQLite is unavailable.
 		options.telemetry?.capture({
 			event: "session_backend_fallback",
 			properties: {
@@ -216,6 +82,23 @@ function createLocalBackend(options: ClineCoreOptions): SessionBackend {
 	}
 }
 
+function createLocalRuntimeHost(
+	options: ClineCoreOptions,
+	distinctId: string,
+	backend?: SessionBackend,
+): LocalRuntimeHost {
+	return new LocalRuntimeHost({
+		sessionService:
+			backend ?? options.sessionService ?? createLocalBackend(options),
+		defaultToolExecutors: options.defaultToolExecutors,
+		telemetry: options.telemetry,
+		toolPolicies: options.toolPolicies,
+		requestToolApproval: options.requestToolApproval,
+		distinctId,
+		fetch: options.fetch,
+	});
+}
+
 export async function resolveSessionBackend(
 	options: ClineCoreOptions,
 ): Promise<SessionBackend> {
@@ -226,83 +109,7 @@ export async function resolveSessionBackend(
 		return await backendInitPromise;
 	}
 
-	const mode = resolveConfiguredBackendMode(options);
-	const requestedAddress = options.rpc?.address?.trim() || DEFAULT_RPC_ADDRESS;
-	const attempts = Math.max(1, options.rpc?.connectAttempts ?? 5);
-	const delayMs = Math.max(0, options.rpc?.connectDelayMs ?? 100);
-	const autoStartRpc = options.rpc?.autoStart !== false;
-	const logger = options.logger;
-
 	backendInitPromise = (async () => {
-		if (mode === "local") {
-			cachedBackend = createLocalBackend(options);
-			await reconcileDeadSessionsIfSupported(cachedBackend);
-			return cachedBackend;
-		}
-
-		let address = requestedAddress;
-		const existingRpcBackend = await tryConnectRpcBackend(address, options);
-		if (existingRpcBackend) {
-			logger?.log("Connected to existing RPC session backend", { address });
-			cachedBackend = existingRpcBackend;
-			await reconcileDeadSessionsIfSupported(cachedBackend);
-			return cachedBackend;
-		}
-
-		if (mode === "rpc") {
-			throw new Error(`RPC backend unavailable at ${address}`);
-		}
-
-		if (autoStartRpc) {
-			try {
-				logger?.log("Ensuring RPC runtime for auto session backend", {
-					address,
-				});
-				const ensured = await ensureRpcRuntimeAddress(address, {
-					resolveOwner: () => resolveRpcOwnerContext({ ownerPrefix: "core" }),
-					spawnIfNeeded: (rpcAddress, owner) => {
-						startRpcServerInBackground(rpcAddress, owner, logger);
-					},
-				});
-				address = ensured.address;
-				logger?.log("RPC runtime ensure completed", {
-					requestedAddress,
-					address,
-					action: ensured.action,
-				});
-			} catch (error) {
-				logger?.error?.("RPC backend auto-start failed", {
-					address,
-					requestedAddress,
-					error,
-				});
-			}
-
-			for (let attempt = 0; attempt < attempts; attempt += 1) {
-				const rpcBackend = await tryConnectRpcBackend(address, options);
-				if (rpcBackend) {
-					logger?.log("Connected to ensured RPC session backend", {
-						address,
-						attempt: attempt + 1,
-						attempts,
-					});
-					cachedBackend = rpcBackend;
-					await reconcileDeadSessionsIfSupported(cachedBackend);
-					return cachedBackend;
-				}
-				if (delayMs > 0) {
-					await new Promise((resolve) => setTimeout(resolve, delayMs));
-				}
-			}
-		}
-
-		logger?.log("Falling back to local session backend", {
-			requestedAddress,
-			address,
-			attempts,
-			delayMs,
-			severity: "warn",
-		});
 		cachedBackend = createLocalBackend(options);
 		await reconcileDeadSessionsIfSupported(cachedBackend);
 		return cachedBackend;
@@ -319,44 +126,97 @@ export async function createRuntimeHost(
 	const distinctId = resolveCoreDistinctId(options.distinctId);
 	options.telemetry?.setDistinctId(distinctId);
 	const configuredMode = resolveConfiguredBackendMode(options);
-	if (requiresLocalRuntimeHost(options)) {
-		if (configuredMode === "rpc") {
+	prewarmLocalHubIfNeeded(configuredMode, options);
+	if (configuredMode === "remote") {
+		const remoteEndpoint = options.remote?.endpoint?.trim();
+		if (!remoteEndpoint) {
 			throw new Error(
-				"RPC runtime mode does not support local-only runtime host options such as custom tool executors or team tools factories.",
+				"Remote runtime mode requires `remote.endpoint` to be configured.",
 			);
 		}
-		options.logger?.log("Using local runtime host due to local-only options", {
-			configuredMode,
-			hasDefaultToolExecutors: !!options.defaultToolExecutors,
-			hasTeamToolsFactory: !!options.teamToolsFactory,
+		options.logger?.log("Using remote runtime host", {
+			endpoint: remoteEndpoint,
 		});
-		const backend = options.sessionService ?? createLocalBackend(options);
-		return new LocalRuntimeHost({
-			sessionService: backend,
-			defaultToolExecutors: options.defaultToolExecutors,
-			teamToolsFactory: options.teamToolsFactory,
-			telemetry: options.telemetry,
-			toolPolicies: options.toolPolicies,
+		return new RemoteRuntimeHost({
+			endpoint: remoteEndpoint,
+			authToken: options.remote?.authToken,
+			clientType: options.remote?.clientType,
+			displayName: options.remote?.displayName,
+			workspaceRoot: options.remote?.workspaceRoot,
+			cwd: options.remote?.cwd,
 			requestToolApproval: options.requestToolApproval,
-			distinctId,
 		});
 	}
-	const backend =
-		options.sessionService ?? (await resolveSessionBackend(options));
-	if (backend instanceof RpcCoreSessionService) {
-		return new RpcRuntimeHost(
-			backend,
-			options.toolPolicies,
-			options.requestToolApproval,
+	if (configuredMode === "hub") {
+		const explicitEndpoint = options.hub?.endpoint?.trim();
+		const hubUrl =
+			explicitEndpoint ||
+			(await ensureCompatibleLocalHubUrl({
+				strategy: options.hub?.strategy ?? "require-hub",
+				workspaceRoot: options.hub?.workspaceRoot,
+				cwd: options.hub?.cwd,
+			}));
+		if (!hubUrl) {
+			throw new Error("No compatible hub runtime is available.");
+		}
+		options.logger?.log("Using hub runtime host", {
+			url: hubUrl,
+			explicitEndpoint: explicitEndpoint || undefined,
+		});
+		return new HubRuntimeHost(
+			{
+				url: hubUrl,
+				authToken: options.hub?.authToken,
+				clientType: options.hub?.clientType,
+				displayName: options.hub?.displayName,
+				requestToolApproval: options.requestToolApproval,
+			},
+			{
+				workspaceRoot: options.hub?.workspaceRoot,
+				cwd: options.hub?.cwd,
+			},
 		);
 	}
-	return new LocalRuntimeHost({
-		sessionService: backend,
-		defaultToolExecutors: options.defaultToolExecutors,
-		teamToolsFactory: options.teamToolsFactory,
-		telemetry: options.telemetry,
-		toolPolicies: options.toolPolicies,
-		requestToolApproval: options.requestToolApproval,
-		distinctId,
-	});
+	if (configuredMode === "auto") {
+		const hubUrl = await resolveCompatibleLocalHubUrl({
+			endpoint: options.hub?.endpoint,
+			strategy: options.hub?.strategy ?? "prefer-hub",
+			workspaceRoot: options.hub?.workspaceRoot,
+			cwd: options.hub?.cwd,
+		});
+		if (hubUrl) {
+			options.logger?.log("Using discovered local hub runtime host", {
+				url: hubUrl,
+			});
+			const host = new HubRuntimeHost(
+				{
+					url: hubUrl,
+					authToken: options.hub?.authToken,
+					clientType: options.hub?.clientType,
+					displayName: options.hub?.displayName,
+					requestToolApproval: options.requestToolApproval,
+				},
+				{
+					workspaceRoot: options.hub?.workspaceRoot,
+					cwd: options.hub?.cwd,
+				},
+			);
+			try {
+				await host.connect();
+				return host;
+			} catch (error) {
+				options.logger?.log("Falling back to local runtime host", {
+					reason: "hub_connect_failed",
+					severity: "warn",
+					error,
+				});
+			}
+		}
+		options.logger?.log("Falling back to local runtime host", {
+			reason: "compatible_hub_unavailable",
+			severity: "warn",
+		});
+		return createLocalRuntimeHost(options, distinctId);
+	}
+	return createLocalRuntimeHost(options, distinctId);
 }

package/src/runtime/index.ts

@@ -3,6 +3,7 @@ export {
 	isRuleEnabled,
 	listEnabledRulesFromWatcher,
 	loadRulesForSystemPromptFromWatcher,
+	mergeRulesForSystemPrompt,
 } from "./rules";
 export { createTeamName, DefaultRuntimeBuilder } from "./runtime-builder";
 export type {

package/src/runtime/loop-detection.ts

@@ -0,0 +1,162 @@
+/**
+ * Repeated tool-call loop detection.
+ *
+ * @see PLAN.md §3.1 — helpers moved from `packages/agents/src/context/loop-detection.ts`.
+ * @see PLAN.md §3.2.3 — public surface of `LoopDetectionTracker`.
+ *
+ * The pure helpers (`createLoopDetectionState`, `resetLoopDetectionState`,
+ * `toolCallSignature`, `checkRepeatedToolCall`) are ported verbatim. The
+ * `LoopDetectionTracker` class is a thin wrapper that owns a
+ * `LoopDetectionState` and exposes the `inspect()` / `reset()` surface that
+ * `SessionRuntime` installs as a `beforeTool` hook per §3.2.3.
+ */
+
+import type { LoopDetectionConfig } from "@clinebot/shared";
+
+// =============================================================================
+// Pure helpers (verbatim port)
+// =============================================================================
+
+export interface LoopDetectionState {
+	lastToolName: string;
+	lastToolSignature: string;
+	consecutiveIdenticalCount: number;
+}
+
+export function createLoopDetectionState(): LoopDetectionState {
+	return {
+		lastToolName: "",
+		lastToolSignature: "",
+		consecutiveIdenticalCount: 0,
+	};
+}
+
+export function resetLoopDetectionState(state: LoopDetectionState): void {
+	state.lastToolName = "";
+	state.lastToolSignature = "";
+	state.consecutiveIdenticalCount = 0;
+}
+
+function sortKeys(value: unknown): unknown {
+	if (value == null || typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map(sortKeys);
+	const sorted: Record<string, unknown> = {};
+	for (const key of Object.keys(value as Record<string, unknown>).sort()) {
+		sorted[key] = sortKeys((value as Record<string, unknown>)[key]);
+	}
+	return sorted;
+}
+
+export function toolCallSignature(input: unknown): string {
+	if (input == null) return "null";
+	if (typeof input === "string") return input;
+	if (typeof input !== "object") return String(input);
+	try {
+		return JSON.stringify(sortKeys(input));
+	} catch {
+		return String(input);
+	}
+}
+
+export interface LoopCheckResult {
+	softWarning: boolean;
+	hardEscalation: boolean;
+}
+
+export function checkRepeatedToolCall(
+	state: LoopDetectionState,
+	toolName: string,
+	signature: string,
+	config: LoopDetectionConfig,
+): LoopCheckResult {
+	if (
+		toolName === state.lastToolName &&
+		signature === state.lastToolSignature
+	) {
+		state.consecutiveIdenticalCount++;
+	} else {
+		state.consecutiveIdenticalCount = 1;
+	}
+	state.lastToolName = toolName;
+	state.lastToolSignature = signature;
+
+	return {
+		softWarning: state.consecutiveIdenticalCount === config.softThreshold,
+		hardEscalation: state.consecutiveIdenticalCount >= config.hardThreshold,
+	};
+}
+
+// =============================================================================
+// Class wrapper (new — per PLAN.md §3.2.3)
+// =============================================================================
+
+/**
+ * Verdict returned by {@link LoopDetectionTracker.inspect}.
+ *
+ * - `"ok"`   — no repeated call detected.
+ * - `"soft"` — soft-warning threshold reached; SessionRuntime may surface a
+ *              recovery notice but should not block the call.
+ * - `"hard"` — hard-escalation threshold reached; SessionRuntime should
+ *              stop the run with the provided `message`.
+ */
+export interface LoopDetectionVerdict {
+	kind: "ok" | "soft" | "hard";
+	message?: string;
+}
+
+/** Minimal call shape the tracker needs; matches `AgentToolCallPart` subset. */
+export interface LoopDetectionCall {
+	name: string;
+	input: unknown;
+}
+
+const DEFAULT_CONFIG: LoopDetectionConfig = {
+	softThreshold: 3,
+	hardThreshold: 5,
+};
+
+/**
+ * Per-session repeated-tool-call detector.
+ *
+ * `SessionRuntime` owns the instance and installs a `beforeTool` hook
+ * (see `AgentRuntimeHooks.beforeTool`) that calls `inspect()` to decide
+ * whether to return `{ skip, stop, reason }`.
+ */
+export class LoopDetectionTracker {
+	private readonly config: LoopDetectionConfig;
+	private readonly state: LoopDetectionState = createLoopDetectionState();
+
+	constructor(config?: Partial<LoopDetectionConfig>) {
+		this.config = {
+			softThreshold: config?.softThreshold ?? DEFAULT_CONFIG.softThreshold,
+			hardThreshold: config?.hardThreshold ?? DEFAULT_CONFIG.hardThreshold,
+		};
+	}
+
+	inspect(call: LoopDetectionCall): LoopDetectionVerdict {
+		const signature = toolCallSignature(call.input);
+		const result = checkRepeatedToolCall(
+			this.state,
+			call.name,
+			signature,
+			this.config,
+		);
+		if (result.hardEscalation) {
+			return {
+				kind: "hard",
+				message: `Detected ${this.state.consecutiveIdenticalCount} consecutive identical calls to \`${call.name}\`; stopping to avoid a loop.`,
+			};
+		}
+		if (result.softWarning) {
+			return {
+				kind: "soft",
+				message: `Detected ${this.state.consecutiveIdenticalCount} consecutive identical calls to \`${call.name}\`; consider trying a different approach.`,
+			};
+		}
+		return { kind: "ok" };
+	}
+
+	reset(): void {
+		resetLoopDetectionState(this.state);
+	}
+}