@clinebot/core 0.0.35 → 0.0.37

package/src/auth/server.test.ts

@@ -1,287 +0,0 @@
-import http from "node:http";
-import net from "node:net";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { startLocalOAuthServer } from "./server";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Bind to port 0 to let the OS pick a free port, then release it. */
-function getFreePort(): Promise<number> {
-	return new Promise((resolve, reject) => {
-		const srv = net.createServer();
-		srv.listen(0, "127.0.0.1", () => {
-			const addr = srv.address() as net.AddressInfo;
-			srv.close(() => resolve(addr.port));
-		});
-		srv.on("error", reject);
-	});
-}
-
-/** Occupy a port so the OAuth server cannot bind to it. */
-function occupyPort(port: number): Promise<http.Server> {
-	return new Promise((resolve, reject) => {
-		const srv = http.createServer();
-		srv.listen(port, "127.0.0.1", () => resolve(srv));
-		srv.on("error", reject);
-	});
-}
-
-/** Close an http.Server, resolving when the socket is gone. */
-function closeServer(srv: http.Server): Promise<void> {
-	return new Promise((resolve, reject) =>
-		srv.close((err) => (err ? reject(err) : resolve())),
-	);
-}
-
-/** Make a GET request and return status + body. */
-function get(url: string): Promise<{ status: number; body: string }> {
-	return new Promise((resolve, reject) => {
-		http
-			.get(url, (res) => {
-				let body = "";
-				res.on("data", (chunk: Buffer) => {
-					body += chunk.toString();
-				});
-				res.on("end", () => resolve({ status: res.statusCode ?? 0, body }));
-			})
-			.on("error", reject);
-	});
-}
-
-/** Flush microtasks + a short macro-task delay for fire-and-forget promises. */
-function flushAsync(): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, 20));
-}
-
-// ---------------------------------------------------------------------------
-// onListening
-// ---------------------------------------------------------------------------
-
-describe("auth/server startLocalOAuthServer — onListening", () => {
-	it("is called with host, port, and callbackUrl when the server binds", async () => {
-		const port = await getFreePort();
-		const onListening = vi.fn();
-
-		const server = await startLocalOAuthServer({
-			ports: [port],
-			callbackPath: "/callback",
-			onListening,
-		});
-
-		expect(onListening).toHaveBeenCalledOnce();
-		expect(onListening).toHaveBeenCalledWith({
-			host: "127.0.0.1",
-			port,
-			callbackUrl: `http://127.0.0.1:${port}/callback`,
-		});
-
-		server.close();
-	});
-
-	it("is not called when no port can be bound", async () => {
-		const port = await getFreePort();
-		const blocker = await occupyPort(port);
-		const onListening = vi.fn();
-
-		await startLocalOAuthServer({
-			ports: [port],
-			callbackPath: "/callback",
-			onListening,
-		});
-
-		expect(onListening).not.toHaveBeenCalled();
-
-		await closeServer(blocker);
-	});
-
-	it("fires for the first available port and skips occupied ones", async () => {
-		const [port1, port2] = await Promise.all([getFreePort(), getFreePort()]);
-		const blocker = await occupyPort(port1);
-		const onListening = vi.fn();
-
-		const server = await startLocalOAuthServer({
-			ports: [port1, port2],
-			callbackPath: "/cb",
-			onListening,
-		});
-
-		expect(onListening).toHaveBeenCalledOnce();
-		expect(onListening).toHaveBeenCalledWith(
-			expect.objectContaining({ port: port2 }),
-		);
-
-		server.close();
-		await closeServer(blocker);
-	});
-
-	it("swallows errors thrown by the onListening callback", async () => {
-		const port = await getFreePort();
-		const onListening = vi
-			.fn()
-			.mockReturnValue(Promise.reject(new Error("listening boom")));
-
-		const server = await startLocalOAuthServer({
-			ports: [port],
-			callbackPath: "/callback",
-			onListening,
-		});
-
-		await flushAsync();
-		expect(onListening).toHaveBeenCalledOnce();
-
-		server.close();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// onClose
-// ---------------------------------------------------------------------------
-
-describe("auth/server startLocalOAuthServer — onClose", () => {
-	it("is called with host and port when close() is invoked", async () => {
-		const port = await getFreePort();
-		const onClose = vi.fn();
-
-		const server = await startLocalOAuthServer({
-			ports: [port],
-			callbackPath: "/callback",
-			onClose,
-		});
-
-		server.close();
-
-		expect(onClose).toHaveBeenCalledOnce();
-		expect(onClose).toHaveBeenCalledWith({ host: "127.0.0.1", port });
-	});
-
-	it("is called with host and port when cancelWait() is invoked", async () => {
-		const port = await getFreePort();
-		const onClose = vi.fn();
-
-		const server = await startLocalOAuthServer({
-			ports: [port],
-			callbackPath: "/callback",
-			onClose,
-		});
-
-		server.cancelWait();
-
-		expect(onClose).toHaveBeenCalledOnce();
-		expect(onClose).toHaveBeenCalledWith({ host: "127.0.0.1", port });
-	});
-
-	it("is called after a successful OAuth callback request", async () => {
-		const port = await getFreePort();
-		const onClose = vi.fn();
-
-		const server = await startLocalOAuthServer({
-			ports: [port],
-			callbackPath: "/callback",
-			onClose,
-		});
-
-		const waitPromise = server.waitForCallback();
-		const { status } = await get(
-			`http://127.0.0.1:${port}/callback?code=tok123`,
-		);
-		expect(status).toBe(200);
-
-		await waitPromise;
-
-		expect(onClose).toHaveBeenCalledOnce();
-		expect(onClose).toHaveBeenCalledWith({ host: "127.0.0.1", port });
-	});
-
-	it("is not called when no port was bound", async () => {
-		const port = await getFreePort();
-		const blocker = await occupyPort(port);
-		const onClose = vi.fn();
-
-		const server = await startLocalOAuthServer({
-			ports: [port],
-			callbackPath: "/callback",
-			onClose,
-		});
-
-		server.close();
-		expect(onClose).not.toHaveBeenCalled();
-
-		await closeServer(blocker);
-	});
-
-	it("swallows errors thrown by the onClose callback", async () => {
-		const port = await getFreePort();
-		const onClose = vi
-			.fn()
-			.mockReturnValue(Promise.reject(new Error("teardown failed")));
-
-		const server = await startLocalOAuthServer({
-			ports: [port],
-			callbackPath: "/callback",
-			onClose,
-		});
-
-		server.close();
-		await flushAsync();
-
-		expect(onClose).toHaveBeenCalledOnce();
-	});
-});
-
-// ---------------------------------------------------------------------------
-// onListening + onClose ordering
-// ---------------------------------------------------------------------------
-
-describe("auth/server startLocalOAuthServer — onListening + onClose together", () => {
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	it("fires onListening on bind then onClose after a successful callback", async () => {
-		const port = await getFreePort();
-		const order: string[] = [];
-
-		const server = await startLocalOAuthServer({
-			ports: [port],
-			callbackPath: "/cb",
-			onListening: vi.fn(() => {
-				order.push("listening");
-			}),
-			onClose: vi.fn(() => {
-				order.push("close");
-			}),
-		});
-
-		expect(order).toEqual(["listening"]);
-
-		const waitPromise = server.waitForCallback();
-		await get(`http://127.0.0.1:${port}/cb?code=mycode`);
-		const payload = await waitPromise;
-
-		expect(payload?.code).toBe("mycode");
-		expect(order).toEqual(["listening", "close"]);
-	});
-
-	it("fires onListening on bind then onClose after cancelWait()", async () => {
-		const port = await getFreePort();
-		const order: string[] = [];
-
-		const server = await startLocalOAuthServer({
-			ports: [port],
-			callbackPath: "/cb",
-			onListening: vi.fn(() => {
-				order.push("listening");
-			}),
-			onClose: vi.fn(() => {
-				order.push("close");
-			}),
-		});
-
-		expect(order).toEqual(["listening"]);
-
-		server.cancelWait();
-		expect(order).toEqual(["listening", "close"]);
-	});
-});

package/src/auth/utils.test.ts

@@ -1,128 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import {
-	decodeJwtPayload,
-	isCredentialLikelyExpired,
-	parseAuthorizationInput,
-	parseOAuthError,
-	resolveAuthorizationCodeInput,
-	resolveUrl,
-} from "./utils";
-
-function toBase64Url(value: string): string {
-	return Buffer.from(value, "utf8").toString("base64url");
-}
-
-function createJwt(payload: Record<string, unknown>): string {
-	return `${toBase64Url(JSON.stringify({ alg: "none", typ: "JWT" }))}.${toBase64Url(JSON.stringify(payload))}.sig`;
-}
-
-describe("auth/utils", () => {
-	it("parses auth input from full URL with provider", () => {
-		const parsed = parseAuthorizationInput(
-			"http://localhost/callback?code=test-code&state=s1&provider=google",
-			{
-				includeProvider: true,
-			},
-		);
-		expect(parsed).toEqual({
-			code: "test-code",
-			state: "s1",
-			provider: "google",
-		});
-	});
-
-	it("parses auth input from hash format when enabled", () => {
-		const parsed = parseAuthorizationInput("abc123#state1", {
-			allowHashCodeState: true,
-		});
-		expect(parsed).toEqual({ code: "abc123", state: "state1" });
-	});
-
-	it("builds resolved URLs from base + path", () => {
-		expect(resolveUrl("https://example.com/", "/token")).toBe(
-			"https://example.com/token",
-		);
-	});
-
-	it("decodes JWT payload", () => {
-		const token = createJwt({ sub: "account-1", exp: 123 });
-		expect(decodeJwtPayload(token)).toMatchObject({
-			sub: "account-1",
-			exp: 123,
-		});
-		expect(decodeJwtPayload("invalid")).toBeNull();
-	});
-
-	it("parses OAuth error payloads from string and object forms", () => {
-		expect(
-			parseOAuthError(
-				JSON.stringify({
-					error: "invalid_grant",
-					error_description: "expired",
-				}),
-			),
-		).toEqual({
-			code: "invalid_grant",
-			message: "expired",
-		});
-		expect(
-			parseOAuthError(
-				JSON.stringify({ error: { type: "unauthorized", message: "denied" } }),
-			),
-		).toEqual({
-			code: "unauthorized",
-			message: "denied",
-		});
-	});
-
-	it("resolves code from callback result", async () => {
-		const result = await resolveAuthorizationCodeInput({
-			waitForCallback: async () => ({
-				url: new URL("http://localhost"),
-				code: "from-callback",
-				state: "s1",
-			}),
-			cancelWait: () => {},
-		});
-		expect(result).toEqual({
-			code: "from-callback",
-			state: "s1",
-			provider: undefined,
-			error: undefined,
-		});
-	});
-
-	it("resolves code from manual input when callback does not provide one", async () => {
-		const cancelWait = vi.fn();
-		const result = await resolveAuthorizationCodeInput({
-			waitForCallback: async () => null,
-			cancelWait,
-			onManualCodeInput: async () => "code=manual&state=manual-state",
-		});
-		expect(cancelWait).toHaveBeenCalled();
-		expect(result).toEqual({
-			code: "manual",
-			state: "manual-state",
-			provider: undefined,
-		});
-	});
-
-	it("throws when manual input rejects", async () => {
-		await expect(
-			resolveAuthorizationCodeInput({
-				waitForCallback: async () => null,
-				cancelWait: () => {},
-				onManualCodeInput: async () => {
-					throw new Error("cancelled");
-				},
-			}),
-		).rejects.toThrow("cancelled");
-	});
-
-	it("checks token expiry with configurable buffer", () => {
-		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(1_000);
-		expect(isCredentialLikelyExpired({ expires: 1_500 }, 600)).toBe(true);
-		expect(isCredentialLikelyExpired({ expires: 3_000 }, 600)).toBe(false);
-		nowSpy.mockRestore();
-	});
-});

package/src/extensions/config/agent-config-loader.test.ts

@@ -1,236 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { Tool, ToolContext } from "@clinebot/shared";
-import { resolveDocumentsExtensionPath } from "@clinebot/shared/storage";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-	AGENT_CONFIG_DIRECTORY_NAME,
-	createAgentConfigDefinition,
-	parseAgentConfigFromYaml,
-	parsePartialAgentConfigFromYaml,
-	readAgentConfigsFromDisk,
-	resolveAgentConfigSearchPaths,
-	resolveAgentsConfigDirPath,
-	resolveAgentTools,
-	toPartialAgentConfig,
-} from "./agent-config-loader";
-
-function createMockTool(name: string): Tool {
-	return {
-		name,
-		description: `${name} tool`,
-		inputSchema: {
-			type: "object",
-			properties: {},
-		},
-		execute: async (_input: unknown, _context: ToolContext) => null,
-	};
-}
-
-describe("agent config YAML loader", () => {
-	const envSnapshot = {
-		CLINE_DATA_DIR: process.env.CLINE_DATA_DIR,
-	};
-	afterEach(() => {
-		process.env.CLINE_DATA_DIR = envSnapshot.CLINE_DATA_DIR;
-	});
-
-	it("resolves default agents settings directory from CLINE_DATA_DIR", () => {
-		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
-		expect(resolveAgentsConfigDirPath()).toBe(
-			join("/tmp/cline-data", "settings", AGENT_CONFIG_DIRECTORY_NAME),
-		);
-	});
-
-	it("includes documents and settings search paths", () => {
-		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
-		expect(resolveAgentConfigSearchPaths()).toEqual([
-			resolveDocumentsExtensionPath("Agents"),
-			join("/tmp/cline-data", "settings", AGENT_CONFIG_DIRECTORY_NAME),
-		]);
-	});
-
-	it("builds a reusable unified watcher definition with expected defaults", () => {
-		process.env.CLINE_DATA_DIR = "/tmp/cline-data";
-		const definition = createAgentConfigDefinition();
-		expect(definition.type).toBe("agent");
-		expect(definition.directories).toEqual([
-			resolveDocumentsExtensionPath("Agents"),
-			join("/tmp/cline-data", "settings", AGENT_CONFIG_DIRECTORY_NAME),
-		]);
-		expect(definition.includeFile?.("agent.yaml", "/tmp/agent.yaml")).toBe(
-			true,
-		);
-		expect(definition.includeFile?.("agent.md", "/tmp/agent.md")).toBe(false);
-	});
-
-	it("parses yaml frontmatter and prompt body", () => {
-		const content = `---
-name: Researcher
-description: Focus on repository analysis
-modelId: claude-sonnet-4-6
-tools:
-  - read_files
-  - search_codebase
-skills:
-  - context-gathering
----
-You are a focused codebase researcher.`;
-
-		const parsed = parseAgentConfigFromYaml(content);
-
-		expect(parsed).toEqual({
-			name: "Researcher",
-			description: "Focus on repository analysis",
-			modelId: "claude-sonnet-4-6",
-			tools: ["read_files", "search_codebase"],
-			skills: ["context-gathering"],
-			systemPrompt: "You are a focused codebase researcher.",
-		});
-	});
-
-	it("supports comma-separated tool and skill values", () => {
-		const parsed = parseAgentConfigFromYaml(`---
-name: Reviewer
-description: Reviews diffs
-tools: read_files,search_codebase,read_files
-skills: quality, quality,architecture
----
-Review every patch for regressions.`);
-
-		expect(parsed.tools).toEqual(["read_files", "search_codebase"]);
-		expect(parsed.skills).toEqual(["quality", "architecture"]);
-	});
-
-	it("throws when frontmatter is missing", () => {
-		expect(() => parseAgentConfigFromYaml("No frontmatter")).toThrow(
-			"Missing YAML frontmatter block in agent config file.",
-		);
-	});
-
-	it("throws for unknown tools", () => {
-		expect(() =>
-			parseAgentConfigFromYaml(`---
-name: UnknownTool
-description: test
-tools: invalid_tool
----
-prompt`),
-		).toThrow("Unknown tool 'invalid_tool'.");
-	});
-
-	it("resolves configured tool names from available tools", () => {
-		const readFiles = createMockTool("read_files");
-		const searchCodebase = createMockTool("search_codebase");
-
-		expect(
-			resolveAgentTools(
-				["read_files", "search_codebase"],
-				[searchCodebase, readFiles],
-			),
-		).toEqual([readFiles, searchCodebase]);
-	});
-
-	it("converts parsed config to partial AgentConfig", () => {
-		const readFiles = createMockTool("read_files");
-		const config = parseAgentConfigFromYaml(`---
-name: Reader
-description: Reads files
-modelId: claude-sonnet-4-6
-tools: read_files
-skills: commit, review
----
-Be precise.`);
-
-		const partial = toPartialAgentConfig(config, {
-			availableTools: [readFiles],
-		});
-
-		expect(partial.modelId).toBe("claude-sonnet-4-6");
-		expect(partial.systemPrompt).toBe("Be precise.");
-		expect(partial.tools).toEqual([readFiles]);
-		expect(partial.skills).toEqual(["commit", "review"]);
-	});
-
-	it("throws when tool overrides are configured without available tools", () => {
-		expect(() =>
-			parsePartialAgentConfigFromYaml(`---
-name: Reader
-description: Reads files
-tools: read_files
----
-Be precise.`),
-		).toThrow(
-			"Configured tools cannot be converted into AgentConfig.tools without availableTools.",
-		);
-	});
-
-	it("reads agent configs from ~/.cline/data/settings/agents-compatible directory", async () => {
-		const tempRoot = await mkdtemp(join(tmpdir(), "core-agent-config-loader-"));
-		const agentsDir = join(tempRoot, "settings", AGENT_CONFIG_DIRECTORY_NAME);
-		await mkdir(agentsDir, { recursive: true });
-		try {
-			await writeFile(
-				join(agentsDir, "reviewer.yaml"),
-				`---
-name: Reviewer
-description: Reviews patches
-tools: read_files
----
-Review code for regressions.`,
-			);
-			await writeFile(
-				join(agentsDir, "invalid.yaml"),
-				`---
-name:
----
-`,
-			);
-
-			const loaded = await readAgentConfigsFromDisk(agentsDir);
-			expect([...loaded.keys()]).toEqual(["reviewer"]);
-			expect(loaded.get("reviewer")?.systemPrompt).toBe(
-				"Review code for regressions.",
-			);
-		} finally {
-			await rm(tempRoot, { recursive: true, force: true });
-		}
-	});
-
-	it("reads from both documents and settings directories", async () => {
-		const tempRoot = await mkdtemp(join(tmpdir(), "core-agent-config-loader-"));
-		const documentsDir = join(tempRoot, "Documents", "Cline", "Agents");
-		const settingsDir = join(tempRoot, "settings", AGENT_CONFIG_DIRECTORY_NAME);
-		await mkdir(documentsDir, { recursive: true });
-		await mkdir(settingsDir, { recursive: true });
-		try {
-			await writeFile(
-				join(documentsDir, "legacy.yaml"),
-				`---
-name: LegacyAgent
-description: legacy
----
-legacy prompt`,
-			);
-			await writeFile(
-				join(settingsDir, "new.yaml"),
-				`---
-name: NewAgent
-description: new
----
-new prompt`,
-			);
-
-			const loaded = await readAgentConfigsFromDisk([
-				documentsDir,
-				settingsDir,
-			]);
-			expect([...loaded.keys()].sort()).toEqual(["legacyagent", "newagent"]);
-			expect(loaded.get("legacyagent")?.systemPrompt).toBe("legacy prompt");
-			expect(loaded.get("newagent")?.systemPrompt).toBe("new prompt");
-		} finally {
-			await rm(tempRoot, { recursive: true, force: true });
-		}
-	});
-});

package/src/extensions/config/hooks-config-loader.test.ts

@@ -1,20 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import {
-	HookConfigFileName,
-	toHookConfigFileName,
-} from "./hooks-config-loader";
-
-describe("hooks config loader", () => {
-	afterEach(() => {
-		delete process.env.CLINE_DATA_DIR;
-	});
-
-	it("recognizes PowerShell hook files", () => {
-		expect(toHookConfigFileName("PreToolUse.ps1")).toBe(
-			HookConfigFileName.PreToolUse,
-		);
-		expect(toHookConfigFileName("TaskError.ps1")).toBe(
-			HookConfigFileName.TaskError,
-		);
-	});
-});