@clinebot/core 0.0.34 → 0.0.36

package/src/runtime/checkpoint-hooks.test.ts

@@ -1,168 +0,0 @@
-import { execFile as execFileCallback } from "node:child_process";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { promisify } from "node:util";
-import { describe, expect, it } from "vitest";
-import {
-	type CheckpointEntry,
-	type CheckpointMetadata,
-	createCheckpointHooks,
-} from "./checkpoint-hooks";
-
-const execFile = promisify(execFileCallback);
-
-async function runGit(cwd: string, ...args: string[]): Promise<string> {
-	const result = await execFile("git", ["-C", cwd, ...args], {
-		windowsHide: true,
-	});
-	return result.stdout.trim();
-}
-
-async function createGitRepo(): Promise<string> {
-	const cwd = await mkdtemp(join(tmpdir(), "core-checkpoint-"));
-	await runGit(cwd, "init");
-	await runGit(cwd, "config", "user.name", "Codex Test");
-	await runGit(cwd, "config", "user.email", "codex@example.com");
-	await writeFile(join(cwd, "note.txt"), "base\n", "utf8");
-	await runGit(cwd, "add", "note.txt");
-	await runGit(cwd, "commit", "-m", "initial");
-	return cwd;
-}
-
-// Currently disabled for process?.env?.CLINE_CHECKPOINT
-describe.skip("createCheckpointHooks", () => {
-	it("creates one checkpoint at the start of each root run and appends metadata", async () => {
-		const cwd = await createGitRepo();
-		let metadata: Record<string, unknown> | undefined;
-		try {
-			const hooks = createCheckpointHooks({
-				cwd,
-				sessionId: "sess_1",
-				readSessionMetadata: async () => metadata,
-				writeSessionMetadata: async (next) => {
-					metadata = next;
-				},
-			});
-
-			await writeFile(join(cwd, "note.txt"), "run-one\n", "utf8");
-			await hooks.onRunStart?.({
-				agentId: "agent_1",
-				conversationId: "conv_1",
-				parentAgentId: null,
-				userMessage: "first",
-			});
-			await hooks.onBeforeAgentStart?.({
-				agentId: "agent_1",
-				conversationId: "conv_1",
-				parentAgentId: null,
-				iteration: 1,
-				systemPrompt: "system",
-				messages: [],
-			});
-
-			const first = metadata?.checkpoint as CheckpointMetadata;
-			expect(first.history).toHaveLength(1);
-			expect(first.latest.runCount).toBe(1);
-			expect(first.latest.ref).toMatch(/^[0-9a-f]{40}$/);
-
-			await writeFile(join(cwd, "note.txt"), "run-two\n", "utf8");
-			await hooks.onRunStart?.({
-				agentId: "agent_1",
-				conversationId: "conv_1",
-				parentAgentId: null,
-				userMessage: "second",
-			});
-			await hooks.onBeforeAgentStart?.({
-				agentId: "agent_1",
-				conversationId: "conv_1",
-				parentAgentId: null,
-				iteration: 1,
-				systemPrompt: "system",
-				messages: [],
-			});
-
-			const checkpoint = metadata?.checkpoint as CheckpointMetadata;
-			expect(checkpoint.latest.runCount).toBe(2);
-			expect(checkpoint.history).toHaveLength(2);
-			expect(
-				checkpoint.history.map((entry: CheckpointEntry) => entry.runCount),
-			).toEqual([1, 2]);
-			expect(checkpoint.latest.kind).toBe("stash");
-		} finally {
-			await rm(cwd, { recursive: true, force: true });
-		}
-	});
-
-	it("falls back to a commit checkpoint when the worktree is clean", async () => {
-		const cwd = await createGitRepo();
-		let metadata: Record<string, unknown> | undefined;
-		try {
-			const hooks = createCheckpointHooks({
-				cwd,
-				sessionId: "sess_clean",
-				readSessionMetadata: async () => metadata,
-				writeSessionMetadata: async (next) => {
-					metadata = next;
-				},
-			});
-
-			await hooks.onRunStart?.({
-				agentId: "agent_1",
-				conversationId: "conv_1",
-				parentAgentId: null,
-				userMessage: "clean",
-			});
-			await hooks.onBeforeAgentStart?.({
-				agentId: "agent_1",
-				conversationId: "conv_1",
-				parentAgentId: null,
-				iteration: 1,
-				systemPrompt: "system",
-				messages: [],
-			});
-
-			const checkpoint = metadata?.checkpoint as CheckpointMetadata;
-			expect(checkpoint.history).toHaveLength(1);
-			expect(checkpoint.latest.kind).toBe("commit");
-			expect(checkpoint.latest.ref).toMatch(/^[0-9a-f]{40}$/);
-		} finally {
-			await rm(cwd, { recursive: true, force: true });
-		}
-	});
-
-	it("skips checkpoint creation for subagents", async () => {
-		const cwd = await createGitRepo();
-		let writes = 0;
-		try {
-			const hooks = createCheckpointHooks({
-				cwd,
-				sessionId: "sess_1",
-				readSessionMetadata: async () => undefined,
-				writeSessionMetadata: async () => {
-					writes += 1;
-				},
-			});
-
-			await writeFile(join(cwd, "note.txt"), "subagent-dirty\n", "utf8");
-			await hooks.onRunStart?.({
-				agentId: "agent_child",
-				conversationId: "conv_child",
-				parentAgentId: "agent_root",
-				userMessage: "child",
-			});
-			await hooks.onBeforeAgentStart?.({
-				agentId: "agent_child",
-				conversationId: "conv_child",
-				parentAgentId: "agent_root",
-				iteration: 1,
-				systemPrompt: "system",
-				messages: [],
-			});
-
-			expect(writes).toBe(0);
-		} finally {
-			await rm(cwd, { recursive: true, force: true });
-		}
-	});
-});

package/src/runtime/hook-file-hooks.test.ts

@@ -1,311 +0,0 @@
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-import { createHookConfigFileHooks, mergeAgentHooks } from "./hook-file-hooks";
-
-async function waitForFile(
-	filePath: string,
-	timeoutMs = 1500,
-): Promise<string> {
-	const started = Date.now();
-	for (;;) {
-		try {
-			return await readFile(filePath, "utf8");
-		} catch (error) {
-			const code =
-				error && typeof error === "object" && "code" in error
-					? String((error as { code?: unknown }).code)
-					: undefined;
-			if (code !== "ENOENT" || Date.now() - started >= timeoutMs) {
-				throw error;
-			}
-			await new Promise((resolve) => setTimeout(resolve, 25));
-		}
-	}
-}
-
-async function createWorkspaceWithHook(
-	fileName: string,
-	body: string,
-): Promise<{ workspace: string; hookPath: string }> {
-	const workspace = await mkdtemp(join(tmpdir(), "hooks-workspace-"));
-	const hooksDir = join(workspace, ".clinerules", "hooks");
-	await mkdir(hooksDir, { recursive: true });
-	const hookPath = join(hooksDir, fileName);
-	await writeFile(hookPath, body, "utf8");
-	return { workspace, hookPath };
-}
-
-describe("createHookConfigFileHooks", () => {
-	it("ignores example hook files", async () => {
-		const { workspace } = await createWorkspaceWithHook(
-			"PreToolUse.example",
-			'echo \'HOOK_CONTROL\t{"cancel":true,"context":"should-not-run"}\'\n',
-		);
-		try {
-			const hooks = createHookConfigFileHooks({
-				cwd: workspace,
-				workspacePath: workspace,
-			});
-			expect(hooks).toBeUndefined();
-		} finally {
-			await rm(workspace, {
-				recursive: true,
-				force: true,
-				maxRetries: 3,
-				retryDelay: 250,
-			});
-		}
-	});
-
-	it("executes extensionless legacy hook files via bash fallback", async () => {
-		const { workspace } = await createWorkspaceWithHook(
-			"PreToolUse",
-			'echo \'HOOK_CONTROL\t{"cancel":true,"context":"legacy-ok"}\'\nexit 0\n',
-		);
-		try {
-			const hooks = createHookConfigFileHooks({
-				cwd: workspace,
-				workspacePath: workspace,
-			});
-			expect(hooks?.onToolCallStart).toBeTypeOf("function");
-			const control = await hooks?.onToolCallStart?.({
-				agentId: "agent_1",
-				conversationId: "conv_1",
-				parentAgentId: null,
-				iteration: 1,
-				call: {
-					id: "call_1",
-					name: "read_file",
-					input: { path: "README.md" },
-				},
-			});
-			expect(control).toMatchObject({ cancel: true, context: "legacy-ok" });
-		} finally {
-			await rm(workspace, {
-				recursive: true,
-				force: true,
-				maxRetries: 3,
-				retryDelay: 250,
-			});
-		}
-	});
-
-	it("honors shebang interpreter when present", async () => {
-		const { workspace } = await createWorkspaceWithHook(
-			"PreToolUse",
-			'#!/usr/bin/env bash\necho \'HOOK_CONTROL\t{"cancel":false,"context":"shebang-ok"}\'\n',
-		);
-		try {
-			const hooks = createHookConfigFileHooks({
-				cwd: workspace,
-				workspacePath: workspace,
-			});
-			expect(hooks?.onToolCallStart).toBeTypeOf("function");
-			const control = await hooks?.onToolCallStart?.({
-				agentId: "agent_1",
-				conversationId: "conv_1",
-				parentAgentId: null,
-				iteration: 1,
-				call: {
-					id: "call_1",
-					name: "read_file",
-					input: { path: "README.md" },
-				},
-			});
-			expect(control).toMatchObject({ cancel: false, context: "shebang-ok" });
-		} finally {
-			await rm(workspace, {
-				recursive: true,
-				force: true,
-				maxRetries: 3,
-				retryDelay: 250,
-			});
-		}
-	});
-
-	it("parses review control from hook output", async () => {
-		const { workspace } = await createWorkspaceWithHook(
-			"PreToolUse.ts",
-			'console.log(\'HOOK_CONTROL\\t{"review":true,"context":"needs-review"}\')\n',
-		);
-		try {
-			const hooks = createHookConfigFileHooks({
-				cwd: workspace,
-				workspacePath: workspace,
-			});
-			expect(hooks?.onToolCallStart).toBeTypeOf("function");
-			const control = await hooks?.onToolCallStart?.({
-				agentId: "agent_1",
-				conversationId: "conv_1",
-				parentAgentId: null,
-				iteration: 1,
-				call: {
-					id: "call_1",
-					name: "run_commands",
-					input: { commands: ["git status"] },
-				},
-			});
-			expect(control).toMatchObject({
-				review: true,
-				context: "needs-review",
-			});
-		} finally {
-			await rm(workspace, {
-				recursive: true,
-				force: true,
-				maxRetries: 3,
-				retryDelay: 250,
-			});
-		}
-	});
-
-	it("executes python hook files", async () => {
-		const { workspace } = await createWorkspaceWithHook(
-			"PreToolUse.py",
-			'print(\'HOOK_CONTROL\\t{"cancel": false, "context": "python-ok"}\')\n',
-		);
-		try {
-			const hooks = createHookConfigFileHooks({
-				cwd: workspace,
-				workspacePath: workspace,
-			});
-			expect(hooks?.onToolCallStart).toBeTypeOf("function");
-			const control = await hooks?.onToolCallStart?.({
-				agentId: "agent_1",
-				conversationId: "conv_1",
-				parentAgentId: null,
-				iteration: 1,
-				call: {
-					id: "call_1",
-					name: "read_file",
-					input: { path: "README.md" },
-				},
-			});
-			expect(control).toMatchObject({
-				cancel: false,
-				context: "python-ok",
-			});
-		} finally {
-			await rm(workspace, {
-				recursive: true,
-				force: true,
-				maxRetries: 3,
-				retryDelay: 250,
-			});
-		}
-	});
-
-	it.runIf(process.platform === "win32")(
-		"executes PowerShell hook files on Windows",
-		async () => {
-			const { workspace } = await createWorkspaceWithHook(
-				"PreToolUse.ps1",
-				'Write-Output \'HOOK_CONTROL\t{"cancel": false, "context": "powershell-ok"}\'\n',
-			);
-			try {
-				const hooks = createHookConfigFileHooks({
-					cwd: workspace,
-					workspacePath: workspace,
-				});
-				expect(hooks?.onToolCallStart).toBeTypeOf("function");
-				const control = await hooks?.onToolCallStart?.({
-					agentId: "agent_1",
-					conversationId: "conv_1",
-					parentAgentId: null,
-					iteration: 1,
-					call: {
-						id: "call_1",
-						name: "read_file",
-						input: { path: "README.md" },
-					},
-				});
-				expect(control).toMatchObject({
-					cancel: false,
-					context: "powershell-ok",
-				});
-			} finally {
-				await rm(workspace, {
-					recursive: true,
-					force: true,
-					maxRetries: 3,
-					retryDelay: 250,
-				});
-			}
-		},
-	);
-
-	it("maps TaskError hook files to agent_error stop events", async () => {
-		const outputPath = join(tmpdir(), `hooks-task-error-${Date.now()}.json`);
-		const { workspace } = await createWorkspaceWithHook(
-			"TaskError.js",
-			`let data='';process.stdin.on('data',c=>data+=c);process.stdin.on('end',()=>{require('node:fs').writeFileSync(${JSON.stringify(outputPath)}, data);});\n`,
-		);
-		try {
-			const hooks = createHookConfigFileHooks({
-				cwd: workspace,
-				workspacePath: workspace,
-			});
-			await hooks?.onStopError?.({
-				agentId: "agent_1",
-				conversationId: "conv_1",
-				parentAgentId: null,
-				iteration: 3,
-				error: new Error("401 unauthorized"),
-			});
-			const payload = JSON.parse(await waitForFile(outputPath)) as {
-				hookName: string;
-				error?: { message?: string };
-			};
-			expect(payload.hookName).toBe("agent_error");
-			expect(payload.error?.message).toBe("401 unauthorized");
-		} finally {
-			await rm(workspace, {
-				recursive: true,
-				force: true,
-				maxRetries: 3,
-				retryDelay: 250,
-			});
-		}
-	});
-
-	it("merges before-agent-start controls across hook layers", async () => {
-		const hooks = mergeAgentHooks([
-			{
-				onBeforeAgentStart: async () => ({
-					systemPrompt: "system-a",
-				}),
-			},
-			{
-				onBeforeAgentStart: async () => ({
-					appendMessages: [
-						{
-							role: "user",
-							content: [{ type: "text", text: "ctx-a" }],
-						},
-					],
-				}),
-			},
-		]);
-
-		const control = await hooks?.onBeforeAgentStart?.({
-			agentId: "agent_1",
-			conversationId: "conv_1",
-			parentAgentId: null,
-			iteration: 1,
-			systemPrompt: "base",
-			messages: [],
-		});
-
-		expect(control).toMatchObject({
-			systemPrompt: "system-a",
-			appendMessages: [
-				{
-					role: "user",
-					content: [{ type: "text", text: "ctx-a" }],
-				},
-			],
-		});
-	});
-});

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

@@ -1,242 +0,0 @@
-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("../team", () => ({
-	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();
-
-		await 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();
-
-		await 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",
-			}),
-		);
-	});
-});