@clinebot/core 0.0.28 → 0.0.30

package/src/runtime/runtime-builder.ts

@@ -1,25 +1,32 @@
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
-import {
-	AgentTeamsRuntime,
-	bootstrapAgentTeams,
-	createDelegatedAgentConfigProvider,
-	type TeamEvent,
-	type TeamTeammateSpec,
-	type Tool,
-} from "@clinebot/agents";
+import type { BasicLogger, TeamTeammateSpec, Tool } from "@clinebot/shared";
 import { resolveSkillsConfigSearchPaths } from "@clinebot/shared/storage";
 import { nanoid } from "nanoid";
 import {
 	createUserInstructionConfigWatcher,
 	type SkillConfig,
 	type UserInstructionConfigWatcher,
-} from "../agents";
-import { buildWorkspaceMetadata } from "../session/workspace-manifest";
+} from "../extensions/config";
+import {
+	createDefaultMcpServerClientFactory,
+	createMcpTools,
+	hasMcpSettingsFile,
+	InMemoryMcpManager,
+	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,
+	resolveToolPresetName,
 	resolveToolRoutingConfig,
 	type SkillsExecutor,
 	type ToolExecutors,
@@ -41,8 +48,6 @@ type SkillsExecutorMetadataItem = {
 	disabled: boolean;
 };
 
-const WORKSPACE_CONFIGURATION_MARKER = "# Workspace Configuration";
-
 type SkillsExecutorWithMetadata = SkillsExecutor & {
 	configuredSkills?: SkillsExecutorMetadataItem[];
 };
@@ -55,13 +60,13 @@ function createBuiltinToolsList(
 	cwd: string,
 	providerId: string,
 	mode: CoreAgentMode,
+	yolo: boolean | undefined,
 	modelId: string,
 	toolRoutingRules: ToolRoutingRule[] | undefined,
 	skillsExecutor?: SkillsExecutorWithMetadata,
 	executorOverrides?: Partial<ToolExecutors>,
 ): Tool[] {
-	const preset =
-		mode === "plan" ? ToolPresets.readonly : ToolPresets.development;
+	const preset = ToolPresets[resolveToolPresetName({ mode, yolo })];
 	const toolRoutingConfig = resolveToolRoutingConfig(
 		providerId,
 		modelId,
@@ -186,6 +191,64 @@ function hasSkillsFiles(workspacePath: string): boolean {
 	return false;
 }
 
+async function loadConfiguredMcpTools(logger?: BasicLogger): Promise<{
+	tools: Tool[];
+	shutdown?: () => Promise<void>;
+}> {
+	const settingsPath = resolveDefaultMcpSettingsPath();
+	if (!hasMcpSettingsFile({ filePath: settingsPath })) {
+		return { tools: [] };
+	}
+
+	const manager = new InMemoryMcpManager({
+		clientFactory: createDefaultMcpServerClientFactory(),
+	});
+
+	let registrations: Awaited<
+		ReturnType<typeof registerMcpServersFromSettingsFile>
+	>;
+	try {
+		registrations = await registerMcpServersFromSettingsFile(manager, {
+			filePath: settingsPath,
+		});
+	} catch (error) {
+		await manager.dispose().catch(() => {});
+		const message = error instanceof Error ? error.message : String(error);
+		logger?.log(
+			`[mcp] Failed to load MCP settings, skipping MCP tools: ${message}`,
+		);
+		return { tools: [] };
+	}
+
+	const enabled = registrations.filter((r) => r.disabled !== true);
+	const results = await Promise.allSettled(
+		enabled.map((r) =>
+			createMcpTools({ serverName: r.name, provider: manager }),
+		),
+	);
+	const tools: Tool[] = [];
+	for (const [i, result] of results.entries()) {
+		if (result.status === "fulfilled") {
+			tools.push(...result.value);
+		} else {
+			const message =
+				result.reason instanceof Error
+					? result.reason.message
+					: String(result.reason);
+			logger?.log(
+				`[mcp] Failed to load tools from MCP server "${enabled[i].name}", skipping: ${message}`,
+			);
+		}
+	}
+
+	return {
+		tools,
+		shutdown: async () => {
+			await manager.dispose();
+		},
+	};
+}
+
 function resolveSkillRecord(
 	watcher: UserInstructionConfigWatcher,
 	requestedSkill: string,
@@ -314,17 +377,6 @@ function shutdownTeamRuntime(
 	}
 }
 
-function extractWorkspaceMetadataFromSystemPrompt(
-	systemPrompt: string,
-): string | undefined {
-	const markerIndex = systemPrompt.lastIndexOf(WORKSPACE_CONFIGURATION_MARKER);
-	if (markerIndex < 0) {
-		return undefined;
-	}
-	const metadata = systemPrompt.slice(markerIndex).trim();
-	return metadata.length > 0 ? metadata : undefined;
-}
-
 function normalizeConfig(
 	config: CoreSessionConfig,
 ): Required<
@@ -334,17 +386,28 @@ function normalizeConfig(
 		| "enableTools"
 		| "enableSpawnAgent"
 		| "enableAgentTeams"
+		| "yolo"
 		| "missionLogIntervalSteps"
 		| "missionLogIntervalMs"
 		| "sessionId"
 	>
 > {
+	const preset =
+		ToolPresets[
+			resolveToolPresetName({
+				mode: config.mode,
+				yolo: config.yolo,
+			})
+		];
 	return {
 		sessionId: config.sessionId || "",
 		mode: config.mode === "plan" ? "plan" : "act",
 		enableTools: config.enableTools !== false,
-		enableSpawnAgent: config.enableSpawnAgent !== false,
-		enableAgentTeams: config.enableAgentTeams !== false,
+		enableSpawnAgent:
+			config.enableSpawnAgent ?? preset.enableSpawnAgent ?? true,
+		enableAgentTeams:
+			config.enableAgentTeams ?? preset.enableAgentTeams ?? true,
+		yolo: config.yolo === true,
 		missionLogIntervalSteps:
 			typeof config.missionLogIntervalSteps === "number" &&
 			Number.isFinite(config.missionLogIntervalSteps)
@@ -361,7 +424,7 @@ function normalizeConfig(
 export class DefaultRuntimeBuilder implements RuntimeBuilder {
 	private readonly teamRuntimeRegistry = new TeamRuntimeRegistry();
 
-	build(input: RuntimeBuilderInput): RuntimeEnvironment {
+	async build(input: RuntimeBuilderInput): Promise<RuntimeEnvironment> {
 		const {
 			config,
 			hooks,
@@ -382,6 +445,7 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 		let userInstructionWatcher = sharedUserInstructionWatcher;
 		let watcherReady = Promise.resolve();
 		let skillsExecutor: SkillsExecutorWithMetadata | undefined;
+		let mcpShutdown: (() => Promise<void>) | undefined;
 
 		if (
 			!userInstructionWatcher &&
@@ -416,12 +480,16 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 					config.cwd,
 					config.providerId,
 					normalized.mode,
+					normalized.yolo,
 					config.modelId,
 					config.toolRoutingRules,
 					skillsExecutor,
 					defaultToolExecutors,
 				),
 			);
+			const mcpRuntime = await loadConfiguredMcpTools(config.logger);
+			tools.push(...mcpRuntime.tools);
+			mcpShutdown = mcpRuntime.shutdown;
 		}
 
 		let teamRuntime: AgentTeamsRuntime | undefined;
@@ -435,6 +503,12 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 			restoredTeammateSpecs.map((spec) => [spec.agentId, spec] as const),
 		);
 		const registryKey = config.sessionId || effectiveTeamName;
+		let leadAgentInstance:
+			| {
+					addTools: (tools: Tool[]) => void;
+			  }
+			| undefined;
+		let pendingLeadTeamTools: Tool[] = [];
 		const delegatedAgentConfigProvider = createDelegatedAgentConfigProvider({
 			providerId: config.providerId,
 			modelId: config.modelId,
@@ -445,29 +519,13 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 			providerConfig: config.providerConfig,
 			knownModels: config.knownModels,
 			thinking: config.thinking,
-			clineWorkspaceMetadata:
-				config.providerId === "cline"
-					? extractWorkspaceMetadataFromSystemPrompt(config.systemPrompt)
-					: undefined,
 			maxIterations: config.maxIterations,
 			hooks,
 			extensions: extensions ?? config.extensions,
 			logger: logger ?? config.logger,
 			telemetry: input.telemetry ?? config.telemetry,
+			workspaceMetadata: config.workspaceMetadata,
 		});
-		const runtimeMetadata = delegatedAgentConfigProvider.getRuntimeConfig();
-		if (
-			config.providerId === "cline" &&
-			!runtimeMetadata.clineWorkspaceMetadata
-		) {
-			buildWorkspaceMetadata(config.cwd ?? "").then((metadata) => {
-				const current = delegatedAgentConfigProvider.getRuntimeConfig();
-				if (current.clineWorkspaceMetadata) {
-					return;
-				}
-				Object.assign(current, { clineWorkspaceMetadata: metadata });
-			});
-		}
 		this.teamRuntimeRegistry.getOrCreate(registryKey, () => ({
 			delegatedAgentConfigProvider,
 		}));
@@ -531,17 +589,25 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 				}
 				teamToolsRegistered = true;
 
-				const teamBootstrap = bootstrapAgentTeams({
+				const factory = input.teamToolsFactory ?? bootstrapAgentTeams;
+				const teamBootstrap = factory({
 					runtime: teamRuntime,
 					leadAgentId: "lead",
 					restoredFromPersistence: Boolean(restoredTeamState),
 					restoredTeammates: restoredTeammateSpecs,
+					includeLeadSpawnTool: true,
+					includeLeadManagementTools: true,
+					onLeadToolsUnlocked: (teamTools) => {
+						pendingLeadTeamTools = teamTools;
+						leadAgentInstance?.addTools(teamTools);
+					},
 					createBaseTools: normalized.enableTools
 						? () =>
 								createBuiltinToolsList(
 									config.cwd,
 									config.providerId,
 									normalized.mode,
+									normalized.yolo,
 									config.modelId,
 									config.toolRoutingRules,
 									skillsExecutor,
@@ -618,9 +684,16 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 				this.teamRuntimeRegistry.get(registryKey)
 					?.delegatedAgentConfigProvider ?? delegatedAgentConfigProvider,
 			completionGuard,
-			shutdown: (reason: string) => {
+			registerLeadAgent: (agent) => {
+				leadAgentInstance = agent;
+				if (pendingLeadTeamTools.length > 0) {
+					agent.addTools(pendingLeadTeamTools);
+				}
+			},
+			shutdown: async (reason: string) => {
 				shutdownTeamRuntime(teamRuntime, reason);
 				this.teamRuntimeRegistry.delete(registryKey);
+				await mcpShutdown?.();
 				if (!watcherProvided) {
 					userInstructionWatcher?.stop();
 				}

package/src/runtime/runtime-parity.test.ts

@@ -1,7 +1,7 @@
 import { mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { Tool } from "@clinebot/agents";
+import type { Tool } from "@clinebot/shared";
 import { describe, expect, it } from "vitest";
 import { createBuiltinTools } from "../tools";
 import { DefaultRuntimeBuilder } from "./runtime-builder";
@@ -47,9 +47,12 @@ function legacyBuildRuntimeEnvironment(
 
 function normalizeParityToolNames(toolNames: string[]): string[] {
 	// Skills are discovered from user/workspace config and can appear in tests
-	// depending on the machine state. They are intentionally excluded from
-	// strict legacy parity checks.
-	return toolNames.filter((toolName) => toolName !== "skills");
+	// depending on the machine state. MCP tools may also be configured outside
+	// the test workspace. They are intentionally excluded from strict legacy
+	// parity checks.
+	return toolNames.filter(
+		(toolName) => toolName !== "skills" && !toolName.includes("__"),
+	);
 }
 
 function makeEmptyWorkspaceCwd(): string {
@@ -66,7 +69,7 @@ function makeSpawnTool(): Tool {
 }
 
 describe("runtime tool parity", () => {
-	it("matches legacy tool list when tools+spawn are enabled", () => {
+	it("matches legacy tool list when tools+spawn are enabled", async () => {
 		const config: LegacyConfig = {
 			providerId: "anthropic",
 			modelId: "claude-sonnet-4-6",
@@ -83,17 +86,16 @@ describe("runtime tool parity", () => {
 				(tool) => tool.name,
 			),
 		);
-		const actual = new DefaultRuntimeBuilder()
-			.build({
-				config,
-				createSpawnTool,
-			})
-			.tools.map((tool) => tool.name);
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config,
+			createSpawnTool,
+		});
+		const actual = runtime.tools.map((tool) => tool.name);
 
 		expect(normalizeParityToolNames(actual)).toEqual(expected);
 	});
 
-	it("matches legacy tool list when only spawn is enabled", () => {
+	it("matches legacy tool list when only spawn is enabled", async () => {
 		const config: LegacyConfig = {
 			providerId: "anthropic",
 			modelId: "claude-sonnet-4-6",
@@ -110,17 +112,16 @@ describe("runtime tool parity", () => {
 				(tool) => tool.name,
 			),
 		);
-		const actual = new DefaultRuntimeBuilder()
-			.build({
-				config,
-				createSpawnTool,
-			})
-			.tools.map((tool) => tool.name);
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config,
+			createSpawnTool,
+		});
+		const actual = runtime.tools.map((tool) => tool.name);
 
 		expect(normalizeParityToolNames(actual)).toEqual(expected);
 	});
 
-	it("matches legacy tool list when tools+spawn are disabled", () => {
+	it("matches legacy tool list when tools+spawn are disabled", async () => {
 		const config: LegacyConfig = {
 			providerId: "anthropic",
 			modelId: "claude-sonnet-4-6",
@@ -134,9 +135,8 @@ describe("runtime tool parity", () => {
 		const expected = normalizeParityToolNames(
 			legacyBuildRuntimeEnvironment(config).map((tool) => tool.name),
 		);
-		const actual = new DefaultRuntimeBuilder()
-			.build({ config })
-			.tools.map((tool) => tool.name);
+		const runtime = await new DefaultRuntimeBuilder().build({ config });
+		const actual = runtime.tools.map((tool) => tool.name);
 
 		expect(normalizeParityToolNames(actual)).toEqual(expected);
 	});

package/src/runtime/session-runtime.ts

@@ -1,13 +1,19 @@
+import type { Agent } from "@clinebot/agents";
 import type {
 	AgentConfig,
 	AgentHooks,
 	AgentResult,
+	BasicLogger,
+	ITelemetryService,
+	TeamTeammateSpec,
+	Tool,
+} from "@clinebot/shared";
+import type { UserInstructionConfigWatcher } from "../extensions/config";
+import type {
 	AgentTeamsRuntime,
 	DelegatedAgentConfigProvider,
-	Tool,
-} from "@clinebot/agents";
-import type { BasicLogger, ITelemetryService } from "@clinebot/shared";
-import type { UserInstructionConfigWatcher } from "../agents";
+	TeamEvent,
+} from "../team";
 import type { ToolExecutors } from "../tools";
 import type { CoreSessionConfig } from "../types/config";
 
@@ -20,24 +26,48 @@ export interface BuiltRuntime {
 	teamRestoredFromPersistence?: boolean;
 	delegatedAgentConfigProvider?: DelegatedAgentConfigProvider;
 	completionGuard?: () => string | undefined;
+	registerLeadAgent?: (agent: Agent) => void;
 	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;
 	extensions?: AgentConfig["extensions"];
-	onTeamEvent?: (event: import("@clinebot/agents").TeamEvent) => void;
+	onTeamEvent?: (event: TeamEvent) => void;
 	createSpawnTool?: () => Tool;
 	onTeamRestored?: () => void;
 	userInstructionWatcher?: UserInstructionConfigWatcher;
 	defaultToolExecutors?: Partial<ToolExecutors>;
 	logger?: BasicLogger;
 	telemetry?: ITelemetryService;
+	teamToolsFactory?: TeamToolsFactory;
 }
 
 export interface RuntimeBuilder {
-	build(input: RuntimeBuilderInput): BuiltRuntime;
+	build(input: RuntimeBuilderInput): Promise<BuiltRuntime> | BuiltRuntime;
 }
 
 export interface SessionRuntime {

package/src/runtime/{sandbox/subprocess-sandbox.ts → subprocess-sandbox.ts}

@@ -1,4 +1,8 @@
 import { type ChildProcess, spawn } from "node:child_process";
+import {
+	augmentNodeCommandForDebug,
+	withResolvedClineBuildEnv,
+} from "@clinebot/shared";
 
 interface SandboxCallMessage {
 	type: "call";
@@ -66,10 +70,26 @@ export class SubprocessSandbox {
 			? [this.options.bootstrapFile]
 			: ["-e", this.options.bootstrapScript ?? ""];
 
-		const child = spawn(process.execPath, args, {
-			stdio: ["ignore", "ignore", "ignore", "ipc"],
+		const command = augmentNodeCommandForDebug([process.execPath, ...args], {
+			debugRole:
+				this.options.name === "plugin-sandbox" ? "plugin-sandbox" : "sandbox",
+		});
+		const child = spawn(command[0] ?? process.execPath, command.slice(1), {
+			stdio: ["ignore", "ignore", "pipe", "ipc"],
+			env: withResolvedClineBuildEnv(process.env),
 		});
 		this.process = child;
+		let stderrBuffer = "";
+		const appendStderr = (chunk: string) => {
+			const next = stderrBuffer + chunk;
+			// Keep only a small tail so errors include useful context
+			// without unbounded memory growth.
+			stderrBuffer = next.length > 4000 ? next.slice(-4000) : next;
+		};
+		child.stderr?.setEncoding("utf8");
+		child.stderr?.on("data", (chunk: string) => {
+			appendStderr(chunk);
+		});
 		child.on("message", (message) => {
 			this.onMessage(message as SandboxResponseMessage | SandboxEventMessage);
 		});
@@ -82,9 +102,10 @@ export class SubprocessSandbox {
 		});
 		child.on("exit", (code, signal) => {
 			this.process = null;
+			const stderrDetail = stderrBuffer.trim();
 			this.failPending(
 				new Error(
-					`${this.options.name ?? "sandbox"} process exited (code=${String(code)}, signal=${String(signal)})`,
+					`${this.options.name ?? "sandbox"} process exited (code=${String(code)}, signal=${String(signal)})${stderrDetail ? `: ${stderrDetail}` : ""}`,
 				),
 			);
 		});

package/src/runtime/team-runtime-registry.ts

@@ -1,7 +1,4 @@
-import type {
-	AgentTeamsRuntime,
-	DelegatedAgentConfigProvider,
-} from "@clinebot/agents";
+import type { AgentTeamsRuntime, DelegatedAgentConfigProvider } from "../team";
 
 export interface TeamRuntimeRegistryEntry {
 	runtime?: AgentTeamsRuntime;

package/src/runtime/tool-approval.ts

@@ -1,6 +1,6 @@
 import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import type { ToolApprovalRequest, ToolApprovalResult } from "@clinebot/agents";
+import type { ToolApprovalRequest, ToolApprovalResult } from "@clinebot/shared";
 
 export type DesktopToolApprovalOptions = {
 	approvalDir?: string;

package/src/session/default-session-manager.e2e.test.ts

@@ -9,8 +9,8 @@ import {
 } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { AgentResult } from "@clinebot/agents";
-import type * as LlmsProviders from "@clinebot/llms/providers";
+import type * as LlmsProviders from "@clinebot/llms";
+import type { AgentResult } from "@clinebot/shared";
 import { setClineDir, setHomeDir } from "@clinebot/shared/storage";
 import { nanoid } from "nanoid";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";