@clinebot/core 0.0.35 → 0.0.37

package/src/services/local-runtime-bootstrap.ts

@@ -1,11 +1,15 @@
 import type {
 	AgentConfig,
 	AgentHooks,
+	ExtensionContext,
 	ITelemetryService,
+	RuntimeConfigExtensionKind,
 	Tool,
 	ToolApprovalRequest,
 	ToolApprovalResult,
+	WorkspaceInfo,
 } from "@clinebot/shared";
+import { decodeJwtPayload } from "../auth/utils";
 import { resolveAndLoadAgentPlugins } from "../extensions/plugin/plugin-config-loader";
 import type {
 	PluginInitializationFailure,
@@ -24,10 +28,7 @@ import type {
 	LocalRuntimeStartOptions,
 	StartSessionInput,
 } from "../runtime/runtime-host";
-import type {
-	RuntimeBuilderInput,
-	TeamToolsFactory,
-} from "../runtime/session-runtime";
+import type { RuntimeBuilderInput } from "../runtime/session-runtime";
 import type { CoreSessionConfig } from "../types/config";
 import {
 	type ProviderConfig,
@@ -35,9 +36,10 @@ import {
 	toProviderConfig,
 } from "../types/provider-settings";
 import { resolveWorkspacePath } from "./config";
+import { filterExtensionToolRegistrations } from "./global-settings";
 import { hasRuntimeHooks, mergeAgentExtensions } from "./session-data";
 import type { ProviderSettingsManager } from "./storage/provider-settings-manager";
-import { buildWorkspaceMetadata } from "./workspace-manifest";
+import { buildWorkspaceMetadataWithInfo } from "./workspace-manifest";
 
 function formatPluginFailure(failure: PluginInitializationFailure): string {
 	const label = failure.pluginName ?? failure.pluginPath;
@@ -90,19 +92,103 @@ function resolveReasoningSettings(
 	};
 }
 
+const ALL_CONFIG_EXTENSIONS: readonly RuntimeConfigExtensionKind[] = [
+	"rules",
+	"skills",
+	"plugins",
+];
+
+function hasConfigExtension(
+	extensions: ReadonlyArray<RuntimeConfigExtensionKind> | undefined,
+	kind: RuntimeConfigExtensionKind,
+): boolean {
+	return new Set(extensions ?? ALL_CONFIG_EXTENSIONS).has(kind);
+}
+
+function buildOpenAICodexHeaders(input: {
+	sessionId: string;
+	configHeaders: CoreSessionConfig["headers"];
+	storedHeaders: ProviderSettings["headers"];
+	accountId?: string;
+	accessToken?: string;
+}): Record<string, string> | undefined {
+	const headers: Record<string, string> = {
+		...(input.storedHeaders ?? {}),
+		...(input.configHeaders ?? {}),
+	};
+	const resolvedAccountId =
+		input.accountId?.trim() || deriveOpenAICodexAccountId(input.accessToken);
+	headers.originator = "cline";
+	headers.session_id = input.sessionId;
+	headers["User-Agent"] = `Cline/${process.env.npm_package_version || "1.0.0"}`;
+	if (resolvedAccountId) {
+		headers["ChatGPT-Account-Id"] = resolvedAccountId;
+	}
+	return headers;
+}
+
+function deriveOpenAICodexAccountId(
+	accessToken: string | undefined,
+): string | undefined {
+	const trimmed = accessToken?.trim();
+	if (!trimmed) {
+		return undefined;
+	}
+	const payload = decodeJwtPayload(trimmed) as {
+		"https://api.openai.com/auth"?: { chatgpt_account_id?: string };
+		organizations?: Array<{ id?: string }>;
+		chatgpt_account_id?: string;
+	} | null;
+	const authAccountId =
+		payload?.["https://api.openai.com/auth"]?.chatgpt_account_id;
+	if (typeof authAccountId === "string" && authAccountId.length > 0) {
+		return authAccountId;
+	}
+	const orgAccountId = payload?.organizations?.[0]?.id;
+	if (typeof orgAccountId === "string" && orgAccountId.length > 0) {
+		return orgAccountId;
+	}
+	const rootAccountId = payload?.chatgpt_account_id;
+	if (typeof rootAccountId === "string" && rootAccountId.length > 0) {
+		return rootAccountId;
+	}
+	return undefined;
+}
+
 function buildProviderConfig(
 	config: CoreSessionConfig,
+	sessionId: string,
 	providerSettingsManager: ProviderSettingsManager,
+	modelCatalogDefaults?: Partial<ProviderSettings["modelCatalog"]>,
+	defaultFetch?: typeof fetch,
 ): ProviderConfig {
 	const stored = providerSettingsManager.getProviderSettings(config.providerId);
+	const modelCatalog =
+		modelCatalogDefaults || stored?.modelCatalog
+			? {
+					...(modelCatalogDefaults ?? {}),
+					...(stored?.modelCatalog ?? {}),
+				}
+			: undefined;
 	const settings: ProviderSettings = {
 		...(stored ?? {}),
 		provider: config.providerId,
 		model: config.modelId,
 		apiKey: config.apiKey ?? stored?.apiKey,
 		baseUrl: config.baseUrl ?? stored?.baseUrl,
-		headers: config.headers ?? stored?.headers,
+		headers:
+			config.providerId === "openai-codex"
+				? buildOpenAICodexHeaders({
+						sessionId,
+						configHeaders: config.headers,
+						storedHeaders: stored?.headers,
+						accountId: stored?.auth?.accountId,
+						accessToken:
+							config.apiKey ?? stored?.auth?.accessToken ?? stored?.apiKey,
+					})
+				: (config.headers ?? stored?.headers),
 		reasoning: resolveReasoningSettings(config, stored?.reasoning),
+		modelCatalog,
 	};
 	const providerConfig = toProviderConfig(settings);
 	if (config.knownModels) {
@@ -111,6 +197,13 @@ function buildProviderConfig(
 	if (config.extensionContext) {
 		providerConfig.extensionContext = config.extensionContext;
 	}
+	// Thread a host-provided custom fetch through to the AI gateway providers.
+	// Precedence: explicit per-session config > stored provider settings > host default.
+	const sessionFetch = (config as { fetch?: typeof fetch }).fetch;
+	const resolvedFetch = sessionFetch ?? providerConfig.fetch ?? defaultFetch;
+	if (resolvedFetch) {
+		providerConfig.fetch = resolvedFetch;
+	}
 	return providerConfig;
 }
 
@@ -121,11 +214,15 @@ export interface PrepareLocalRuntimeBootstrapOptions {
 	providerSettingsManager: ProviderSettingsManager;
 	defaultTelemetry?: ITelemetryService;
 	defaultToolExecutors?: Partial<ToolExecutors>;
-	teamToolsFactory?: TeamToolsFactory;
 	defaultToolPolicies?: AgentConfig["toolPolicies"];
 	defaultRequestToolApproval?: (
 		request: ToolApprovalRequest,
 	) => Promise<ToolApprovalResult>;
+	/**
+	 * Host-level default `fetch` threaded into `ProviderConfig.fetch` so the
+	 * AI gateway providers can use a custom HTTP implementation.
+	 */
+	defaultFetch?: typeof fetch;
 	onPluginEvent: (event: { name: string; payload?: unknown }) => void;
 	onTeamEvent: (event: TeamEvent) => void;
 	createSpawnTool: () => Tool;
@@ -140,6 +237,8 @@ export interface LocalRuntimeBootstrap {
 	config: CoreSessionConfig;
 	providerConfig: ProviderConfig;
 	workspaceMetadata: string;
+	/** Structured git + path metadata generated alongside workspaceMetadata. */
+	workspaceInfo: WorkspaceInfo;
 	extensions: AgentConfig["extensions"];
 	hooks: AgentHooks | undefined;
 	toolPolicies: AgentConfig["toolPolicies"];
@@ -159,9 +258,9 @@ export async function prepareLocalRuntimeBootstrap(
 		providerSettingsManager,
 		defaultTelemetry,
 		defaultToolExecutors,
-		teamToolsFactory,
 		defaultToolPolicies,
 		defaultRequestToolApproval,
+		defaultFetch,
 		onPluginEvent,
 		onTeamEvent,
 		createSpawnTool,
@@ -173,18 +272,44 @@ export async function prepareLocalRuntimeBootstrap(
 	const configOverrides = localRuntime?.configOverrides as
 		| Partial<LocalRuntimeConfigOverrides>
 		| undefined;
+	const localConfig = configOverrides as Partial<CoreSessionConfig> | undefined;
+
+	// Generate workspace + git metadata once, early, so it can be forwarded to
+	// hooks and extensions. The serialized string goes into CoreSessionConfig
+	// as workspaceMetadata; the structured object is kept as workspaceInfo.
+	const { workspaceInfo, workspaceMetadata } =
+		await buildWorkspaceMetadataWithInfo(input.config.cwd);
+	const configuredExtensionContext = localConfig?.extensionContext;
+	const extensionContext: ExtensionContext = {
+		...(configuredExtensionContext ?? {}),
+		workspace: {
+			...workspaceInfo,
+			...(configuredExtensionContext?.workspace ?? {}),
+		},
+		session: {
+			...(configuredExtensionContext?.session ?? {}),
+			sessionId,
+		},
+		logger: configuredExtensionContext?.logger ?? configOverrides?.logger,
+		telemetry:
+			configuredExtensionContext?.telemetry ??
+			configOverrides?.telemetry ??
+			defaultTelemetry,
+	};
 
 	const fileHooks = createHookConfigFileHooks({
 		cwd: input.config.cwd,
 		workspacePath,
 		rootSessionId: sessionId,
 		logger: configOverrides?.logger,
+		workspaceInfo,
 	});
 	const auditHooks = hasRuntimeHooks(configOverrides?.hooks)
 		? undefined
 		: createHookAuditHooks({
 				rootSessionId: sessionId,
 				workspacePath,
+				workspaceInfo,
 			});
 	const baseHooks = mergeAgentHooks([
 		configOverrides?.hooks,
@@ -195,40 +320,55 @@ export async function prepareLocalRuntimeBootstrap(
 	let loadedPlugins:
 		| Awaited<ReturnType<typeof resolveAndLoadAgentPlugins>>
 		| undefined;
-	try {
-		loadedPlugins = await resolveAndLoadAgentPlugins({
-			pluginPaths: configOverrides?.pluginPaths,
-			workspacePath,
-			cwd: input.config.cwd,
-			onEvent: onPluginEvent,
-		});
-		logPluginDiagnostics(
-			loadedPlugins.failures,
-			loadedPlugins.warnings,
-			configOverrides?.logger,
-		);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		configOverrides?.logger?.log?.(
-			`plugin loading failed; continuing without plugins (${message})`,
-		);
+	if (hasConfigExtension(localRuntime?.configExtensions, "plugins")) {
+		try {
+			loadedPlugins = await resolveAndLoadAgentPlugins({
+				pluginPaths: localConfig?.pluginPaths,
+				workspacePath,
+				cwd: input.config.cwd,
+				onEvent: onPluginEvent,
+				providerId: input.config.providerId,
+				modelId: input.config.modelId,
+				workspaceInfo,
+				session: extensionContext.session,
+				client: extensionContext.client,
+				user: extensionContext.user,
+				logger: extensionContext.logger,
+				telemetry: extensionContext.telemetry,
+				automation: extensionContext.automation,
+			});
+			logPluginDiagnostics(
+				loadedPlugins.failures,
+				loadedPlugins.warnings,
+				configOverrides?.logger,
+			);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			configOverrides?.logger?.log?.(
+				`plugin loading failed; continuing without plugins (${message})`,
+			);
+		}
 	}
 
 	const extensions = mergeAgentExtensions(
 		configOverrides?.extensions,
-		loadedPlugins?.extensions,
+		filterExtensionToolRegistrations(loadedPlugins?.extensions),
 	);
-	const workspaceMetadata = await buildWorkspaceMetadata(input.config.cwd);
 	const baseConfig: CoreSessionConfig = {
 		...input.config,
 		...(configOverrides ?? {}),
+		sessionId,
 		hooks: baseHooks,
 		extensions,
-		telemetry: configOverrides?.telemetry ?? defaultTelemetry,
+		extensionContext,
+		telemetry: extensionContext.telemetry,
 	};
 	const providerConfig = buildProviderConfig(
 		baseConfig,
+		sessionId,
 		providerSettingsManager,
+		localRuntime?.modelCatalogDefaults,
+		defaultFetch,
 	);
 	const hooks = mergeAgentHooks([
 		baseConfig.hooks,
@@ -249,15 +389,19 @@ export async function prepareLocalRuntimeBootstrap(
 		workspaceMetadata,
 		hooks,
 	};
-	const toolPolicies = input.toolPolicies ?? defaultToolPolicies;
+	const toolPolicies =
+		input.toolPolicies ?? baseConfig.toolPolicies ?? defaultToolPolicies;
 	const requestToolApproval =
 		input.requestToolApproval ?? defaultRequestToolApproval;
+	const effectiveToolExecutors =
+		localRuntime?.defaultToolExecutors ?? defaultToolExecutors;
 
 	return {
 		effectiveInput: input,
 		config,
 		providerConfig,
 		workspaceMetadata,
+		workspaceInfo,
 		extensions,
 		hooks,
 		toolPolicies,
@@ -271,10 +415,10 @@ export async function prepareLocalRuntimeBootstrap(
 			createSpawnTool,
 			onTeamRestored: localRuntime?.onTeamRestored,
 			userInstructionWatcher: localRuntime?.userInstructionWatcher,
-			defaultToolExecutors,
+			configExtensions: localRuntime?.configExtensions,
+			defaultToolExecutors: effectiveToolExecutors,
 			logger: config.logger,
 			telemetry: config.telemetry,
-			teamToolsFactory,
 		},
 	};
 }

package/src/services/plugin-tools.ts

@@ -0,0 +1,86 @@
+import type { AgentConfig, Tool } from "@clinebot/shared";
+import { resolveAgentPluginPaths } from "../extensions/plugin/plugin-config-loader";
+import { loadAgentPluginsFromPathsWithDiagnostics } from "../extensions/plugin/plugin-loader";
+import { resolveDisabledToolNames } from "./global-settings";
+
+type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
+type AgentExtensionApi = Parameters<NonNullable<AgentExtension["setup"]>>[0];
+
+export interface PluginToolSummary {
+	name: string;
+	pluginName: string;
+	path: string;
+	source: "workspace-plugin" | "global-plugin";
+	enabled: boolean;
+	description?: string;
+}
+
+function collectRegisteredTools(
+	extension: AgentExtension,
+	workspaceInfo?: { rootPath: string },
+): Tool[] {
+	if (!extension.setup) {
+		return [];
+	}
+
+	const tools: Tool[] = [];
+	const api: AgentExtensionApi = {
+		registerTool: (tool) => tools.push(tool),
+		registerCommand: () => {},
+		registerMessageBuilder: () => {},
+		registerProvider: () => {},
+		registerAutomationEventType: () => {},
+	};
+	extension.setup(api, { workspaceInfo });
+	return tools;
+}
+
+export async function listPluginTools(input: {
+	workspacePath: string;
+	cwd?: string;
+	disabledToolNames?: ReadonlyArray<string>;
+	providerId?: string;
+	modelId?: string;
+}): Promise<PluginToolSummary[]> {
+	const pluginPaths = resolveAgentPluginPaths({
+		workspacePath: input.workspacePath,
+		cwd: input.cwd,
+	});
+	const disabled = resolveDisabledToolNames(input.disabledToolNames);
+	const summaries: PluginToolSummary[] = [];
+
+	for (const pluginPath of pluginPaths) {
+		const report = await loadAgentPluginsFromPathsWithDiagnostics(
+			[pluginPath],
+			{
+				cwd: input.cwd,
+				providerId: input.providerId,
+				modelId: input.modelId,
+			},
+		);
+		for (const extension of report.plugins) {
+			for (const tool of collectRegisteredTools(extension, {
+				rootPath: input.workspacePath,
+			})) {
+				summaries.push({
+					name: tool.name,
+					pluginName: extension.name,
+					path: pluginPath,
+					source: pluginPath.startsWith(input.workspacePath)
+						? "workspace-plugin"
+						: "global-plugin",
+					enabled: !disabled.has(tool.name),
+					description: tool.description?.trim() || undefined,
+				});
+			}
+		}
+	}
+
+	return summaries.sort((left, right) => {
+		const nameOrder = left.name.localeCompare(right.name);
+		if (nameOrder !== 0) {
+			return nameOrder;
+		}
+		return left.path.localeCompare(right.path);
+	});
+}