@caplets/core 0.18.2 → 0.18.4

package/dist/native/service.d.ts

@@ -1,6 +1,7 @@
 import type { NativeCapletsServiceResolutionInput } from "./options";
 import { resolveNativeCapletsServiceOptions } from "./options";
 import { type RemoteCapletsClient } from "./remote";
+import { type CapletsConfig } from "../config";
 import { generatedToolInputJsonSchemaForCaplet } from "../generated-tool-input-schema";
 export type NativeCapletsServiceOptions = NativeCapletsServiceResolutionInput & {
     configPath?: string;
@@ -12,6 +13,7 @@ export type NativeCapletsServiceOptions = NativeCapletsServiceResolutionInput &
     remoteClientFactory?: (options: Extract<ReturnType<typeof resolveNativeCapletsServiceOptions>, {
         mode: "remote";
     }>["remote"]) => RemoteCapletsClient;
+    localServiceFactory?: (options: LocalNativeCapletsServiceOptions) => NativeCapletsService;
 };
 export type NativeCapletTool = {
     caplet: string;
@@ -31,3 +33,7 @@ export type NativeCapletsService = {
     close(): Promise<void>;
 };
 export declare function createNativeCapletsService(options?: NativeCapletsServiceOptions): NativeCapletsService;
+type LocalNativeCapletsServiceOptions = NativeCapletsServiceOptions & {
+    configLoader?: (configPath: string, projectConfigPath: string) => CapletsConfig;
+};
+export {};

package/dist/native.js

@@ -1,4 +1,4 @@
-import { Ot as CapletsError, Q as ToolListChangedNotificationSchema, _ as StreamableHTTPClientTransport, a as resolveCapletsServer, b as Client, i as resolveCapletsMode, l as capabilityDescription, n as mcpUrlForBase, o as CapletsEngine } from "./options-bnsSREid.js";
+import { Q as ToolListChangedNotificationSchema, _ as StreamableHTTPClientTransport, a as resolveCapletsServer, b as Client, bt as parseConfig, i as resolveCapletsMode, jt as CapletsError, l as capabilityDescription, n as mcpUrlForBase, o as CapletsEngine, vt as loadLocalOverlayConfigWithSources } from "./options-BlNyqF_E.js";
 import { a as generatedToolInputJsonSchemaForCaplet, i as generatedToolInputJsonSchema, l as operations, o as generatedToolInputSchema } from "./generated-tool-input-schema-BYoyY-l-.js";
 //#region src/native/options.ts
 const DEFAULT_POLL_INTERVAL_MS = 3e4;
@@ -155,10 +155,10 @@ var RemoteNativeCapletsService = class {
 				await this.reloadFromClient();
 				return !this.closed;
 			} catch (retryError) {
-				this.warn(`Could not reload remote Caplets tools: ${errorMessage(retryError)}\n`);
+				this.warn(`Could not reload remote Caplets tools: ${errorMessage$1(retryError)}\n`);
 				return false;
 			}
-			this.warn(`Could not reload remote Caplets tools: ${errorMessage(error)}\n`);
+			this.warn(`Could not reload remote Caplets tools: ${errorMessage$1(error)}\n`);
 			return false;
 		}
 	}
@@ -248,14 +248,14 @@ function operationNamesFromSchema(schema) {
 function isPlainObject(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function errorMessage(error) {
+function errorMessage$1(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 function remoteAuthError() {
 	return new CapletsError("AUTH_FAILED", "Remote Caplets authentication failed; check CAPLETS_SERVER_USER and CAPLETS_SERVER_PASSWORD.");
 }
 function isSessionFailure(error) {
-	const message = errorMessage(error).toLowerCase();
+	const message = errorMessage$1(error).toLowerCase();
 	return /session|transport|connection|connect|closed|invalid/u.test(message);
 }
 function isAuthFailure(error) {
@@ -264,18 +264,33 @@ function isAuthFailure(error) {
 	const statusCode = typeof candidate?.statusCode === "number" ? candidate.statusCode : void 0;
 	const code = typeof candidate?.code === "number" ? candidate.code : void 0;
 	if (status === 401 || status === 403 || statusCode === 401 || statusCode === 403 || code === 401 || code === 403) return true;
-	return /\b(401|403|unauthorized|forbidden)\b/iu.test(errorMessage(error));
+	return /\b(401|403|unauthorized|forbidden)\b/iu.test(errorMessage$1(error));
 }
 //#endregion
 //#region src/native/service.ts
 function createNativeCapletsService(options = {}) {
 	const resolved = resolveNativeCapletsServiceOptions(options);
-	if (resolved.mode === "remote") return new RemoteNativeCapletsService({
-		client: (options.remoteClientFactory ?? createSdkRemoteCapletsClient)(resolved.remote),
-		clientFactory: () => (options.remoteClientFactory ?? createSdkRemoteCapletsClient)(resolved.remote),
-		pollIntervalMs: resolved.remote.pollIntervalMs,
-		...options.writeErr ? { writeErr: options.writeErr } : {}
-	});
+	if (resolved.mode === "remote") {
+		const localOptions = {
+			...options,
+			mode: "local",
+			configLoader: createLocalOverlayConfigLoader(options)
+		};
+		const local = (options.localServiceFactory ?? createDefaultNativeCapletsService)(localOptions);
+		try {
+			return new CompositeNativeCapletsService(new RemoteNativeCapletsService({
+				client: (options.remoteClientFactory ?? createSdkRemoteCapletsClient)(resolved.remote),
+				clientFactory: () => (options.remoteClientFactory ?? createSdkRemoteCapletsClient)(resolved.remote),
+				pollIntervalMs: resolved.remote.pollIntervalMs,
+				...options.writeErr ? { writeErr: options.writeErr } : {}
+			}), local, options);
+		} catch (error) {
+			local.close().catch((closeError) => {
+				writeErr(options, `Could not close local overlay Caplets service: ${errorMessage(closeError)}\n`);
+			});
+			throw error;
+		}
+	}
 	return new DefaultNativeCapletsService(options);
 }
 var DefaultNativeCapletsService = class {
@@ -311,6 +326,108 @@ var DefaultNativeCapletsService = class {
 		await this.engine.close();
 	}
 };
+function createDefaultNativeCapletsService(options) {
+	return new DefaultNativeCapletsService(options);
+}
+var CompositeNativeCapletsService = class {
+	remote;
+	local;
+	options;
+	listeners = /* @__PURE__ */ new Set();
+	unsubscribers;
+	tools = [];
+	closed = false;
+	batchingReload = false;
+	constructor(remote, local, options) {
+		this.remote = remote;
+		this.local = local;
+		this.options = options;
+		this.unsubscribers = [this.remote.onToolsChanged(() => this.updateMergedTools()), this.local.onToolsChanged(() => this.updateMergedTools())];
+		this.tools = this.mergeTools();
+	}
+	listTools() {
+		return [...this.tools];
+	}
+	async execute(capletId, request) {
+		if (this.local.listTools().some((tool) => tool.caplet === capletId)) return await this.local.execute(capletId, request);
+		return await this.remote.execute(capletId, request);
+	}
+	async reload() {
+		if (this.closed) return false;
+		this.batchingReload = true;
+		const remoteReloaded = await this.reloadChild(this.remote, "remote");
+		const localReloaded = await this.reloadChild(this.local, "local overlay");
+		this.batchingReload = false;
+		if (remoteReloaded === void 0 || localReloaded === void 0) return false;
+		this.updateMergedTools();
+		return remoteReloaded || localReloaded;
+	}
+	onToolsChanged(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		for (const unsubscribe of this.unsubscribers.splice(0)) unsubscribe();
+		this.listeners.clear();
+		await Promise.all([this.remote.close(), this.local.close()]);
+	}
+	updateMergedTools() {
+		if (this.closed || this.batchingReload) return;
+		const tools = this.mergeTools();
+		if (JSON.stringify(tools) === JSON.stringify(this.tools)) return;
+		this.tools = tools;
+		for (const listener of this.listeners) try {
+			listener(this.listTools());
+		} catch (error) {
+			writeErr(this.options, `Caplets tools-changed listener failed: ${errorMessage(error)}\n`);
+		}
+	}
+	mergeTools() {
+		const localTools = this.local.listTools();
+		const localIds = new Set(localTools.map((tool) => tool.caplet));
+		return [...this.remote.listTools().filter((tool) => !localIds.has(tool.caplet)), ...localTools];
+	}
+	async reloadChild(service, label) {
+		try {
+			return await service.reload();
+		} catch (error) {
+			writeErr(this.options, `Could not reload composite Caplets tools from ${label}: ${errorMessage(error)}\n`);
+			return;
+		}
+	}
+};
+function createLocalOverlayConfigLoader(options) {
+	let hasLoaded = false;
+	let previousWarnings = /* @__PURE__ */ new Set();
+	return (configPath, projectConfigPath) => {
+		let result;
+		try {
+			result = loadLocalOverlayConfigWithSources(configPath, projectConfigPath);
+		} catch (error) {
+			writeErr(options, `Caplets local overlay warning: Could not load local overlay config: ${errorMessage(error)}\n`);
+			if (hasLoaded) throw new CapletsError("CONFIG_INVALID", "Caplets local overlay reload failed; keeping last known-good config.", error);
+			hasLoaded = true;
+			return parseConfig({});
+		}
+		for (const warning of result.warnings) writeErr(options, `Caplets local overlay warning${typeof warning.path === "string" ? ` at ${warning.path}` : ""}: ${warning.message}\n`);
+		const warnings = new Set(result.warnings.map(warningKey));
+		if (hasLoaded && [...warnings].some((warning) => !previousWarnings.has(warning))) throw new CapletsError("CONFIG_INVALID", "Caplets local overlay reload produced new warnings; keeping last known-good config.");
+		previousWarnings = warnings;
+		hasLoaded = true;
+		return result.config;
+	};
+}
+function warningKey(warning) {
+	return `${warning.kind}\0${warning.path}\0${warning.message}`;
+}
+function writeErr(options, message) {
+	(options.writeErr ?? ((value) => process.stderr.write(value)))(message);
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
 //#endregion
 //#region src/native/process-cleanup.ts
 function registerNativeCapletsProcessCleanup(service) {