@clinebot/core 0.0.35 → 0.0.36

package/src/runtime/host.ts

@@ -1,42 +1,17 @@
-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 { 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,16 +22,13 @@ 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;
@@ -70,130 +42,6 @@ async function reconcileDeadSessionsIfSupported(
 	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"],
-): 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",
-		});
-		return;
-	}
-	const entry = resolve(process.cwd(), entryArg);
-	if (!existsSync(entry)) {
-		lease.release();
-		logger?.error?.("RPC sidecar spawn aborted", {
-			address,
-			reason: "entrypoint_missing",
-			entryPath: entry,
-		});
-		return;
-	}
-	const conditionsArg = process.execArgv.find((arg) =>
-		arg.startsWith("--conditions="),
-	);
-	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;
-	}
-}
-
 function createLocalBackend(options: ClineCoreOptions): SessionBackend {
 	try {
 		const store = new SqliteSessionStore();
@@ -202,7 +50,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 +64,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 +91,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 +108,93 @@ export async function createRuntimeHost(
 	const distinctId = resolveCoreDistinctId(options.distinctId);
 	options.telemetry?.setDistinctId(distinctId);
 	const configuredMode = resolveConfiguredBackendMode(options);
-	if (requiresLocalRuntimeHost(options)) {
-		if (configuredMode === "rpc") {
+	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,
-			requestToolApproval: options.requestToolApproval,
-			distinctId,
+		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,
 		});
 	}
-	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,
+			},
+			{
+				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,
+				},
+				{
+					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/rules.ts

@@ -20,6 +20,18 @@ export function formatRulesForSystemPrompt(
 	return `\n\n# Rules\n${renderedRules}`;
 }
 
+export function mergeRulesForSystemPrompt(
+	primaryRules?: string,
+	additionalRules?: string,
+): string | undefined {
+	const primary = primaryRules?.trim();
+	const additional = additionalRules?.trim();
+	if (primary && additional) {
+		return `${primary}\n\n${additional}`;
+	}
+	return primary || additional || undefined;
+}
+
 export function listEnabledRulesFromWatcher(
 	watcher: UserInstructionConfigWatcher,
 ): RuleConfig[] {

package/src/runtime/runtime-builder.ts

@@ -32,6 +32,10 @@ import {
 	createDelegatedAgentConfigProvider,
 	type TeamEvent,
 } from "../extensions/tools/team";
+import {
+	filterDisabledTools,
+	resolveDisabledToolNames,
+} from "../services/global-settings";
 import { createLocalTeamStore } from "../services/storage/team-store";
 import type { CoreAgentMode, CoreSessionConfig } from "../types/config";
 import type {
@@ -74,6 +78,13 @@ function filterToolsByPolicies(
 	);
 }
 
+function filterAvailableTools(
+	tools: Tool[],
+	toolPolicies: CoreSessionConfig["toolPolicies"],
+): Tool[] {
+	return filterDisabledTools(filterToolsByPolicies(tools, toolPolicies));
+}
+
 export function createTeamName(): string {
 	return `team-${nanoid(5)}`;
 }
@@ -96,7 +107,7 @@ function createBuiltinToolsList(
 		toolRoutingRules ?? DEFAULT_MODEL_TOOL_ROUTING_RULES,
 	);
 
-	return filterToolsByPolicies(
+	return filterAvailableTools(
 		createBuiltinTools({
 			cwd,
 			...preset,
@@ -478,8 +489,10 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 		} = input;
 		const onTeamEvent = input.onTeamEvent ?? (() => {});
 		const normalized = normalizeConfig(config);
+		const globallyDisabledToolNames = resolveDisabledToolNames();
 		const tools: Tool[] = [];
 		const effectiveTeamName = config.teamName?.trim() || createTeamName();
+		const teamStoreKey = config.sessionId?.trim() || effectiveTeamName;
 		const hasLocalSkills = hasSkillsFiles(config.cwd);
 		let teamToolsRegistered = false;
 		const watcherProvided = Boolean(sharedUserInstructionWatcher);
@@ -535,7 +548,7 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 		const teamStore = normalized.enableAgentTeams
 			? createLocalTeamStore()
 			: undefined;
-		const restoredTeam = teamStore?.loadRuntime(effectiveTeamName);
+		const restoredTeam = teamStore?.loadRuntime(teamStoreKey);
 		const restoredTeamState = restoredTeam?.state;
 		const restoredTeammateSpecs = restoredTeam?.teammates ?? [];
 		const teammateSpecs = new Map(
@@ -606,9 +619,9 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 							if (event.type === "teammate_shutdown") {
 								teammateSpecs.delete(event.agentId);
 							}
-							teamStore.handleTeamEvent(effectiveTeamName, event);
+							teamStore.handleTeamEvent(teamStoreKey, event);
 							teamStore.persistRuntime(
-								effectiveTeamName,
+								teamStoreKey,
 								teamRuntime.exportState(),
 								Array.from(teammateSpecs.values()),
 							);
@@ -628,8 +641,7 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 				}
 				teamToolsRegistered = true;
 
-				const factory = input.teamToolsFactory ?? bootstrapAgentTeams;
-				const teamBootstrap = factory({
+				const teamBootstrap = bootstrapAgentTeams({
 					runtime: teamRuntime,
 					leadAgentId: config.sessionId || "lead",
 					restoredFromPersistence: Boolean(restoredTeamState),
@@ -714,7 +726,7 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 			: undefined;
 
 		return {
-			tools: filterToolsByPolicies(tools, config.toolPolicies),
+			tools: filterAvailableTools(tools, config.toolPolicies),
 			logger: logger ?? config.logger,
 			telemetry: telemetry ?? config.telemetry,
 			teamRuntime,
@@ -726,7 +738,11 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 			registerLeadAgent: (agent) => {
 				leadAgentInstance = agent;
 				if (pendingLeadTeamTools.length > 0) {
-					agent.addTools(pendingLeadTeamTools);
+					agent.addTools(
+						filterDisabledTools(pendingLeadTeamTools, [
+							...globallyDisabledToolNames,
+						]),
+					);
 				}
 			},
 			shutdown: async (reason: string) => {