@clinebot/core 0.0.34 → 0.0.36

package/src/runtime/runtime-host.ts

@@ -0,0 +1,206 @@
+import type * as LlmsProviders from "@clinebot/llms";
+import type {
+	AgentResult,
+	ToolApprovalRequest,
+	ToolApprovalResult,
+} from "@clinebot/shared";
+import type { ToolExecutors } from "../extensions/tools";
+import type { HookEventPayload } from "../hooks";
+import type { ProviderSettings } from "../llms/provider-settings";
+import type { SessionManifest } from "../session/session-manifest";
+import type { SessionSource } from "../types/common";
+import type { CoreSessionConfig } from "../types/config";
+import type { CoreSessionEvent } from "../types/events";
+import type { SessionRecord } from "../types/sessions";
+
+type LocalOnlyCoreSessionConfigKeys =
+	| "hooks"
+	| "logger"
+	| "telemetry"
+	| "extraTools"
+	| "extensions"
+	| "onTeamEvent"
+	| "onConsecutiveMistakeLimitReached";
+
+export type RuntimeSessionConfig = Omit<
+	CoreSessionConfig,
+	LocalOnlyCoreSessionConfigKeys | "checkpoint" | "compaction"
+> & {
+	checkpoint?: Omit<
+		NonNullable<CoreSessionConfig["checkpoint"]>,
+		"createCheckpoint"
+	>;
+	compaction?: Omit<NonNullable<CoreSessionConfig["compaction"]>, "compact">;
+};
+
+export type LocalRuntimeConfigOverrides = Pick<
+	CoreSessionConfig,
+	LocalOnlyCoreSessionConfigKeys
+> & {
+	checkpoint?: Pick<
+		NonNullable<CoreSessionConfig["checkpoint"]>,
+		"createCheckpoint"
+	> &
+		Partial<NonNullable<CoreSessionConfig["checkpoint"]>>;
+	compaction?: Pick<NonNullable<CoreSessionConfig["compaction"]>, "compact"> &
+		Partial<NonNullable<CoreSessionConfig["compaction"]>>;
+};
+
+export interface LocalRuntimeStartOptions {
+	configOverrides?: Partial<LocalRuntimeConfigOverrides>;
+	modelCatalogDefaults?: Partial<NonNullable<ProviderSettings["modelCatalog"]>>;
+	userInstructionWatcher?: import("../extensions/config").UserInstructionConfigWatcher;
+	onTeamRestored?: () => void;
+	defaultToolExecutors?: Partial<ToolExecutors>;
+}
+
+export interface StartSessionInput {
+	config: RuntimeSessionConfig;
+	source?: SessionSource;
+	prompt?: string;
+	interactive?: boolean;
+	sessionMetadata?: Record<string, unknown>;
+	initialMessages?: LlmsProviders.Message[];
+	userImages?: string[];
+	userFiles?: string[];
+	/**
+	 * Host-local bootstrap options. These are intentionally isolated from the
+	 * transport-neutral runtime session config so all runtime hosts share the
+	 * same execution contract while still allowing host-specific preparation.
+	 */
+	localRuntime?: LocalRuntimeStartOptions;
+	toolPolicies?: import("@clinebot/shared").AgentConfig["toolPolicies"];
+	requestToolApproval?: (
+		request: ToolApprovalRequest,
+	) => Promise<ToolApprovalResult>;
+}
+
+export function splitCoreSessionConfig(config: CoreSessionConfig): {
+	config: RuntimeSessionConfig;
+	localRuntime?: LocalRuntimeStartOptions;
+} {
+	const {
+		hooks,
+		logger,
+		telemetry,
+		extraTools,
+		extensions,
+		onTeamEvent,
+		onConsecutiveMistakeLimitReached,
+		checkpoint,
+		compaction,
+		...transportConfig
+	} = config;
+
+	const localConfigOverrides: Partial<LocalRuntimeConfigOverrides> = {};
+	if (hooks) localConfigOverrides.hooks = hooks;
+	if (logger) localConfigOverrides.logger = logger;
+	if (telemetry) localConfigOverrides.telemetry = telemetry;
+	if (extraTools) localConfigOverrides.extraTools = extraTools;
+	if (extensions) localConfigOverrides.extensions = extensions;
+	if (onTeamEvent) localConfigOverrides.onTeamEvent = onTeamEvent;
+	if (onConsecutiveMistakeLimitReached) {
+		localConfigOverrides.onConsecutiveMistakeLimitReached =
+			onConsecutiveMistakeLimitReached;
+	}
+	if (checkpoint?.createCheckpoint) {
+		localConfigOverrides.checkpoint = checkpoint;
+	}
+	if (compaction?.compact) {
+		localConfigOverrides.compaction = compaction;
+	}
+
+	const localRuntime =
+		Object.keys(localConfigOverrides).length > 0
+			? {
+					configOverrides:
+						localConfigOverrides as Partial<LocalRuntimeConfigOverrides>,
+				}
+			: undefined;
+
+	return {
+		config: {
+			...transportConfig,
+			...(checkpoint ? { checkpoint: { enabled: checkpoint.enabled } } : {}),
+			...(compaction
+				? {
+						compaction: {
+							enabled: compaction.enabled,
+							strategy: compaction.strategy,
+							thresholdRatio: compaction.thresholdRatio,
+							reserveTokens: compaction.reserveTokens,
+							preserveRecentTokens: compaction.preserveRecentTokens,
+							contextWindowTokens: compaction.contextWindowTokens,
+							summarizer: compaction.summarizer,
+						},
+					}
+				: {}),
+		},
+		...(localRuntime ? { localRuntime } : {}),
+	};
+}
+
+export interface StartSessionResult {
+	sessionId: string;
+	manifest: SessionManifest;
+	manifestPath: string;
+	messagesPath: string;
+	result?: AgentResult;
+}
+
+export interface SendSessionInput {
+	sessionId: string;
+	prompt: string;
+	userImages?: string[];
+	userFiles?: string[];
+	delivery?: "queue" | "steer";
+}
+
+export interface SessionAccumulatedUsage {
+	inputTokens: number;
+	outputTokens: number;
+	cacheReadTokens: number;
+	cacheWriteTokens: number;
+	totalCost: number;
+}
+
+export interface RuntimeHostSubscribeOptions {
+	sessionId?: string;
+}
+
+/**
+ * RuntimeHost is the transport/runtime boundary for core session execution.
+ * Callers must normalize broad local config into `RuntimeSessionConfig`
+ * plus optional `localRuntime` overrides before invoking a host.
+ */
+export interface RuntimeHost {
+	readonly runtimeAddress?: string;
+	start(input: StartSessionInput): Promise<StartSessionResult>;
+	send(input: SendSessionInput): Promise<AgentResult | undefined>;
+	getAccumulatedUsage(
+		sessionId: string,
+	): Promise<SessionAccumulatedUsage | undefined>;
+	abort(sessionId: string, reason?: unknown): Promise<void>;
+	stop(sessionId: string): Promise<void>;
+	dispose(reason?: string): Promise<void>;
+	get(sessionId: string): Promise<SessionRecord | undefined>;
+	list(limit?: number): Promise<SessionRecord[]>;
+	delete(sessionId: string): Promise<boolean>;
+	update(
+		sessionId: string,
+		updates: {
+			prompt?: string | null;
+			metadata?: Record<string, unknown> | null;
+			title?: string | null;
+		},
+	): Promise<{ updated: boolean }>;
+	readMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
+	handleHookEvent(payload: HookEventPayload): Promise<void>;
+	subscribe(
+		listener: (event: CoreSessionEvent) => void,
+		options?: RuntimeHostSubscribeOptions,
+	): () => void;
+	updateSessionModel?(sessionId: string, modelId: string): Promise<void>;
+}
+
+export type RuntimeHostMode = "auto" | "local" | "hub" | "remote";

package/src/{session → runtime}/runtime-oauth-token-manager.ts

@@ -1,4 +1,3 @@
-import type * as LlmsProviders from "@clinebot/llms";
 import {
 	type ITelemetryService,
 	isOAuthProviderId,
@@ -11,7 +10,8 @@ import {
 import { getValidOpenAICodexCredentials } from "../auth/codex";
 import { getValidOcaCredentials } from "../auth/oca";
 import { decodeJwtPayload } from "../auth/utils";
-import { ProviderSettingsManager } from "../storage/provider-settings-manager";
+import { ProviderSettingsManager } from "../services/storage/provider-settings-manager";
+import type { ProviderSettings } from "../types/provider-settings";
 
 const DEFAULT_CLINE_API_BASE_URL = "https://api.cline.bot";
 const WORKOS_TOKEN_PREFIX = "workos:";
@@ -51,12 +51,12 @@ function readExpiryFromToken(accessToken: string): number | null {
 }
 
 function deriveCredentialExpiry(
-	settings: LlmsProviders.ProviderSettings,
+	settings: ProviderSettings,
 	normalizedAccessToken: string,
 ): number {
 	const explicitExpiry = (
 		settings.auth as
-			| (LlmsProviders.ProviderSettings["auth"] & { expiresAt?: number })
+			| (ProviderSettings["auth"] & { expiresAt?: number })
 			| undefined
 	)?.expiresAt;
 	if (
@@ -78,7 +78,7 @@ function deriveCredentialExpiry(
 
 function toCredentials(
 	providerId: ManagedOAuthProviderId,
-	settings: LlmsProviders.ProviderSettings,
+	settings: ProviderSettings,
 ): ClineOAuthCredentials | null {
 	const rawAccess = settings.auth?.accessToken?.trim();
 	const refreshToken = settings.auth?.refreshToken?.trim();
@@ -99,18 +99,14 @@ function toCredentials(
 }
 
 function authSettingsEqual(
-	a: LlmsProviders.ProviderSettings["auth"] | undefined,
-	b: LlmsProviders.ProviderSettings["auth"] | undefined,
+	a: ProviderSettings["auth"] | undefined,
+	b: ProviderSettings["auth"] | undefined,
 ): boolean {
 	const aExpiry = (
-		a as
-			| (LlmsProviders.ProviderSettings["auth"] & { expiresAt?: number })
-			| undefined
+		a as (ProviderSettings["auth"] & { expiresAt?: number }) | undefined
 	)?.expiresAt;
 	const bExpiry = (
-		b as
-			| (LlmsProviders.ProviderSettings["auth"] & { expiresAt?: number })
-			| undefined
+		b as (ProviderSettings["auth"] & { expiresAt?: number }) | undefined
 	)?.expiresAt;
 	return (
 		a?.accessToken === b?.accessToken &&
@@ -219,9 +215,9 @@ export class RuntimeOAuthTokenManager {
 			accessToken: persistedAccessToken,
 			refreshToken: nextCredentials.refresh,
 			accountId: nextCredentials.accountId,
-		} as LlmsProviders.ProviderSettings["auth"] & { expiresAt?: number };
+		} as ProviderSettings["auth"] & { expiresAt?: number };
 		nextAuth.expiresAt = nextCredentials.expires;
-		const nextSettings: LlmsProviders.ProviderSettings = {
+		const nextSettings: ProviderSettings = {
 			...settings,
 			auth: nextAuth,
 		};
@@ -243,7 +239,7 @@ export class RuntimeOAuthTokenManager {
 
 	private async resolveCredentials(
 		providerId: ManagedOAuthProviderId,
-		settings: LlmsProviders.ProviderSettings,
+		settings: ProviderSettings,
 		currentCredentials: ClineOAuthCredentials,
 		forceRefresh: boolean,
 	): Promise<ClineOAuthCredentials | null> {

package/src/runtime/session-runtime.ts

@@ -5,16 +5,15 @@ import type {
 	AgentResult,
 	BasicLogger,
 	ITelemetryService,
-	TeamTeammateSpec,
 	Tool,
 } from "@clinebot/shared";
 import type { UserInstructionConfigWatcher } from "../extensions/config";
+import type { ToolExecutors } from "../extensions/tools";
 import type {
 	AgentTeamsRuntime,
 	DelegatedAgentConfigProvider,
 	TeamEvent,
-} from "../team";
-import type { ToolExecutors } from "../tools";
+} from "../extensions/tools/team";
 import type { CoreSessionConfig } from "../types/config";
 
 export interface BuiltRuntime {
@@ -30,28 +29,6 @@ export interface BuiltRuntime {
 	shutdown: (reason: string) => Promise<void> | void;
 }
 
-export interface TeamToolsFactoryOptions {
-	runtime: AgentTeamsRuntime;
-	teammateConfigProvider: DelegatedAgentConfigProvider;
-	createBaseTools?: () => Tool[];
-	leadAgentId?: string;
-	restoredTeammates?: TeamTeammateSpec[];
-	restoredFromPersistence?: boolean;
-	includeLeadSpawnTool?: boolean;
-	includeLeadManagementTools?: boolean;
-	onLeadToolsUnlocked?: (tools: Tool[]) => void;
-}
-
-export interface TeamToolsFactoryResult {
-	tools: Tool[];
-	restoredFromPersistence: boolean;
-	restoredTeammates: string[];
-}
-
-export type TeamToolsFactory = (
-	options: TeamToolsFactoryOptions,
-) => TeamToolsFactoryResult;
-
 export interface RuntimeBuilderInput {
 	config: CoreSessionConfig;
 	hooks?: AgentHooks;
@@ -63,7 +40,6 @@ export interface RuntimeBuilderInput {
 	defaultToolExecutors?: Partial<ToolExecutors>;
 	logger?: BasicLogger;
 	telemetry?: ITelemetryService;
-	teamToolsFactory?: TeamToolsFactory;
 }
 
 export interface RuntimeBuilder {

package/src/{session/session-agent-events.ts → services/agent-events.ts}

@@ -1,4 +1,9 @@
 import type { AgentEvent } from "@clinebot/shared";
+import type { SessionAccumulatedUsage } from "../runtime/runtime-host";
+import type { CoreSessionConfig } from "../types/config";
+import type { CoreSessionEvent } from "../types/events";
+import type { ActiveSession } from "../types/session";
+import { serializeAgentEvent } from "./session-data";
 import {
 	captureConversationTurnEvent,
 	captureDiffEditFailure,
@@ -7,13 +12,8 @@ import {
 	captureTokenUsage,
 	captureToolUsage,
 	type TelemetryAgentIdentityProperties,
-} from "../telemetry/core-events";
-import type { CoreSessionConfig } from "../types/config";
-import type { CoreSessionEvent } from "../types/events";
-import type { SessionAccumulatedUsage } from "./session-manager";
-import { serializeAgentEvent } from "./utils/helpers";
-import type { ActiveSession } from "./utils/types";
-import { accumulateUsageTotals } from "./utils/usage";
+} from "./telemetry/core-events";
+import { accumulateUsageTotals } from "./usage";
 
 export function extractSkillNameFromToolInput(
 	input: unknown,

package/src/services/config.ts

@@ -0,0 +1,5 @@
+import type { CoreSessionConfig } from "../types/config";
+
+export function resolveWorkspacePath(config: CoreSessionConfig): string {
+	return config.workspaceRoot ?? config.cwd;
+}

package/src/services/global-settings.ts

@@ -0,0 +1,122 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import type { AgentConfig, Tool } from "@clinebot/shared";
+import { resolveGlobalSettingsPath } from "@clinebot/shared/storage";
+
+type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
+type AgentExtensionApi = Parameters<NonNullable<AgentExtension["setup"]>>[0];
+
+export interface GlobalSettings {
+	disabledTools?: string[];
+}
+
+function normalizeDisabledTools(value: unknown): string[] | undefined {
+	if (!Array.isArray(value)) {
+		return undefined;
+	}
+
+	const normalized = [
+		...new Set(
+			value
+				.filter((entry): entry is string => typeof entry === "string")
+				.map((entry) => entry.trim())
+				.filter(Boolean),
+		),
+	].sort((left, right) => left.localeCompare(right));
+
+	return normalized.length > 0 ? normalized : undefined;
+}
+
+export function readGlobalSettings(): GlobalSettings {
+	const filePath = resolveGlobalSettingsPath();
+	try {
+		const parsed = JSON.parse(readFileSync(filePath, "utf8")) as GlobalSettings;
+		return {
+			disabledTools: normalizeDisabledTools(parsed.disabledTools),
+		};
+	} catch {
+		return {};
+	}
+}
+
+export function writeGlobalSettings(settings: GlobalSettings): void {
+	const filePath = resolveGlobalSettingsPath();
+	mkdirSync(dirname(filePath), { recursive: true });
+	const normalizedDisabledTools = normalizeDisabledTools(
+		settings.disabledTools,
+	);
+	const normalized: GlobalSettings = normalizedDisabledTools
+		? { disabledTools: normalizedDisabledTools }
+		: {};
+	writeFileSync(filePath, `${JSON.stringify(normalized, null, 2)}\n`, "utf8");
+}
+
+export function resolveDisabledToolNames(
+	disabledToolNames?: ReadonlyArray<string>,
+): Set<string> {
+	return new Set(disabledToolNames ?? readGlobalSettings().disabledTools ?? []);
+}
+
+export function isToolDisabledGlobally(toolName: string): boolean {
+	return resolveDisabledToolNames().has(toolName);
+}
+
+export function toggleDisabledTool(toolName: string): boolean {
+	const disabled = resolveDisabledToolNames();
+	if (disabled.has(toolName)) {
+		disabled.delete(toolName);
+		writeGlobalSettings({ disabledTools: [...disabled] });
+		return false;
+	}
+
+	disabled.add(toolName);
+	writeGlobalSettings({ disabledTools: [...disabled] });
+	return true;
+}
+
+export function filterDisabledTools<T extends Pick<Tool, "name">>(
+	tools: ReadonlyArray<T>,
+	disabledToolNames?: ReadonlyArray<string>,
+): T[] {
+	const disabled = resolveDisabledToolNames(disabledToolNames);
+	if (disabled.size === 0) {
+		return [...tools];
+	}
+	return tools.filter((tool) => !disabled.has(tool.name));
+}
+
+export function filterExtensionToolRegistrations(
+	extensions: AgentConfig["extensions"],
+	disabledToolNames?: ReadonlyArray<string>,
+): AgentConfig["extensions"] {
+	if (!extensions || extensions.length === 0) {
+		return extensions;
+	}
+
+	const disabled = resolveDisabledToolNames(disabledToolNames);
+	if (disabled.size === 0) {
+		return extensions;
+	}
+
+	return extensions.map((extension) => {
+		if (!extension.setup) {
+			return extension;
+		}
+
+		return {
+			...extension,
+			setup: (api: AgentExtensionApi, ctx) =>
+				extension.setup?.(
+					{
+						...api,
+						registerTool: (tool) => {
+							if (!disabled.has(tool.name)) {
+								api.registerTool(tool);
+							}
+						},
+					},
+					ctx,
+				),
+		};
+	});
+}