@clinebot/core 0.0.35 → 0.0.36

package/src/extensions/plugin/plugin-sandbox.ts

@@ -2,17 +2,35 @@ import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import type { AgentConfig, HookStage, Tool } from "@clinebot/shared";
+import type {
+	AgentConfig,
+	HookStage,
+	Tool,
+	WorkspaceInfo,
+} from "@clinebot/shared";
 import { SubprocessSandbox } from "../../runtime/subprocess-sandbox";
 import type { PluginLoadDiagnostics } from "./plugin-load-report";
+import type { PluginTargeting } from "./plugin-targeting";
 
-export interface PluginSandboxOptions {
+export interface PluginSandboxOptions extends PluginTargeting {
 	pluginPaths: string[];
 	exportName?: string;
 	importTimeoutMs?: number;
 	hookTimeoutMs?: number;
 	contributionTimeoutMs?: number;
 	onEvent?: (event: { name: string; payload?: unknown }) => void;
+	/**
+	 * The session's working directory. Forwarded to the sandbox subprocess so
+	 * that `process.cwd()` returns the correct path inside the sandbox even
+	 * when `--cwd` was passed without calling `process.chdir()` on the host.
+	 */
+	cwd?: string;
+	/**
+	 * Structured workspace and git metadata (branch, commit, remotes) generated
+	 * at session startup. Forwarded to plugins via PluginSetupCtx.workspaceInfo
+	 * so they can inspect git state without running their own commands.
+	 */
+	workspaceInfo?: WorkspaceInfo;
 }
 
 type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
@@ -25,8 +43,6 @@ type SandboxedContributionDescriptor = {
 	inputSchema?: unknown;
 	timeoutMs?: number;
 	retryable?: boolean;
-	value?: string;
-	defaultValue?: boolean | string | number;
 	metadata?: Record<string, unknown>;
 };
 
@@ -38,10 +54,10 @@ type SandboxedPluginDescriptor = {
 	contributions: {
 		tools: SandboxedContributionDescriptor[];
 		commands: SandboxedContributionDescriptor[];
-		shortcuts: SandboxedContributionDescriptor[];
-		flags: SandboxedContributionDescriptor[];
 		messageBuilders: SandboxedContributionDescriptor[];
 		providers: SandboxedContributionDescriptor[];
+		shortcuts?: SandboxedContributionDescriptor[];
+		flags?: SandboxedContributionDescriptor[];
 	};
 };
 
@@ -49,6 +65,22 @@ type SandboxedInitializeResult = {
 	plugins: SandboxedPluginDescriptor[];
 } & PluginLoadDiagnostics;
 
+function normalizeDescriptor(
+	descriptor: SandboxedPluginDescriptor,
+): SandboxedPluginDescriptor {
+	return {
+		...descriptor,
+		contributions: {
+			tools: descriptor.contributions?.tools ?? [],
+			commands: descriptor.contributions?.commands ?? [],
+			messageBuilders: descriptor.contributions?.messageBuilders ?? [],
+			providers: descriptor.contributions?.providers ?? [],
+			shortcuts: descriptor.contributions?.shortcuts ?? [],
+			flags: descriptor.contributions?.flags ?? [],
+		},
+	};
+}
+
 function isUnknownPluginIdError(error: unknown): boolean {
 	const message = error instanceof Error ? error.message : String(error);
 	return message.includes("Unknown sandbox plugin id:");
@@ -181,6 +213,10 @@ export async function loadSandboxedPlugins(
 	const initArgs = {
 		pluginPaths: options.pluginPaths,
 		exportName: options.exportName,
+		providerId: options.providerId,
+		modelId: options.modelId,
+		cwd: options.cwd,
+		workspaceInfo: options.workspaceInfo,
 	};
 
 	// Guard against concurrent re-initialization when multiple tools/hooks
@@ -208,7 +244,7 @@ export async function loadSandboxedPlugins(
 		});
 		throw error;
 	}
-	const descriptors = initialized.plugins;
+	const descriptors = initialized.plugins.map(normalizeDescriptor);
 
 	const extensions: NonNullable<AgentConfig["extensions"]> = descriptors.map(
 		(descriptor) => {
@@ -267,7 +303,7 @@ function registerTools(
 	timeoutMs: number,
 	reinitialize: () => Promise<void>,
 ): void {
-	for (const td of descriptor.contributions.tools) {
+	for (const td of descriptor.contributions?.tools ?? []) {
 		const tool: Tool = {
 			name: td.name,
 			description: td.description ?? "",
@@ -318,7 +354,7 @@ function registerCommands(
 	timeoutMs: number,
 	reinitialize: () => Promise<void>,
 ): void {
-	for (const cd of descriptor.contributions.commands) {
+	for (const cd of descriptor.contributions?.commands ?? []) {
 		api.registerCommand({
 			name: cd.name,
 			description: cd.description,
@@ -357,30 +393,14 @@ function registerSimpleContributions(
 	api: AgentExtensionApi,
 	descriptor: SandboxedPluginDescriptor,
 ): void {
-	for (const sd of descriptor.contributions.shortcuts) {
-		api.registerShortcut({
-			name: sd.name,
-			value: sd.value ?? "",
-			description: sd.description,
-		});
-	}
-
-	for (const fd of descriptor.contributions.flags) {
-		api.registerFlag({
-			name: fd.name,
-			description: fd.description,
-			defaultValue: fd.defaultValue,
-		});
-	}
-
-	for (const rd of descriptor.contributions.messageBuilders) {
+	for (const rd of descriptor.contributions?.messageBuilders ?? []) {
 		api.registerMessageBuilder({
 			name: rd.name,
 			build: (m) => m,
 		});
 	}
 
-	for (const pd of descriptor.contributions.providers) {
+	for (const pd of descriptor.contributions?.providers ?? []) {
 		api.registerProvider({
 			name: pd.name,
 			description: pd.description,

package/src/extensions/plugin/plugin-targeting.ts

@@ -0,0 +1,32 @@
+import type { PluginManifest } from "@clinebot/shared";
+
+export interface PluginTargeting {
+	providerId?: string;
+	modelId?: string;
+}
+
+export function matchesPluginManifestTargeting(
+	manifest: PluginManifest | undefined,
+	targeting: PluginTargeting | undefined,
+): boolean {
+	if (!manifest) {
+		return true;
+	}
+
+	if (manifest.providerIds?.length) {
+		if (
+			!targeting?.providerId ||
+			!manifest.providerIds.includes(targeting.providerId)
+		) {
+			return false;
+		}
+	}
+
+	if (manifest.modelIds?.length) {
+		if (!targeting?.modelId || !manifest.modelIds.includes(targeting.modelId)) {
+			return false;
+		}
+	}
+
+	return true;
+}

package/src/extensions/tools/definitions.ts

@@ -350,67 +350,48 @@ export function createWebFetchTool(
 	});
 }
 
-const APPLY_PATCH_TOOL_DESC = `This is a custom utility that makes it more convenient to add, remove, move, or edit code in a single file. \`apply_patch\` effectively allows you to execute a diff/patch against a file, but the format of the diff specification is unique to this task, so pay careful attention to these instructions. To use the \`apply_patch\` command, you should pass a message of the following structure as "input":
+const APPLY_PATCH_TOOL_DESC = `Use \`apply_patch\` to edit files with the canonical freeform patch grammar. Pass the patch text directly as the \`input\` string. Prefer the exact format below:
 
-%%bash
-apply_patch <<"EOF"
 *** Begin Patch
-[YOUR_PATCH]
+*** Update File: path/to/file.ts
+@@ optional section marker
+ [context before]
+-[old line]
++[new line]
+ [context after]
 *** End Patch
-EOF
 
-Where [YOUR_PATCH] is the actual content of your patch, specified in the following V4A diff format.
+Supported actions:
+- \`*** Add File: <path>\`
+- \`*** Update File: <path>\`
+- \`*** Delete File: <path>\`
+- optional \`*** Move to: <new path>\` immediately after an Update File header
 
-*** [ACTION] File: [path/to/file] -> ACTION can be one of Add, Update, or Delete. 
+Rules:
+- In an Add File section, every file-content line must start with \`+\`.
+- In an Update section, use context lines plus \`-\` and \`+\` lines to describe the change.
+- Use \`@@\` markers when extra context is needed to disambiguate repeated code blocks.
+- Do not use line numbers; this format is context-based.
+- Prefer sending the patch body directly. Legacy shell wrappers such as \`%%bash\` and \`apply_patch <<"EOF"\` are accepted for compatibility but are not preferred.
 
-In a Add File section, every line of the new file (including blank/empty lines) MUST start with a \`+\` prefix. Do not include any unprefixed lines inside an Add section
-In a Update/Delete section, repeat the following for each snippet of code that needs to be changed:
-[context_before] -> See below for further instructions on context.
-- [old_code] -> Precede the old code with a minus sign.
-+ [new_code] -> Precede the new, replacement code with a plus sign.
-[context_after] -> See below for further instructions on context.
+Example:
 
-For instructions on [context_before] and [context_after]:
-- By default, show 3 lines of code immediately above and 3 lines immediately below each change. If a change is within 3 lines of a previous change, do NOT duplicate the first change’s [context_after] lines in the second change’s [context_before] lines.
-- If 3 lines of context is insufficient to uniquely identify the snippet of code within the file, use the @@ operator to indicate the class or function to which the snippet belongs. For instance, we might have:
-@@ class BaseClass
-[3 lines of pre-context]
-- [old_code]
-+ [new_code]
-[3 lines of post-context]
-
-- If a code block is repeated so many times in a class or function such that even a single @@ statement and 3 lines of context cannot uniquely identify the snippet of code, you can use multiple \`@@\` statements to jump to the right context. For instance:
-
-@@ class BaseClass
-@@ 	def method():
-[3 lines of pre-context]
-- [old_code]
-+ [new_code]
-[3 lines of post-context]
-
-Note, then, that we do not use line numbers in this diff format, as the context is enough to uniquely identify code. An example of a message that you might pass as "input" to this function, in order to apply a patch, is shown below.
-
-%%bash
-apply_patch <<"EOF"
 *** Begin Patch
-*** Update File: pygorithm/searching/binary_search.py
-@@ class BaseClass
-@@     def search():
--          pass
-+          raise NotImplementedError()
-
-@@ class Subclass
-@@     def search():
--          pass
-+          raise NotImplementedError()
-
-*** End Patch
-EOF`;
+*** Update File: src/page.tsx
+@@
+   return (
+     <div>
+       <button onClick={() => console.log("clicked")}>Click me</button>
++      <button onClick={() => console.log("cancel clicked")}>Cancel</button>
+     </div>
+   );
+ }
+*** End Patch`;
 
 /**
  * Create the apply_patch tool
  *
- * Applies the legacy Cline patch format to one or more files.
+ * Applies the canonical apply_patch format to one or more files.
  */
 export function createApplyPatchTool(
 	executor: ApplyPatchExecutor,

package/src/extensions/tools/executors/apply-patch.ts

@@ -1,7 +1,9 @@
 /**
  * Apply Patch Executor
  *
- * Built-in implementation for the legacy apply_patch format.
+ * Built-in implementation for the documented GPT-5 apply_patch grammar.
+ * It accepts the freeform patch body directly and tolerates the legacy shell
+ * wrapper form used by older prompts.
  */
 
 import * as fs from "node:fs/promises";
@@ -25,6 +27,10 @@ interface FileChange {
 	movePath?: string;
 }
 
+interface NormalizedPatchInput {
+	lines: string[];
+}
+
 /**
  * Options for the apply_patch executor
  */
@@ -63,104 +69,87 @@ function resolveFilePath(
 	return resolved;
 }
 
-function stripBashWrapper(lines: string[]): string[] {
-	const result: string[] = [];
-	let insidePatch = false;
-	let foundBegin = false;
-	let foundContent = false;
-
-	for (let i = 0; i < lines.length; i++) {
-		const line = lines[i];
-		if (
-			!insidePatch &&
-			BASH_WRAPPERS.some((wrapper) => line.startsWith(wrapper))
-		) {
-			continue;
-		}
-
-		if (line.startsWith(PATCH_MARKERS.BEGIN)) {
-			insidePatch = true;
-			foundBegin = true;
-			result.push(line);
-			continue;
-		}
+function normalizeLineEndings(input: string): string[] {
+	return input.split("\n").map((line) => line.replace(/\r$/, ""));
+}
 
-		if (line === PATCH_MARKERS.END) {
-			insidePatch = false;
-			result.push(line);
-			continue;
-		}
+function isWrapperLine(line: string): boolean {
+	if (line.trim() === "") {
+		return false;
+	}
+	return BASH_WRAPPERS.some((wrapper) => line.startsWith(wrapper));
+}
 
-		const isPatchContent =
-			line.startsWith(PATCH_MARKERS.ADD) ||
-			line.startsWith(PATCH_MARKERS.UPDATE) ||
-			line.startsWith(PATCH_MARKERS.DELETE) ||
-			line.startsWith(PATCH_MARKERS.MOVE) ||
-			line.startsWith(PATCH_MARKERS.SECTION) ||
-			line.startsWith("+") ||
-			line.startsWith("-") ||
-			line.startsWith(" ") ||
-			line === "***";
-
-		if (isPatchContent && i !== lines.length - 1) {
-			foundContent = true;
-		}
+function trimWrapperLines(lines: string[]): string[] {
+	let start = 0;
+	let end = lines.length;
 
-		if (
-			insidePatch ||
-			(!foundBegin && isPatchContent) ||
-			(line === "" && foundContent)
-		) {
-			result.push(line);
-		}
+	while (start < end && isWrapperLine(lines[start] ?? "")) {
+		start++;
 	}
 
-	while (result.length > 0 && result[result.length - 1] === "") {
-		result.pop();
+	while (end > start && isWrapperLine(lines[end - 1] ?? "")) {
+		end--;
 	}
 
-	return !foundBegin && !foundContent ? lines : result;
+	return lines.slice(start, end);
 }
 
-function preprocessLines(input: string): string[] {
-	let lines = input.split("\n").map((line) => line.replace(/\r$/, ""));
-	lines = stripBashWrapper(lines);
+function normalizePatchInput(input: string): NormalizedPatchInput {
+	const rawLines = normalizeLineEndings(input);
+	const beginIndex = rawLines.findIndex((line) =>
+		line.startsWith(PATCH_MARKERS.BEGIN),
+	);
+	let endIndex = -1;
+	for (let i = rawLines.length - 1; i >= 0; i--) {
+		if (rawLines[i]?.startsWith(PATCH_MARKERS.END)) {
+			endIndex = i;
+			break;
+		}
+	}
+
+	if (beginIndex !== -1 || endIndex !== -1) {
+		if (beginIndex === -1 || endIndex === -1 || endIndex < beginIndex) {
+			throw new DiffError(
+				"Invalid patch text - incomplete sentinels. Try breaking it into smaller patches.",
+			);
+		}
+		const lines = rawLines.slice(beginIndex, endIndex + 1);
+		return {
+			lines,
+		};
+	}
 
-	const hasBegin = lines.length > 0 && lines[0].startsWith(PATCH_MARKERS.BEGIN);
-	const hasEnd =
-		lines.length > 0 && lines[lines.length - 1] === PATCH_MARKERS.END;
-	if (!hasBegin && !hasEnd) {
-		return [PATCH_MARKERS.BEGIN, ...lines, PATCH_MARKERS.END];
+	const stripped = trimWrapperLines(rawLines);
+	while (stripped.length > 0 && stripped[0] === "") {
+		stripped.shift();
 	}
-	if (hasBegin && hasEnd) {
-		return lines;
+	while (stripped.length > 0 && stripped[stripped.length - 1] === "") {
+		stripped.pop();
 	}
-	throw new DiffError(
-		"Invalid patch text - incomplete sentinels. Try breaking it into smaller patches.",
-	);
+
+	const lines = [PATCH_MARKERS.BEGIN, ...stripped, PATCH_MARKERS.END];
+	return {
+		lines,
+	};
 }
 
 function extractFilesForOperations(
-	text: string,
+	lines: readonly string[],
 	markers: readonly string[],
 ): string[] {
-	const lines = stripBashWrapper(text.split("\n"));
-	const files: string[] = [];
+	const files = new Set<string>();
 
 	for (const line of lines) {
 		for (const marker of markers) {
-			if (!line.startsWith(marker)) {
-				continue;
-			}
-			const file = line.substring(marker.length).trim();
-			if (!text.trim().endsWith(file)) {
-				files.push(file);
+			if (line.startsWith(marker)) {
+				files.add(line.substring(marker.length).trim());
+				break;
 			}
-			break;
 		}
 	}
 
-	return files;
+	return [...files];
 }
 
 function applyChunks(
@@ -197,12 +186,12 @@ function applyChunks(
 }
 
 async function loadFiles(
-	rawInput: string,
+	lines: readonly string[],
 	cwd: string,
 	encoding: BufferEncoding,
 	restrictToCwd: boolean,
 ): Promise<Record<string, string>> {
-	const filesToLoad = extractFilesForOperations(rawInput, [
+	const filesToLoad = extractFilesForOperations(lines, [
 		PATCH_MARKERS.UPDATE,
 		PATCH_MARKERS.DELETE,
 	]);
@@ -328,14 +317,14 @@ export function createApplyPatchExecutor(
 		cwd: string,
 		_context: ToolContext,
 	): Promise<string> => {
-		const lines = preprocessLines(input.input);
+		const normalizedInput = normalizePatchInput(input.input);
 		const currentFiles = await loadFiles(
-			input.input,
+			normalizedInput.lines,
 			cwd,
 			encoding,
 			restrictToCwd,
 		);
-		const parser = new PatchParser(lines, currentFiles);
+		const parser = new PatchParser(normalizedInput.lines, currentFiles);
 		const { patch, fuzz } = parser.parse();
 		const changes = patchToChanges(patch, currentFiles);
 		const touched = await applyChanges(changes, cwd, encoding, restrictToCwd);