@clinebot/core 0.0.22 → 0.0.24

package/src/runtime/index.ts

@@ -0,0 +1,37 @@
+export {
+	type AvailableRuntimeCommand,
+	listAvailableRuntimeCommandsFromWatcher,
+	resolveRuntimeSlashCommandFromWatcher,
+} from "./commands";
+export {
+	formatRulesForSystemPrompt,
+	isRuleEnabled,
+	listEnabledRulesFromWatcher,
+	loadRulesForSystemPromptFromWatcher,
+} from "./rules";
+export { createTeamName, DefaultRuntimeBuilder } from "./runtime-builder";
+export {
+	type SandboxCallOptions,
+	SubprocessSandbox,
+	type SubprocessSandboxOptions,
+} from "./sandbox/subprocess-sandbox";
+export type {
+	BuiltRuntime,
+	RuntimeBuilder,
+	RuntimeBuilderInput,
+	SessionRuntime,
+} from "./session-runtime";
+export {
+	type AvailableSkill,
+	listAvailableSkillsFromWatcher,
+	resolveSkillsSlashCommandFromWatcher,
+} from "./skills";
+export {
+	type DesktopToolApprovalOptions,
+	requestDesktopToolApproval,
+} from "./tool-approval";
+export {
+	type AvailableWorkflow,
+	listAvailableWorkflowsFromWatcher,
+	resolveWorkflowSlashCommandFromWatcher,
+} from "./workflows";

package/src/runtime/rules.ts

@@ -0,0 +1,34 @@
+import type { RuleConfig, UserInstructionConfigWatcher } from "../agents";
+
+export function isRuleEnabled(rule: RuleConfig): boolean {
+	return rule.disabled !== true;
+}
+
+export function formatRulesForSystemPrompt(
+	rules: ReadonlyArray<RuleConfig>,
+): string {
+	if (rules.length === 0) {
+		return "";
+	}
+
+	const renderedRules = rules
+		.map((rule) => `## ${rule.name}\n${rule.instructions}`)
+		.join("\n\n");
+	return `\n\n# Rules\n${renderedRules}`;
+}
+
+export function listEnabledRulesFromWatcher(
+	watcher: UserInstructionConfigWatcher,
+): RuleConfig[] {
+	const snapshot = watcher.getSnapshot("rule");
+	return [...snapshot.values()]
+		.map((record) => record.item as RuleConfig)
+		.filter(isRuleEnabled)
+		.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function loadRulesForSystemPromptFromWatcher(
+	watcher: UserInstructionConfigWatcher,
+): string {
+	return formatRulesForSystemPrompt(listEnabledRulesFromWatcher(watcher));
+}

package/src/runtime/runtime-builder.team-persistence.test.ts

@@ -0,0 +1,245 @@
+import { describe, expect, it, vi } from "vitest";
+
+const createBuiltinToolsMock = vi.fn(() => []);
+const bootstrapAgentTeamsMock = vi.fn(() => ({
+	tools: [],
+	restoredFromPersistence: true,
+	restoredTeammates: ["restored-1"],
+}));
+
+let runtimeInstance: MockAgentTeamsRuntime | undefined;
+class MockAgentTeamsRuntime {
+	private readonly onTeamEvent?: (event: any) => void;
+
+	constructor(options: { onTeamEvent?: (event: any) => void }) {
+		this.onTeamEvent = options.onTeamEvent;
+		runtimeInstance = this;
+	}
+
+	emit(event: any): void {
+		this.onTeamEvent?.(event);
+	}
+
+	hydrateState = vi.fn();
+	exportState = vi.fn(() => ({
+		members: [],
+		tasks: [],
+		mailbox: [],
+		missionLog: [],
+		runs: [],
+		outcomes: [],
+		outcomeFragments: [],
+	}));
+	markStaleRunsInterrupted = vi.fn();
+	getTeammateIds = vi.fn(() => []);
+	shutdownTeammate = vi.fn();
+}
+
+vi.mock("@clinebot/agents", () => ({
+	AgentTeamsRuntime: MockAgentTeamsRuntime,
+	bootstrapAgentTeams: bootstrapAgentTeamsMock,
+	createDelegatedAgentConfigProvider: (config: Record<string, unknown>) => {
+		let runtimeConfig = { ...config };
+		return {
+			getRuntimeConfig: () => runtimeConfig,
+			getConnectionConfig: () => ({
+				providerId: runtimeConfig.providerId,
+				modelId: runtimeConfig.modelId,
+				apiKey: runtimeConfig.apiKey,
+				baseUrl: runtimeConfig.baseUrl,
+				headers: runtimeConfig.headers,
+				providerConfig: runtimeConfig.providerConfig,
+				knownModels: runtimeConfig.knownModels,
+				thinking: runtimeConfig.thinking,
+			}),
+			updateConnectionDefaults: (overrides: Record<string, unknown>) => {
+				runtimeConfig = { ...runtimeConfig, ...overrides };
+			},
+		};
+	},
+}));
+
+vi.mock("../default-tools", () => ({
+	ALL_DEFAULT_TOOL_NAMES: [],
+	createBuiltinTools: createBuiltinToolsMock,
+	ToolPresets: {
+		development: {},
+		readonly: {},
+	},
+}));
+
+let teamStoreInstance: MockTeamStore | undefined;
+class MockTeamStore {
+	constructor() {
+		teamStoreInstance = this;
+	}
+
+	loadRuntime = vi.fn(() => ({
+		state: {
+			teamId: "team_1",
+			teamName: "test",
+			members: [],
+			tasks: [],
+			mailbox: [],
+			missionLog: [],
+			runs: [],
+			outcomes: [],
+			outcomeFragments: [],
+		},
+		teammates: [
+			{
+				agentId: "restored-1",
+				rolePrompt: "Persisted teammate",
+				modelId: "claude-sonnet-4-5-20250929",
+				maxIterations: 4,
+			},
+		],
+		interruptedRunIds: ["run_00001"],
+	}));
+	handleTeamEvent = vi.fn();
+	persistRuntime = vi.fn();
+}
+
+vi.mock("../storage/team-store", () => ({
+	createLocalTeamStore: () => new MockTeamStore(),
+}));
+
+describe("DefaultRuntimeBuilder team persistence boundary", () => {
+	it("persists teammate specs and runtime state from team events", async () => {
+		const { DefaultRuntimeBuilder } = await import("./runtime-builder");
+		const onTeamRestored = vi.fn();
+
+		new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				headers: {
+					Authorization: "Bearer team-token",
+				},
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				enableTools: false,
+				enableSpawnAgent: false,
+				enableAgentTeams: true,
+			},
+			onTeamRestored,
+		});
+
+		expect(bootstrapAgentTeamsMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				restoredFromPersistence: true,
+				restoredTeammates: [expect.objectContaining({ agentId: "restored-1" })],
+				teammateConfigProvider: expect.objectContaining({
+					getRuntimeConfig: expect.any(Function),
+				}),
+			}),
+		);
+		const bootstrapCall = (
+			bootstrapAgentTeamsMock.mock.calls as unknown as Array<
+				[Record<string, any>]
+			>
+		)[0]?.[0];
+		expect(bootstrapCall).toBeDefined();
+		expect(bootstrapCall?.teammateConfigProvider.getRuntimeConfig()).toEqual(
+			expect.objectContaining({
+				headers: {
+					Authorization: "Bearer team-token",
+				},
+			}),
+		);
+		expect(onTeamRestored).toHaveBeenCalledTimes(1);
+		expect(runtimeInstance).toBeDefined();
+		expect(teamStoreInstance).toBeDefined();
+		if (!runtimeInstance || !teamStoreInstance) {
+			throw new Error("Expected mocked runtime and team store instances");
+		}
+
+		expect(runtimeInstance.markStaleRunsInterrupted).toHaveBeenCalledWith(
+			"runtime_recovered",
+		);
+
+		runtimeInstance.emit({
+			type: "teammate_spawned",
+			agentId: "python-poet",
+			teammate: {
+				rolePrompt: "Write concise Python-focused haiku",
+				modelId: "claude-sonnet-4-5-20250929",
+				maxIterations: 7,
+			},
+		});
+		expect(teamStoreInstance.handleTeamEvent).toHaveBeenCalledWith(
+			expect.any(String),
+			expect.objectContaining({
+				type: "teammate_spawned",
+				agentId: "python-poet",
+			}),
+		);
+		expect(teamStoreInstance.persistRuntime).toHaveBeenCalled();
+
+		runtimeInstance.emit({
+			type: "teammate_shutdown",
+			agentId: "python-poet",
+		});
+		expect(teamStoreInstance.handleTeamEvent).toHaveBeenCalledWith(
+			expect.any(String),
+			expect.objectContaining({
+				type: "teammate_shutdown",
+				agentId: "python-poet",
+			}),
+		);
+	});
+
+	it("forwards cline workspace metadata to teammate runtime bootstrap config", async () => {
+		const { DefaultRuntimeBuilder } = await import("./runtime-builder");
+		bootstrapAgentTeamsMock.mockClear();
+
+		new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "cline",
+				modelId: "anthropic/claude-sonnet-4.6",
+				apiKey: "key",
+				systemPrompt: `Base instructions.
+
+# Workspace Configuration
+{
+  "workspaces": {
+    "/repo/demo": {
+      "hint": "demo",
+      "latestGitBranchName": "main"
+    }
+  }
+}`,
+				cwd: "/repo/demo",
+				enableTools: false,
+				enableSpawnAgent: false,
+				enableAgentTeams: true,
+			},
+		});
+
+		expect(bootstrapAgentTeamsMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				teammateConfigProvider: expect.objectContaining({
+					getRuntimeConfig: expect.any(Function),
+				}),
+			}),
+		);
+		const clineBootstrapCall = (
+			bootstrapAgentTeamsMock.mock.calls as unknown as Array<
+				[Record<string, any>]
+			>
+		)[0]?.[0];
+		expect(clineBootstrapCall).toBeDefined();
+		expect(
+			clineBootstrapCall?.teammateConfigProvider.getRuntimeConfig(),
+		).toEqual(
+			expect.objectContaining({
+				providerId: "cline",
+				cwd: "/repo/demo",
+				clineWorkspaceMetadata: expect.stringContaining(
+					"# Workspace Configuration",
+				),
+			}),
+		);
+	});
+});

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

@@ -0,0 +1,371 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { Tool } from "@clinebot/agents";
+import { describe, expect, it } from "vitest";
+import { TelemetryService } from "../telemetry/TelemetryService";
+import { DefaultRuntimeBuilder } from "./runtime-builder";
+
+function makeSpawnTool(): Tool {
+	return {
+		name: "spawn_agent",
+		description: "Spawn a subagent",
+		inputSchema: { type: "object", properties: {}, required: [] },
+		execute: async () => ({ ok: true }),
+	};
+}
+
+describe("DefaultRuntimeBuilder", () => {
+	it("includes builtin tools when enabled", () => {
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				enableTools: true,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+			},
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names.length).toBeGreaterThan(0);
+		expect(names).not.toContain("spawn_agent");
+	});
+
+	it("forwards runtime logger for downstream agent creation", () => {
+		const logger = {
+			info: () => {},
+		};
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				enableTools: false,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+				logger,
+			},
+		});
+
+		expect(runtime.logger).toBe(logger);
+	});
+
+	it("forwards telemetry for downstream runtime consumers", () => {
+		const telemetry = new TelemetryService();
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				enableTools: false,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+				telemetry,
+			},
+		});
+
+		expect(runtime.telemetry).toBe(telemetry);
+	});
+
+	it("uses readonly preset in plan mode", () => {
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				mode: "plan",
+				enableTools: true,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+			},
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).not.toContain("editor");
+	});
+
+	it("uses apply_patch instead of editor for codex/gpt model IDs in act mode", () => {
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "openai",
+				modelId: "openai/gpt-5.4",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				mode: "act",
+				enableTools: true,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+			},
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).toContain("apply_patch");
+		expect(names).not.toContain("editor");
+	});
+
+	it("keeps editor for non-codex/non-gpt model IDs in act mode", () => {
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				mode: "act",
+				enableTools: true,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+			},
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).toContain("editor");
+		expect(names).not.toContain("apply_patch");
+	});
+
+	it("applies custom tool routing rules from session config", () => {
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				mode: "act",
+				enableTools: true,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+				toolRoutingRules: [
+					{
+						mode: "act",
+						providerIdIncludes: ["anthropic"],
+						modelIdIncludes: ["claude"],
+						enableTools: ["apply_patch"],
+						disableTools: ["editor"],
+					},
+				],
+			},
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).toContain("apply_patch");
+		expect(names).not.toContain("editor");
+	});
+
+	it("omits builtin tools when disabled", () => {
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				enableTools: false,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+			},
+		});
+
+		expect(runtime.tools).toEqual([]);
+	});
+
+	it("adds spawn tool when enabled", () => {
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				enableTools: false,
+				enableSpawnAgent: true,
+				enableAgentTeams: false,
+			},
+			createSpawnTool: makeSpawnTool,
+		});
+
+		expect(runtime.tools.map((tool) => tool.name)).toContain("spawn_agent");
+	});
+
+	it("provides a shutdown helper", () => {
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				enableTools: false,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+			},
+		});
+
+		expect(() => runtime.shutdown("test")).not.toThrow();
+	});
+
+	it("includes skills tool when workspace skills are available", () => {
+		const cwd = mkdtempSync(join(tmpdir(), "runtime-builder-skills-"));
+		const skillDir = join(cwd, ".cline", "skills", "commit");
+		mkdirSync(skillDir, { recursive: true });
+		writeFileSync(
+			join(skillDir, "SKILL.md"),
+			`---
+name: commit
+description: Create commit message
+---
+Use conventional commits.`,
+			"utf8",
+		);
+
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd,
+				enableTools: true,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+			},
+		});
+
+		expect(runtime.tools.map((tool) => tool.name)).toContain("skills");
+		runtime.shutdown("test");
+	});
+
+	it("marks configured but disabled skills in executor metadata", async () => {
+		const cwd = mkdtempSync(join(tmpdir(), "runtime-builder-skills-disabled-"));
+		const enabledDir = join(cwd, ".cline", "skills", "commit");
+		const disabledDir = join(cwd, ".cline", "skills", "review");
+		mkdirSync(enabledDir, { recursive: true });
+		mkdirSync(disabledDir, { recursive: true });
+		writeFileSync(
+			join(enabledDir, "SKILL.md"),
+			`---
+name: commit
+---
+Enabled skill.`,
+			"utf8",
+		);
+		writeFileSync(
+			join(disabledDir, "SKILL.md"),
+			`---
+name: review
+disabled: true
+---
+Disabled skill.`,
+			"utf8",
+		);
+
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd,
+				enableTools: true,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+			},
+		});
+
+		const skillsTool = runtime.tools.find((tool) => tool.name === "skills");
+		expect(skillsTool).toBeDefined();
+		if (!skillsTool) {
+			throw new Error("Expected skills tool.");
+		}
+
+		const disabledResult = await skillsTool.execute(
+			{ skill: "review" },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+		expect(disabledResult).toContain("configured but disabled");
+
+		runtime.shutdown("test");
+	});
+
+	it("scopes skills tool to session-configured skills", async () => {
+		const cwd = mkdtempSync(join(tmpdir(), "runtime-builder-skills-scoped-"));
+		const commitDir = join(cwd, ".cline", "skills", "commit");
+		const reviewDir = join(cwd, ".cline", "skills", "review");
+		mkdirSync(commitDir, { recursive: true });
+		mkdirSync(reviewDir, { recursive: true });
+		writeFileSync(
+			join(commitDir, "SKILL.md"),
+			`---
+name: commit
+---
+Commit skill.`,
+			"utf8",
+		);
+		writeFileSync(
+			join(reviewDir, "SKILL.md"),
+			`---
+name: review
+---
+Review skill.`,
+			"utf8",
+		);
+
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd,
+				enableTools: true,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+				skills: ["commit"],
+			},
+		});
+
+		const skillsTool = runtime.tools.find((tool) => tool.name === "skills");
+		expect(skillsTool).toBeDefined();
+		if (!skillsTool) {
+			throw new Error("Expected skills tool.");
+		}
+
+		const known = await skillsTool.execute(
+			{ skill: "commit" },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+		expect(known).toContain("<command-name>commit</command-name>");
+
+		const blocked = await skillsTool.execute(
+			{ skill: "review" },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+		expect(blocked).toContain('Skill "review" not found.');
+		expect(blocked).toContain("Available skills: commit");
+
+		runtime.shutdown("test");
+	});
+});