@clinebot/core 0.0.34 → 0.0.36

package/src/runtime/history.ts

@@ -0,0 +1,237 @@
+import type * as LlmsProviders from "@clinebot/llms";
+import { formatDisplayUserInput, normalizeUserInput } from "@clinebot/shared";
+import type {
+	SessionHistoryMetadata,
+	SessionHistoryRecord,
+	SessionRecord,
+} from "../types/sessions";
+import type { RuntimeHost } from "./runtime-host";
+
+type StoredSessionMessage = LlmsProviders.Message & {
+	metrics?: {
+		cost?: number;
+	};
+	modelInfo?: {
+		id?: string;
+		provider?: string;
+	};
+};
+
+type TextBlock = {
+	type?: string;
+	text?: string;
+};
+
+function asTrimmedString(value: unknown): string | undefined {
+	if (typeof value !== "string") {
+		return undefined;
+	}
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function asKnownString(value: unknown): string | undefined {
+	const trimmed = asTrimmedString(value);
+	if (!trimmed) {
+		return undefined;
+	}
+	return trimmed.toLowerCase() === "unknown" ? undefined : trimmed;
+}
+
+function asFiniteNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value)
+		? value
+		: undefined;
+}
+
+function asHistoryMetadata(value: unknown): SessionHistoryMetadata | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return undefined;
+	}
+	return { ...(value as Record<string, unknown>) };
+}
+
+function extractTextFromContent(
+	content: LlmsProviders.Message["content"],
+): string {
+	if (typeof content === "string") {
+		return content.trim();
+	}
+	const segments: string[] = [];
+	for (const block of content) {
+		if (!block || typeof block !== "object") {
+			continue;
+		}
+		const maybeText = block as TextBlock;
+		if (maybeText.type !== "text") {
+			continue;
+		}
+		const text = maybeText.text?.trim();
+		if (text) {
+			segments.push(text);
+		}
+	}
+	return segments.join("\n").trim();
+}
+
+function toSingleLine(text: string): string {
+	return text.replace(/\s+/g, " ").trim();
+}
+
+function truncateText(text: string, limit: number): string {
+	if (text.length <= limit) {
+		return text;
+	}
+	return `${text.slice(0, Math.max(0, limit - 3)).trimEnd()}...`;
+}
+
+function inferTitleFromMessages(
+	messages: LlmsProviders.Message[],
+): string | undefined {
+	for (const role of ["user", "assistant"] as const) {
+		for (const raw of messages) {
+			if (raw.role !== role) {
+				continue;
+			}
+			const text = toSingleLine(extractTextFromContent(raw.content));
+			if (!text) {
+				continue;
+			}
+			const formatted =
+				role === "user" ? toSingleLine(formatDisplayUserInput(text)) : text;
+			const normalized = normalizeUserInput(
+				formatted.split("\n")[0] ?? formatted,
+			);
+			return truncateText(normalized, 50);
+		}
+	}
+	return undefined;
+}
+
+function summarizeCostFromMessages(messages: LlmsProviders.Message[]): number {
+	let total = 0;
+	for (const message of messages as StoredSessionMessage[]) {
+		total += asFiniteNumber(message.metrics?.cost) ?? 0;
+	}
+	return total;
+}
+
+function inferProviderAndModelFromMessages(messages: LlmsProviders.Message[]): {
+	provider?: string;
+	model?: string;
+} {
+	let provider: string | undefined;
+	let model: string | undefined;
+	for (let i = messages.length - 1; i >= 0; i -= 1) {
+		const message = messages[i] as StoredSessionMessage;
+		if (!provider) {
+			provider = asKnownString(message.modelInfo?.provider);
+		}
+		if (!model) {
+			model = asKnownString(message.modelInfo?.id);
+		}
+		if (provider && model) {
+			break;
+		}
+	}
+	return { provider, model };
+}
+
+function getMetadataProvider(
+	metadata?: SessionHistoryMetadata,
+): string | undefined {
+	return (
+		asKnownString(metadata?.provider) ??
+		asKnownString(
+			metadata?.provider &&
+				typeof metadata.provider === "object" &&
+				!Array.isArray(metadata.provider)
+				? (metadata.provider as Record<string, unknown>).id
+				: undefined,
+		)
+	);
+}
+
+function getMetadataModel(
+	metadata?: SessionHistoryMetadata,
+): string | undefined {
+	return (
+		asKnownString(metadata?.model) ??
+		asKnownString(
+			metadata?.model &&
+				typeof metadata.model === "object" &&
+				!Array.isArray(metadata.model)
+				? (metadata.model as Record<string, unknown>).id
+				: undefined,
+		)
+	);
+}
+
+function normalizeHistoryRow(
+	row: SessionRecord,
+	overrides?: {
+		title?: string;
+		provider?: string;
+		model?: string;
+		totalCost?: number;
+	},
+): SessionHistoryRecord {
+	const metadata = asHistoryMetadata(row.metadata);
+	const title =
+		asTrimmedString(overrides?.title) ?? asTrimmedString(metadata?.title);
+	const totalCost =
+		asFiniteNumber(overrides?.totalCost) ?? asFiniteNumber(metadata?.totalCost);
+	const nextMetadata =
+		metadata || title !== undefined || totalCost !== undefined
+			? {
+					...(metadata ?? {}),
+					...(title !== undefined ? { title } : {}),
+					...(totalCost !== undefined ? { totalCost } : {}),
+				}
+			: undefined;
+	return {
+		...row,
+		provider:
+			asKnownString(overrides?.provider) ??
+			asKnownString(row.provider) ??
+			getMetadataProvider(metadata) ??
+			"",
+		model:
+			asKnownString(overrides?.model) ??
+			asKnownString(row.model) ??
+			getMetadataModel(metadata) ??
+			"",
+		metadata: nextMetadata,
+	};
+}
+
+export async function hydrateSessionHistory(
+	host: Pick<RuntimeHost, "readMessages">,
+	rows: SessionRecord[],
+): Promise<SessionHistoryRecord[]> {
+	return await Promise.all(
+		rows.map(async (row) => {
+			const initial = normalizeHistoryRow(row);
+			const hasTitle = Boolean(asTrimmedString(initial.metadata?.title));
+			const hasProvider = Boolean(asKnownString(initial.provider));
+			const hasModel = Boolean(asKnownString(initial.model));
+			const knownCost = asFiniteNumber(initial.metadata?.totalCost);
+			const hasCost = knownCost !== undefined && knownCost > 0;
+			if (hasTitle && hasProvider && hasModel && hasCost) {
+				return initial;
+			}
+			const messages = await host.readMessages(row.sessionId);
+			if (messages.length === 0) {
+				return initial;
+			}
+			const inferredProviderModel = inferProviderAndModelFromMessages(messages);
+			const inferredCost = summarizeCostFromMessages(messages);
+			return normalizeHistoryRow(row, {
+				title: hasTitle ? undefined : inferTitleFromMessages(messages),
+				provider: hasProvider ? undefined : inferredProviderModel.provider,
+				model: hasModel ? undefined : inferredProviderModel.model,
+				totalCost: hasCost || inferredCost <= 0 ? undefined : inferredCost,
+			});
+		}),
+	);
+}

package/src/runtime/host.ts

@@ -0,0 +1,200 @@
+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 { CoreSessionService } from "../session/session-service";
+import { HubRuntimeHost } from "../transports/hub";
+import { LocalRuntimeHost } from "../transports/local";
+import { RemoteRuntimeHost } from "../transports/remote";
+import type { RuntimeHost, RuntimeHostMode } from "./runtime-host";
+
+function resolveConfiguredBackendMode(
+	options: ClineCoreOptions,
+): RuntimeHostMode {
+	if (options.backendMode) {
+		return options.backendMode;
+	}
+	if (process.env.CLINE_VCR?.trim()) {
+		return "local";
+	}
+	const raw = process.env.CLINE_SESSION_BACKEND_MODE?.trim().toLowerCase();
+	if (raw === "local" || raw === "hub" || raw === "remote") {
+		return raw;
+	}
+	return "auto";
+}
+
+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 createLocalBackend(options: ClineCoreOptions): SessionBackend {
+	try {
+		const store = new SqliteSessionStore();
+		store.init();
+		return new CoreSessionService(store, {
+			messagesArtifactUploader: options.messagesArtifactUploader,
+		});
+	} catch {
+		// Fallback to file-based session service if SQLite is unavailable.
+		options.telemetry?.capture({
+			event: "session_backend_fallback",
+			properties: {
+				requestedBackend: "sqlite",
+				fallbackBackend: "file",
+			},
+		});
+		return new FileSessionService(undefined, {
+			messagesArtifactUploader: options.messagesArtifactUploader,
+		});
+	}
+}
+
+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> {
+	if (cachedBackend) {
+		return cachedBackend;
+	}
+	if (backendInitPromise) {
+		return await backendInitPromise;
+	}
+
+	backendInitPromise = (async () => {
+		cachedBackend = createLocalBackend(options);
+		await reconcileDeadSessionsIfSupported(cachedBackend);
+		return cachedBackend;
+	})().finally(() => {
+		backendInitPromise = undefined;
+	});
+
+	return await backendInitPromise;
+}
+
+export async function createRuntimeHost(
+	options: ClineCoreOptions,
+): Promise<RuntimeHost> {
+	const distinctId = resolveCoreDistinctId(options.distinctId);
+	options.telemetry?.setDistinctId(distinctId);
+	const configuredMode = resolveConfiguredBackendMode(options);
+	if (configuredMode === "remote") {
+		const remoteEndpoint = options.remote?.endpoint?.trim();
+		if (!remoteEndpoint) {
+			throw new Error(
+				"Remote runtime mode requires `remote.endpoint` to be configured.",
+			);
+		}
+		options.logger?.log("Using remote runtime host", {
+			endpoint: remoteEndpoint,
+		});
+		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,
+		});
+	}
+	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,
+			},
+		);
+	}
+	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

@@ -16,13 +16,6 @@ import {
 	registerMcpServersFromSettingsFile,
 	resolveDefaultMcpSettingsPath,
 } from "../extensions/mcp";
-import { createLocalTeamStore } from "../storage/team-store";
-import {
-	AgentTeamsRuntime,
-	bootstrapAgentTeams,
-	createDelegatedAgentConfigProvider,
-	type TeamEvent,
-} from "../team";
 import {
 	createBuiltinTools,
 	DEFAULT_MODEL_TOOL_ROUTING_RULES,
@@ -32,7 +25,18 @@ import {
 	type ToolExecutors,
 	ToolPresets,
 	type ToolRoutingRule,
-} from "../tools";
+} from "../extensions/tools";
+import {
+	AgentTeamsRuntime,
+	bootstrapAgentTeams,
+	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 {
 	RuntimeBuilder,
@@ -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)}`;
 }
@@ -82,14 +93,13 @@ function createBuiltinToolsList(
 	cwd: string,
 	providerId: string,
 	mode: CoreAgentMode,
-	yolo: boolean | undefined,
 	modelId: string,
 	toolRoutingRules: ToolRoutingRule[] | undefined,
 	toolPolicies: CoreSessionConfig["toolPolicies"],
 	skillsExecutor?: SkillsExecutorWithMetadata,
 	executorOverrides?: Partial<ToolExecutors>,
 ): Tool[] {
-	const preset = ToolPresets[resolveToolPresetName({ mode, yolo })];
+	const preset = ToolPresets[resolveToolPresetName({ mode })];
 	const toolRoutingConfig = resolveToolRoutingConfig(
 		providerId,
 		modelId,
@@ -97,7 +107,7 @@ function createBuiltinToolsList(
 		toolRoutingRules ?? DEFAULT_MODEL_TOOL_ROUTING_RULES,
 	);
 
-	return filterToolsByPolicies(
+	return filterAvailableTools(
 		createBuiltinTools({
 			cwd,
 			...preset,
@@ -429,16 +439,11 @@ function normalizeConfig(
 		| "sessionId"
 	>
 > {
-	const preset =
-		ToolPresets[
-			resolveToolPresetName({
-				mode: config.mode,
-				yolo: config.yolo,
-			})
-		];
+	const preset = ToolPresets[resolveToolPresetName({ mode: config.mode })];
 	return {
 		sessionId: config.sessionId || "",
-		mode: config.mode === "plan" ? "plan" : "act",
+		mode:
+			config.mode === "plan" ? "plan" : config.mode === "yolo" ? "yolo" : "act",
 		enableTools: config.enableTools !== false,
 		enableSpawnAgent:
 			config.enableSpawnAgent ?? preset.enableSpawnAgent ?? true,
@@ -484,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);
@@ -523,7 +530,6 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 					config.cwd,
 					config.providerId,
 					normalized.mode,
-					normalized.yolo,
 					config.modelId,
 					config.toolRoutingRules,
 					config.toolPolicies,
@@ -542,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(
@@ -613,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()),
 							);
@@ -635,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),
@@ -653,7 +658,6 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 									config.cwd,
 									config.providerId,
 									normalized.mode,
-									normalized.yolo,
 									config.modelId,
 									config.toolRoutingRules,
 									config.toolPolicies,
@@ -715,14 +719,14 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 						if (pending) parts.push(`Unfinished tasks: ${pending}`);
 						if (activeRunSummary)
 							parts.push(`Active runs: ${activeRunSummary}`);
-						return `[SYSTEM] You still have team obligations. ${parts.join(". ")}. Use team_run_task to delegate work, or team_task with action=complete to mark tasks done, or team_await_run / team_await_all_runs to wait for active runs. Do NOT stop until all tasks are completed.`;
+						return `[SYSTEM] You still have team obligations. ${parts.join(". ")}. Use team_run_task to delegate work, or team_task with action=complete to mark tasks done, or team_await_runs to wait for active runs. Do NOT stop until all tasks are completed.`;
 					}
 					return undefined;
 				}
 			: undefined;
 
 		return {
-			tools: filterToolsByPolicies(tools, config.toolPolicies),
+			tools: filterAvailableTools(tools, config.toolPolicies),
 			logger: logger ?? config.logger,
 			telemetry: telemetry ?? config.telemetry,
 			teamRuntime,
@@ -734,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) => {