@clinebot/core 0.0.6 → 0.0.7

package/src/storage/provider-settings-legacy-migration.test.ts

@@ -2,7 +2,11 @@ import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
-import { migrateLegacyProviderSettings } from "./provider-settings-legacy-migration";
+import {
+	type LegacyClineUserInfo,
+	migrateLegacyProviderSettings,
+	resolveLegacyClineAuth,
+} from "./provider-settings-legacy-migration";
 import { ProviderSettingsManager } from "./provider-settings-manager";
 
 describe("migrateLegacyProviderSettings", () => {
@@ -173,3 +177,131 @@ describe("migrateLegacyProviderSettings", () => {
 		);
 	});
 });
+
+// =============================================================================
+// resolveLegacyClineAuth – pure in-memory tests
+// =============================================================================
+
+/** Builds a realistic LegacyClineUserInfo JSON string. */
+function makeClineAccountJson(
+	overrides: Partial<LegacyClineUserInfo> & { userId?: string } = {},
+): string {
+	return JSON.stringify({
+		idToken: overrides.idToken ?? "id-token-abc",
+		expiresAt: overrides.expiresAt ?? 1750000000000,
+		refreshToken: overrides.refreshToken ?? "refresh-token-xyz",
+		userInfo: overrides.userInfo ?? {
+			id: overrides.userId ?? "user-42",
+			email: "test@example.com",
+			displayName: "Test User",
+			termsAcceptedAt: "2025-01-01T00:00:00Z",
+			clineBenchConsent: false,
+			createdAt: "2025-01-01T00:00:00Z",
+			updatedAt: "2025-01-01T00:00:00Z",
+		},
+		provider: overrides.provider ?? "google",
+		startedAt: overrides.startedAt ?? Date.now(),
+	} satisfies LegacyClineUserInfo);
+}
+
+describe("resolveLegacyClineAuth", () => {
+	it("extracts all auth fields from a complete legacy account JSON", () => {
+		const result = resolveLegacyClineAuth(
+			makeClineAccountJson({
+				idToken: "my-id-token",
+				expiresAt: 1750000000000,
+				refreshToken: "my-refresh",
+				userId: "user-123",
+			}),
+		);
+
+		expect(result).toEqual({
+			accessToken: "my-id-token",
+			refreshToken: "my-refresh",
+			expiresAt: 1750000000000,
+			accountId: "user-123",
+		});
+	});
+
+	it("maps idToken to accessToken", () => {
+		const result = resolveLegacyClineAuth(
+			makeClineAccountJson({ idToken: "tok-abc" }),
+		);
+		expect(result?.accessToken).toBe("tok-abc");
+	});
+
+	it("preserves expiresAt as a number", () => {
+		const result = resolveLegacyClineAuth(
+			makeClineAccountJson({ expiresAt: 9999999999999 }),
+		);
+		expect(result?.expiresAt).toBe(9999999999999);
+		expect(typeof result?.expiresAt).toBe("number");
+	});
+
+	it("maps userInfo.id to accountId", () => {
+		const result = resolveLegacyClineAuth(
+			makeClineAccountJson({ userId: "uid-xyz" }),
+		);
+		expect(result?.accountId).toBe("uid-xyz");
+	});
+
+	it("returns undefined accountId when userInfo is missing entirely", () => {
+		const raw = JSON.stringify({
+			idToken: "tok",
+			expiresAt: 1000,
+			refreshToken: "ref",
+			provider: "google",
+			startedAt: 1,
+		});
+
+		const result = resolveLegacyClineAuth(raw);
+		expect(result).toBeDefined();
+		expect(result?.accessToken).toBe("tok");
+		expect(result?.accountId).toBeUndefined();
+	});
+
+	it("returns undefined accountId when userInfo.id is missing", () => {
+		const raw = JSON.stringify({
+			idToken: "tok",
+			expiresAt: 1000,
+			refreshToken: "ref",
+			userInfo: {
+				email: "x@y.com",
+				displayName: "X",
+				termsAcceptedAt: "2025-01-01T00:00:00Z",
+				clineBenchConsent: false,
+				createdAt: "2025-01-01T00:00:00Z",
+				updatedAt: "2025-01-01T00:00:00Z",
+			},
+			provider: "google",
+			startedAt: 1,
+		});
+
+		const result = resolveLegacyClineAuth(raw);
+		expect(result).toBeDefined();
+		expect(result?.accountId).toBeUndefined();
+	});
+
+	it("returns undefined for invalid json", () => {
+		expect(resolveLegacyClineAuth(undefined)).toBeUndefined();
+		expect(resolveLegacyClineAuth("")).toBeUndefined();
+		expect(resolveLegacyClineAuth("   \n\t  ")).toBeUndefined();
+		expect(resolveLegacyClineAuth("not-json{{{")).toBeUndefined();
+		expect(resolveLegacyClineAuth("null")).toBeUndefined();
+	});
+
+	it("returns undefined fields when idToken/refreshToken are missing from JSON", () => {
+		const raw = JSON.stringify({
+			userInfo: { id: "uid" },
+			provider: "google",
+			startedAt: 1,
+		});
+
+		const result = resolveLegacyClineAuth(raw);
+		expect(result).toBeDefined();
+		expect(result?.accessToken).toBeUndefined();
+		expect(result?.refreshToken).toBeUndefined();
+		expect(result?.expiresAt).toBeUndefined();
+		expect(result?.accountId).toBe("uid");
+	});
+});

package/src/storage/provider-settings-legacy-migration.ts

@@ -162,6 +162,53 @@ export interface MigrateLegacyProviderSettingsResult {
 	lastUsedProvider?: string;
 }
 
+export type LegacyClineUserInfo = {
+	idToken: string;
+	expiresAt: number;
+	refreshToken: string;
+	userInfo: {
+		id: string;
+		email: string;
+		displayName: string;
+		termsAcceptedAt: string;
+		clineBenchConsent: boolean;
+		createdAt: string;
+		updatedAt: string;
+	};
+	provider: string;
+	startedAt: number;
+};
+
+/**
+ * Resolves legacy Cline account auth data from the raw `cline:clineAccountId`
+ * secret string into the auth fields used by `ProviderSettings`.
+ *
+ * Returns `undefined` when the input is missing, empty, whitespace-only, or
+ * unparseable JSON.
+ */
+export function resolveLegacyClineAuth(
+	rawAccountData: string | undefined,
+): ProviderSettings["auth"] | undefined {
+	const trimmed = rawAccountData?.trim();
+	if (!trimmed) {
+		return undefined;
+	}
+	try {
+		const data = JSON.parse(trimmed) as LegacyClineUserInfo;
+		if (!data) {
+			return undefined;
+		}
+		return {
+			accessToken: data.idToken,
+			refreshToken: data.refreshToken,
+			expiresAt: data.expiresAt,
+			accountId: data.userInfo?.id,
+		};
+	} catch {
+		return undefined;
+	}
+}
+
 function trimNonEmpty(value: string | undefined): string | undefined {
 	const trimmed = value?.trim();
 	return trimmed ? trimmed : undefined;
@@ -400,14 +447,19 @@ function buildLegacyProviderSettings(
 		Object.assign(providerSpecific, resolveLegacyCodexAuth(legacySecrets));
 	}
 	if (providerId === "cline") {
-		const accountId = trimNonEmpty(
-			legacySecrets["cline:clineAccountId"] ?? legacySecrets.clineAccountId,
-		);
-		if (accountId) {
-			providerSpecific.auth = {
-				...(providerSpecific.auth ?? {}),
-				accountId,
-			};
+		try {
+			const legacyAuthString = trimNonEmpty(
+				legacySecrets["cline:clineAccountId"],
+			);
+
+			if (legacyAuthString) {
+				providerSpecific.auth = {
+					...(providerSpecific.auth ?? {}),
+					...resolveLegacyClineAuth(legacyAuthString),
+				};
+			}
+		} catch {
+			// Failed to parse stored cline auth data
 		}
 	}
 	if (providerId === "openai" && legacyGlobalState.openAiHeaders) {

package/src/tools/definitions.test.ts

@@ -261,7 +261,7 @@ describe("zod schema conversion", () => {
 });
 
 describe("default editor tool", () => {
-	it("accepts null for unused optional fields on str_replace", async () => {
+	it("accepts replacement edits without insert fields", async () => {
 		const execute = vi.fn(async () => "patched");
 		const tools = createDefaultTools({
 			executors: {
@@ -284,12 +284,9 @@ describe("default editor tool", () => {
 
 		const result = await editorTool.execute(
 			{
-				command: "str_replace",
 				path: "/tmp/example.ts",
-				old_str: "before",
-				new_str: "after",
-				file_text: null,
-				insert_line: null,
+				old_text: "before",
+				new_text: "after",
 			},
 			{
 				agentId: "agent-1",
@@ -299,18 +296,15 @@ describe("default editor tool", () => {
 		);
 
 		expect(result).toEqual({
-			query: "str_replace:/tmp/example.ts",
+			query: "edit:/tmp/example.ts",
 			result: "patched",
 			success: true,
 		});
 		expect(execute).toHaveBeenCalledWith(
 			expect.objectContaining({
-				command: "str_replace",
 				path: "/tmp/example.ts",
-				old_str: "before",
-				new_str: "after",
-				file_text: null,
-				insert_line: null,
+				old_text: "before",
+				new_text: "after",
 			}),
 			process.cwd(),
 			expect.objectContaining({
@@ -321,7 +315,7 @@ describe("default editor tool", () => {
 		);
 	});
 
-	it("still rejects null for required insert fields", async () => {
+	it("allows edit without old_text so missing files can be created", async () => {
 		const execute = vi.fn(async () => "patched");
 		const tools = createDefaultTools({
 			executors: {
@@ -342,21 +336,80 @@ describe("default editor tool", () => {
 			throw new Error("Expected editor tool to be defined.");
 		}
 
-		await expect(
-			editorTool.execute(
-				{
-					command: "insert",
-					path: "/tmp/example.ts",
-					new_str: "after",
-					insert_line: null,
-				},
-				{
-					agentId: "agent-1",
-					conversationId: "conv-1",
-					iteration: 1,
-				},
-			),
-		).rejects.toThrow(/insert_line is required for command=insert/);
-		expect(execute).not.toHaveBeenCalled();
+		const result = await editorTool.execute(
+			{
+				path: "/tmp/example.ts",
+				new_text: "created",
+			},
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual({
+			query: "edit:/tmp/example.ts",
+			result: "patched",
+			success: true,
+		});
+		expect(execute).toHaveBeenCalledWith(
+			expect.objectContaining({
+				path: "/tmp/example.ts",
+				new_text: "created",
+			}),
+			process.cwd(),
+			expect.anything(),
+		);
+	});
+
+	it("treats insert_line as an insert operation", async () => {
+		const execute = vi.fn(async () => "patched");
+		const tools = createDefaultTools({
+			executors: {
+				editor: execute,
+			},
+			enableReadFiles: false,
+			enableSearch: false,
+			enableBash: false,
+			enableWebFetch: false,
+			enableSkills: false,
+			enableAskQuestion: false,
+			enableApplyPatch: false,
+			enableEditor: true,
+		});
+		const editorTool = tools.find((tool) => tool.name === "editor");
+		expect(editorTool).toBeDefined();
+		if (!editorTool) {
+			throw new Error("Expected editor tool to be defined.");
+		}
+
+		const result = await editorTool.execute(
+			{
+				path: "/tmp/example.ts",
+				new_text: "after",
+				insert_line: 3,
+			},
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toEqual({
+			query: "insert:/tmp/example.ts",
+			result: "patched",
+			success: true,
+		});
+		expect(execute).toHaveBeenCalledWith(
+			expect.objectContaining({
+				path: "/tmp/example.ts",
+				new_text: "after",
+				insert_line: 3,
+			}),
+			process.cwd(),
+			expect.anything(),
+		);
 	});
 });

package/src/tools/definitions.ts

@@ -432,14 +432,16 @@ export function createEditorTool(
 	return createTool<EditFileInput, ToolOperationResult>({
 		name: "editor",
 		description:
-			"Edit file using absolute path with create, string replacement, and line insert operations. " +
-			"Supported commands: create, str_replace, insert.",
+			"An editor for controlled filesystem edits on the text file at the provided path. " +
+			"Provide `insert_line` to insert `new_text` at a specific line number. " +
+			"Otherwise, the tool replaces `old_text` with `new_text`, or creates the file with `new_text` if it does not exist.",
 		inputSchema: zodToJsonSchema(EditFileInputSchema),
 		timeoutMs,
 		retryable: false, // Editing operations are stateful and should not auto-retry
 		maxRetries: 0,
 		execute: async (input, context) => {
 			const validatedInput = validateWithZod(EditFileInputSchema, input);
+			const operation = validatedInput.insert_line == null ? "edit" : "insert";
 
 			try {
 				const result = await withTimeout(
@@ -449,14 +451,14 @@ export function createEditorTool(
 				);
 
 				return {
-					query: `${validatedInput.command}:${validatedInput.path}`,
+					query: `${operation}:${validatedInput.path}`,
 					result,
 					success: true,
 				};
 			} catch (error) {
 				const msg = formatError(error);
 				return {
-					query: `${validatedInput.command}:${validatedInput.path}`,
+					query: `${operation}:${validatedInput.path}`,
 					result: "",
 					error: `Editor operation failed: ${msg}`,
 					success: false,

package/src/tools/executors/editor.test.ts

@@ -0,0 +1,35 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createEditorExecutor } from "./editor.js";
+
+describe("createEditorExecutor", () => {
+	it("creates a missing file when edit is used", async () => {
+		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-editor-"));
+		const filePath = path.join(dir, "example.txt");
+
+		try {
+			const editor = createEditorExecutor();
+			const result = await editor(
+				{
+					path: filePath,
+					new_text: "created with edit",
+				},
+				dir,
+				{
+					agentId: "agent-1",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			);
+
+			expect(result).toBe(`File created successfully at: ${filePath}`);
+			await expect(fs.readFile(filePath, "utf-8")).resolves.toBe(
+				"created with edit",
+			);
+		} finally {
+			await fs.rm(dir, { recursive: true, force: true });
+		}
+	});
+});

package/src/tools/executors/editor.ts

@@ -113,6 +113,15 @@ async function createFile(
 	return `File created successfully at: ${filePath}`;
 }
 
+async function fileExists(filePath: string): Promise<boolean> {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
 async function replaceInFile(
 	filePath: string,
 	oldStr: string,
@@ -181,52 +190,30 @@ export function createEditorExecutor(
 	): Promise<string> => {
 		const filePath = resolveFilePath(cwd, input.path, restrictToCwd);
 
-		switch (input.command) {
-			case "create":
-				if (input.file_text == null) {
-					throw new Error(
-						"Parameter `file_text` is required for command: create",
-					);
-				}
-				return createFile(filePath, input.file_text, encoding);
-
-			case "str_replace":
-				if (input.old_str == null) {
-					throw new Error(
-						"Parameter `old_str` is required for command: str_replace",
-					);
-				}
-				return replaceInFile(
-					filePath,
-					input.old_str,
-					input.new_str,
-					encoding,
-					maxDiffLines,
-				);
-
-			case "insert":
-				if (input.insert_line == null) {
-					throw new Error(
-						"Parameter `insert_line` is required for insert command.",
-					);
-				}
-				if (input.new_str == null) {
-					throw new Error(
-						"Parameter `new_str` is required for insert command.",
-					);
-				}
-				return insertInFile(
-					filePath,
-					input.insert_line, // One-based index
-					input.new_str,
-					encoding,
-				);
-
-			default:
-				throw new Error(
-					`Unrecognized command ${(input as { command: string }).command}. ` +
-						"Allowed commands are: create, str_replace, insert",
-				);
+		if (input.insert_line != null) {
+			return insertInFile(
+				filePath,
+				input.insert_line, // One-based index
+				input.new_text,
+				encoding,
+			);
+		}
+
+		if (!(await fileExists(filePath))) {
+			return createFile(filePath, input.new_text, encoding);
+		}
+		if (input.old_text == null) {
+			throw new Error(
+				"Parameter `old_text` is required when editing an existing file without `insert_line`",
+			);
 		}
+
+		return replaceInFile(
+			filePath,
+			input.old_text,
+			input.new_text,
+			encoding,
+			maxDiffLines,
+		);
 	};
 }

package/src/tools/schemas.ts

@@ -52,14 +52,16 @@ export const SearchCodebaseUnionInputSchema = z.union([
 	z.string(),
 ]);
 
-const CommandInputSchema = z.string();
+const CommandInputSchema = z
+	.string()
+	.describe("The non-interactive shell command to execute");
 /**
  * Schema for run_commands tool input
  */
 export const RunCommandsInputSchema = z.object({
 	commands: z
 		.array(CommandInputSchema)
-		.describe("Array of shell commands to execute."),
+		.describe("Array of shell commands to execute"),
 });
 
 /**
@@ -67,8 +69,8 @@ export const RunCommandsInputSchema = z.object({
  */
 export const RunCommandsInputUnionSchema = z.union([
 	RunCommandsInputSchema,
-	z.array(CommandInputSchema),
-	CommandInputSchema,
+	z.array(z.string()),
+	z.string(),
 ]);
 
 /**
@@ -93,46 +95,34 @@ export const FetchWebContentInputSchema = z.object({
  */
 export const EditFileInputSchema = z
 	.object({
-		command: z
-			.enum(["create", "str_replace", "insert"])
-			.describe("Editor command to execute: create, str_replace, insert"),
-		path: z.string().min(1).describe("Absolute file path"),
-		file_text: z
+		path: z
 			.string()
-			.nullish()
-			.describe("Full file content required for 'create' command"),
-		old_str: z
+			.min(1)
+			.describe("The absolute file path for the action to be performed on"),
+		old_text: z
 			.string()
-			.nullish()
+			.nullable()
+			.optional()
 			.describe(
-				"Exact text to replace (must match exactly once) for 'str_replace' command",
+				"Exact text to replace (must match exactly once). Omit this when creating a missing file or inserting via insert_line.",
 			),
-		new_str: z
+		new_text: z
 			.string()
-			.nullish()
-			.describe("Replacement text for 'str_replace' or 'insert' commands"),
+			.describe(
+				"The new content to write when creating a missing file, the replacement text for edits, or the inserted text when insert_line is provided",
+			),
 		insert_line: z
 			.number()
 			.int()
-			.nullish()
-			.describe("Optional one-based line index for 'insert' command"),
-	})
-	.refine((v) => v.command !== "create" || v.file_text != null, {
-		path: ["file_text"],
-		message: "file_text is required for command=create",
-	})
-	.refine((v) => v.command !== "str_replace" || v.old_str != null, {
-		path: ["old_str"],
-		message: "old_str is required for command=str_replace",
-	})
-	.refine((v) => v.command !== "insert" || v.insert_line != null, {
-		path: ["insert_line"],
-		message: "insert_line is required for command=insert",
+			.nullable()
+			.optional()
+			.describe(
+				"Optional one-based line index. When provided, the tool inserts new_text at that line instead of performing a replacement edit.",
+			),
 	})
-	.refine((v) => v.command !== "insert" || v.new_str != null, {
-		path: ["new_str"],
-		message: "new_str is required for command=insert",
-	});
+	.describe(
+		"Edit a text file by replacing old_text with new_text, create the file with new_text if it does not exist, or insert new_text at insert_line when insert_line is provided. IMPORTANT: large edits can time out, so use small chunks and multiple calls when possible.",
+	);
 
 /**
  * Schema for apply_patch tool input

package/src/types/events.ts

@@ -13,7 +13,12 @@ export interface SessionEndedEvent {
 
 export interface SessionToolEvent {
 	sessionId: string;
-	hookEventName: "tool_call" | "tool_result" | "agent_end" | "session_shutdown";
+	hookEventName:
+		| "tool_call"
+		| "tool_result"
+		| "agent_end"
+		| "agent_error"
+		| "session_shutdown";
 	agentId?: string;
 	conversationId?: string;
 	parentAgentId?: string;