@xopcai/xopc 0.0.155 → 0.0.157

package/dist/src/connectors/connector-memory-sync.js

@@ -3,17 +3,29 @@ import "../storage/sqlite/index.js";
 import { ComposioSessionsAdapter } from "./composio-sessions.js";
 import { scopeForComposioAction } from "./composio.js";
 import { getConnectorDefinition } from "./catalog.js";
+import { getConnectorInstance } from "./instances.js";
 import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import { KnowledgeIngestionService } from "../knowledge/ingestion-service.js";
 import { ConnectedKnowledgePipeline } from "../knowledge/connected-knowledge-pipeline.js";
+import { LocalFolderKnowledgeSourceAdapter } from "../knowledge/local-folder-adapter.js";
 import "../knowledge/index.js";
 import { createHash } from "node:crypto";
 //#region src/connectors/connector-memory-sync.ts
-const MEMORY_SOURCE_TOOLKITS = new Set([
+const COMPOSIO_MEMORY_SOURCE_TOOLKITS = new Set([
 	"gmail",
+	"googlecalendar",
 	"googledrive",
+	"googledocs",
+	"googlesheets",
 	"notion",
-	"slack"
+	"slack",
+	"github",
+	"linear",
+	"jira",
+	"outlook",
+	"microsoft_teams",
+	"one_drive",
+	"excel"
 ]);
 const EXTERNAL_ID_KEYS = [
 	"id",
@@ -89,9 +101,85 @@ function sanitizeSourceValue(value, depth = 0) {
 	if (!record) return value;
 	return Object.fromEntries(Object.entries(record).map(([key, nested]) => [key, SENSITIVE_KEY_RE.test(key) ? "[REDACTED]" : sanitizeSourceValue(nested, depth + 1)]));
 }
+function itemTypeFor(toolkit, actionId) {
+	if (toolkit === "gmail" || toolkit === "outlook") return "email";
+	if (toolkit === "googlecalendar" || actionId.includes("CALENDAR")) return "calendar_event";
+	if (toolkit === "slack" || toolkit === "microsoft_teams") return "conversation_message";
+	if (toolkit === "github") return "development_activity";
+	if (toolkit === "linear" || toolkit === "jira") return "work_item";
+	if ([
+		"googledrive",
+		"googledocs",
+		"googlesheets",
+		"notion",
+		"one_drive",
+		"excel"
+	].includes(toolkit)) return "document";
+	return "connector_item";
+}
+function boundedPersonValue(value, maxLength = 320) {
+	return typeof value === "string" ? value.trim().slice(0, maxLength) : "";
+}
+function personEntities(record) {
+	if (!record) return [];
+	const extractPerson = (value, role) => {
+		if (typeof value === "string") {
+			const normalized = boundedPersonValue(value);
+			if (!normalized) return [];
+			return normalized.includes("@") ? [{
+				role,
+				email: normalized
+			}] : [{
+				role,
+				name: normalized
+			}];
+		}
+		const nested = asRecord(value);
+		if (!nested) return [];
+		const name = boundedPersonValue(nested.name, 160) || boundedPersonValue(nested.displayName, 160);
+		const email = boundedPersonValue(nested.email);
+		const username = boundedPersonValue(nested.username, 160);
+		return name || email || username ? [{
+			role,
+			name: name || void 0,
+			email: email || void 0,
+			username: username || void 0
+		}] : [];
+	};
+	const entities = [
+		"email",
+		"from",
+		"sender",
+		"author",
+		"user",
+		"username",
+		"owner",
+		"assignee",
+		"attendees",
+		"participants"
+	].flatMap((key) => {
+		const value = record[key];
+		return Array.isArray(value) ? value.flatMap((item) => extractPerson(item, key)) : extractPerson(value, key);
+	});
+	const unique = /* @__PURE__ */ new Map();
+	for (const entity of entities) {
+		const key = `${entity.role}\u0000${entity.email?.toLowerCase() ?? ""}\u0000${entity.username?.toLowerCase() ?? ""}\u0000${entity.name?.toLowerCase() ?? ""}`;
+		unique.set(key, entity);
+	}
+	return [...unique.values()].slice(0, 50);
+}
+function peopleSignals(entities) {
+	const values = entities.flatMap((entity) => [
+		entity.email,
+		entity.name,
+		entity.username
+	]).filter((value) => typeof value === "string").map((value) => value.trim()).filter(Boolean);
+	return [...new Set(values)].slice(0, 50);
+}
 function resultToSourceItems(input) {
 	return resultRows(input.result).slice(0, 200).map((row, index) => {
 		const record = asRecord(row);
+		const people = personEntities(record);
 		const serialized = JSON.stringify(sanitizeSourceValue(row), null, 2) ?? String(row);
 		const normalizedText = serialized.length > 8e3 ? `${serialized.slice(0, 8e3)}\n…` : serialized;
 		const contentHash = createHash("sha256").update(serialized).digest("hex");
@@ -99,7 +187,7 @@ function resultToSourceItems(input) {
 		return {
 			sourceInstanceId: input.sourceInstanceId,
 			externalId,
-			itemType: `${input.connectorId}:${input.actionId}`,
+			itemType: itemTypeFor(input.toolkit, input.actionId),
 			authorRole: "third_party",
 			occurredAt: timestampField(record, OCCURRED_AT_KEYS),
 			sourceUpdatedAt: timestampField(record, UPDATED_AT_KEYS),
@@ -109,6 +197,9 @@ function resultToSourceItems(input) {
 				connectorId: input.connectorId,
 				connectionId: input.connectionId,
 				actionId: input.actionId,
+				toolkit: input.toolkit,
+				people: peopleSignals(people),
+				personEntities: people,
 				agentId: input.agentId,
 				workspaceId: input.workspaceId
 			},
@@ -119,11 +210,57 @@ function resultToSourceItems(input) {
 		};
 	});
 }
+var ComposioKnowledgeSourceAdapter = class {
+	kind = "composio";
+	constructor(input) {
+		this.input = input;
+	}
+	async pull(pull) {
+		const execution = await this.input.adapter.executeWithPolicy({
+			context: {
+				principalId: "local-owner",
+				toolkits: [this.input.toolkit]
+			},
+			installation: {
+				...this.input.installation,
+				maxScope: "read",
+				confirmationPolicy: "never"
+			},
+			connection: this.input.connection,
+			agentId: this.input.agentId,
+			action: {
+				connectorId: this.input.connectorId,
+				actionId: this.input.actionId,
+				toolkit: this.input.toolkit,
+				scope: "read",
+				curated: true,
+				cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+			},
+			args: this.input.arguments,
+			confirmed: true
+		});
+		if (execution.decision !== "allowed") throw new Error(execution.reason);
+		return {
+			items: resultToSourceItems({
+				result: execution.result,
+				sourceInstanceId: pull.instanceId,
+				connectorId: this.input.connectorId,
+				connectionId: this.input.connection.id,
+				actionId: this.input.actionId,
+				toolkit: this.input.toolkit,
+				agentId: this.input.agentId,
+				workspaceId: this.input.workspaceId
+			}),
+			nextCursor: (/* @__PURE__ */ new Date()).toISOString(),
+			warnings: []
+		};
+	}
+};
 async function syncComposioResultToMemory(input) {
 	const definition = getConnectorDefinition(input.connectorId);
 	if (definition?.runtime.type !== "composio" || definition.runtime.role !== "toolkit") throw new Error("Memory sync requires a Composio toolkit connector.");
 	const toolkit = definition.runtime.toolkit;
-	if (!MEMORY_SOURCE_TOOLKITS.has(toolkit)) throw new Error("Memory sync is supported for Gmail, Google Drive, Notion, and Slack.");
+	if (!COMPOSIO_MEMORY_SOURCE_TOOLKITS.has(toolkit)) throw new Error(`Memory sync is not supported for the ${toolkit} connector.`);
 	const risk = scopeForComposioAction(input.actionId);
 	if (risk.toolkit !== toolkit || risk.scope !== "read" || !risk.curated) throw new Error("Memory sync only accepts a verified read action for the selected connector.");
 	const connectorId = definition.id;
@@ -136,46 +273,25 @@ async function syncComposioResultToMemory(input) {
 	}).filter((connection) => connection.status === "active");
 	const connection = input.connectionId ? activeConnections.find((candidate) => candidate.id === input.connectionId) : activeConnections.find((candidate) => candidate.isDefault) ?? activeConnections[0];
 	if (!connection) throw new Error("No active connector account is available for memory sync.");
-	const execution = await (input.adapter ?? new ComposioSessionsAdapter()).executeWithPolicy({
-		context: {
-			principalId: "local-owner",
-			toolkits: [toolkit]
-		},
-		installation: {
-			...installation,
-			maxScope: "read",
-			confirmationPolicy: "never"
-		},
-		connection,
-		agentId: input.agentId,
-		action: {
-			connectorId,
-			actionId: input.actionId,
-			toolkit,
-			scope: "read",
-			curated: true,
-			cachedAt: (/* @__PURE__ */ new Date()).toISOString()
-		},
-		args: input.arguments ?? {},
-		confirmed: true
-	});
-	if (execution.decision !== "allowed") throw new Error(execution.reason);
+	const adapter = input.adapter ?? new ComposioSessionsAdapter();
 	const workspaceId = getWorkspacePath(input.config);
 	const sourceInstanceId = `composio:${connectorId}:${connection.id}`;
-	const items = resultToSourceItems({
-		result: execution.result,
-		sourceInstanceId,
+	const sourceAdapter = new ComposioKnowledgeSourceAdapter({
 		connectorId,
-		connectionId: connection.id,
+		connection,
 		actionId: input.actionId,
+		arguments: input.arguments ?? {},
 		agentId: input.agentId,
-		workspaceId
+		toolkit,
+		workspaceId,
+		installation,
+		adapter
 	});
-	new KnowledgeIngestionService(/* @__PURE__ */ new Map()).ingest({
-		instanceId: sourceInstanceId,
-		items,
-		cursorAfter: (/* @__PURE__ */ new Date()).toISOString()
+	const syncRun = await new KnowledgeIngestionService(new Map([[sourceAdapter.kind, sourceAdapter]])).sync({
+		adapterKind: sourceAdapter.kind,
+		instanceId: sourceInstanceId
 	});
+	if (syncRun.status === "failed" || syncRun.status === "cancelled") throw new Error(syncRun.error ?? `Connector memory sync ${syncRun.status}.`);
 	const pipeline = new ConnectedKnowledgePipeline({
 		agentId: input.agentId,
 		workspaceId
@@ -193,5 +309,35 @@ async function syncComposioResultToMemory(input) {
 		actionId: input.actionId
 	};
 }
+async function syncLocalFolderToMemory(input) {
+	const definition = getConnectorDefinition(input.connectorId);
+	if (definition?.runtime.type !== "memorySource" || definition.runtime.sourceKind !== "local-folder") throw new Error("Local folder sync requires a local-folder memory source connector.");
+	const instance = getConnectorInstance(input.config, definition.id);
+	if (!instance?.enabled) throw new Error("Local folder connector is not installed and enabled.");
+	const rootPath = typeof instance.config?.rootPath === "string" ? instance.config.rootPath.trim() : "";
+	if (!rootPath) throw new Error("Local folder connector requires a rootPath.");
+	const sourceInstanceId = `local-folder:${definition.id}`;
+	const adapter = new LocalFolderKnowledgeSourceAdapter(rootPath);
+	const syncRun = await new KnowledgeIngestionService(new Map([[adapter.kind, adapter]])).sync({
+		adapterKind: adapter.kind,
+		instanceId: sourceInstanceId
+	});
+	if (syncRun.status === "failed" || syncRun.status === "cancelled") throw new Error(syncRun.error ?? `Local folder sync ${syncRun.status}.`);
+	const pipeline = new ConnectedKnowledgePipeline({
+		agentId: input.agentId,
+		workspaceId: getWorkspacePath(input.config)
+	});
+	const recordIds = [];
+	for (let batch = 0; batch < 10; batch += 1) {
+		const synthesis = await pipeline.processPending(sourceInstanceId);
+		recordIds.push(...synthesis.recordIds);
+		if (synthesis.claimed === 0) break;
+	}
+	return {
+		connectorId: definition.id,
+		sourceInstanceId,
+		recordIds
+	};
+}
 //#endregion
-export { syncComposioResultToMemory };
+export { COMPOSIO_MEMORY_SOURCE_TOOLKITS, syncComposioResultToMemory, syncLocalFolderToMemory };

package/dist/src/connectors/integration-strategy.js

@@ -1,13 +1,70 @@
 //#region src/connectors/integration-strategy.ts
-const COMPOSIO_STRATEGY_OVERRIDES = { telegram: {
-	lane: "native",
-	workload: "core",
-	preferred: false,
-	alternative: {
-		kind: "channel",
-		id: "telegram"
+const COMPOSIO_STRATEGY_OVERRIDES = {
+	gmail: {
+		lane: "composio",
+		workload: "core",
+		preferred: true
+	},
+	googlecalendar: {
+		lane: "composio",
+		workload: "core",
+		preferred: true
+	},
+	googledrive: {
+		lane: "composio",
+		workload: "core",
+		preferred: true
+	},
+	notion: {
+		lane: "composio",
+		workload: "core",
+		preferred: true
+	},
+	slack: {
+		lane: "composio",
+		workload: "core",
+		preferred: true
+	},
+	github: {
+		lane: "composio",
+		workload: "core",
+		preferred: true
+	},
+	linear: {
+		lane: "composio",
+		workload: "core",
+		preferred: true
+	},
+	jira: {
+		lane: "composio",
+		workload: "core",
+		preferred: true
+	},
+	outlook: {
+		lane: "composio",
+		workload: "core",
+		preferred: true
+	},
+	microsoft_teams: {
+		lane: "composio",
+		workload: "core",
+		preferred: true
+	},
+	one_drive: {
+		lane: "composio",
+		workload: "core",
+		preferred: true
+	},
+	telegram: {
+		lane: "native",
+		workload: "core",
+		preferred: false,
+		alternative: {
+			kind: "channel",
+			id: "telegram"
+		}
 	}
-} };
+};
 function composioIntegrationStrategy(toolkit) {
 	return COMPOSIO_STRATEGY_OVERRIDES[toolkit.trim().toLowerCase()] ?? {
 		lane: "composio",

package/dist/src/connectors/memory-sync-coordinator.d.ts

@@ -0,0 +1,28 @@
+import type { Config } from '../config/schema.js';
+import { syncComposioResultToMemory, syncLocalFolderToMemory } from './connector-memory-sync.js';
+export type ConnectorMemorySyncCoordinator = {
+    runNow(options?: {
+        toolkit?: string;
+        force?: boolean;
+    }): Promise<void>;
+    stop(): void;
+};
+export declare function syncDueMemorySources(options: {
+    config: Config;
+    agentId: string;
+    nowMs?: number;
+    toolkit?: string;
+    force?: boolean;
+    syncLocalSource?: typeof syncLocalFolderToMemory;
+    syncComposioSource?: typeof syncComposioResultToMemory;
+}): Promise<{
+    eligible: number;
+    synced: number;
+    failed: number;
+}>;
+export declare function startConnectorMemorySyncCoordinator(options: {
+    getConfig: () => Config;
+    resolveAgentId: () => string;
+    intervalMs?: number;
+    initialDelayMs?: number;
+}): ConnectorMemorySyncCoordinator;

package/dist/src/connectors/memory-sync-coordinator.js

@@ -0,0 +1,162 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { listKnowledgeSyncRuns } from "../storage/sqlite/knowledge-repository.js";
+import { listConnectorConnections } from "../storage/sqlite/connector-repository.js";
+import "../storage/sqlite/index.js";
+import { getConnectorDefinition } from "./catalog.js";
+import { listConnectorInstances } from "./instances.js";
+import { syncComposioResultToMemory, syncLocalFolderToMemory } from "./connector-memory-sync.js";
+import { getComposioMemorySyncProfile } from "./memory-sync-profile.js";
+//#region src/connectors/memory-sync-coordinator.ts
+init_logger();
+const log = createLogger("ConnectorMemorySync");
+const DEFAULT_SYNC_INTERVAL_MINUTES = 15;
+async function syncDueMemorySources(options) {
+	const nowMs = options.nowMs ?? Date.now();
+	const syncLocalSource = options.syncLocalSource ?? syncLocalFolderToMemory;
+	const syncComposioSource = options.syncComposioSource ?? syncComposioResultToMemory;
+	let eligible = 0;
+	let synced = 0;
+	let failed = 0;
+	for (const instance of listConnectorInstances(options.config)) {
+		if (!instance.enabled) continue;
+		const definition = getConnectorDefinition(instance.connectorId);
+		if (definition?.runtime.type === "memorySource" && definition.runtime.sourceKind === "local-folder") {
+			if (options.toolkit || instance.config?.autoSync === false) continue;
+			eligible += 1;
+			const configuredMinutes = Number(instance.config?.syncIntervalMinutes ?? DEFAULT_SYNC_INTERVAL_MINUTES);
+			const intervalMinutes = Number.isFinite(configuredMinutes) ? Math.max(5, Math.min(configuredMinutes, 1440)) : DEFAULT_SYNC_INTERVAL_MINUTES;
+			const sourceInstanceId = `local-folder:${definition.id}`;
+			const latestRun = listKnowledgeSyncRuns({
+				sourceInstanceId,
+				limit: 1
+			})[0];
+			if (!options.force && latestRun && nowMs - Date.parse(latestRun.startedAt) < intervalMinutes * 6e4) continue;
+			try {
+				await syncLocalSource({
+					config: options.config,
+					connectorId: definition.id,
+					agentId: options.agentId
+				});
+				synced += 1;
+			} catch (err) {
+				failed += 1;
+				const errorMessage = err instanceof Error ? err.message : String(err);
+				log.warn({
+					err,
+					connectorId: definition.id,
+					sourceInstanceId
+				}, `Automatic connector memory sync failed: ${errorMessage}`);
+			}
+			continue;
+		}
+		if (definition?.runtime.type !== "composio" || definition.runtime.role !== "toolkit") continue;
+		if (options.toolkit && definition.runtime.toolkit !== options.toolkit) continue;
+		const profile = getComposioMemorySyncProfile(options.config, definition.id);
+		if (!profile?.enabled || options.force && options.toolkit && !profile.triggerSync) continue;
+		eligible += 1;
+		const activeConnections = listConnectorConnections({ connectorId: definition.id }).filter((candidate) => candidate.status === "active");
+		const connection = profile.connectionId ? activeConnections.find((candidate) => candidate.id === profile.connectionId) : activeConnections.find((candidate) => candidate.isDefault) ?? activeConnections[0];
+		if (!connection) continue;
+		const sourceInstanceId = `composio:${definition.id}:${connection.id}`;
+		const latestRun = listKnowledgeSyncRuns({
+			sourceInstanceId,
+			limit: 1
+		})[0];
+		if (!options.force && latestRun && nowMs - Date.parse(latestRun.startedAt) < profile.intervalMinutes * 6e4) continue;
+		try {
+			await syncComposioSource({
+				config: options.config,
+				connectorId: definition.id,
+				actionId: profile.actionId,
+				arguments: profile.arguments,
+				agentId: profile.agentId,
+				connectionId: connection.id
+			});
+			synced += 1;
+		} catch (err) {
+			failed += 1;
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			log.warn({
+				err,
+				connectorId: definition.id,
+				sourceInstanceId
+			}, `Automatic Composio memory sync failed: ${errorMessage}`);
+		}
+	}
+	return {
+		eligible,
+		synced,
+		failed
+	};
+}
+function startConnectorMemorySyncCoordinator(options) {
+	const intervalMs = Math.max(1e4, Math.min(options.intervalMs ?? 6e4, 30 * 6e4));
+	let timer = null;
+	let running = false;
+	let stopped = false;
+	let pendingAll = false;
+	let pendingForce = false;
+	const pendingToolkits = /* @__PURE__ */ new Set();
+	async function runNow(runOptions) {
+		if (stopped) return;
+		if (running) {
+			if (runOptions?.toolkit) pendingToolkits.add(runOptions.toolkit);
+			else pendingAll = true;
+			pendingForce ||= runOptions?.force === true;
+			return;
+		}
+		running = true;
+		try {
+			const result = await syncDueMemorySources({
+				config: options.getConfig(),
+				agentId: options.resolveAgentId(),
+				toolkit: runOptions?.toolkit,
+				force: runOptions?.force
+			});
+			if (result.synced > 0 || result.failed > 0) log.info(result, "Automatic connector memory sync cycle completed");
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			log.warn({ err }, `Automatic connector memory sync cycle failed: ${errorMessage}`);
+		} finally {
+			running = false;
+			if (!stopped && (pendingAll || pendingToolkits.size > 0)) {
+				const runAll = pendingAll;
+				const force = pendingForce;
+				const toolkits = [...pendingToolkits];
+				pendingAll = false;
+				pendingForce = false;
+				pendingToolkits.clear();
+				queueMicrotask(() => {
+					if (runAll) runNow({ force });
+					else toolkits.reduce(async (previous, toolkit) => {
+						await previous;
+						await runNow({
+							toolkit,
+							force
+						});
+					}, Promise.resolve());
+				});
+			}
+		}
+	}
+	timer = setTimeout(() => {
+		runNow();
+		timer = setInterval(() => void runNow(), intervalMs);
+		timer.unref?.();
+	}, Math.max(0, options.initialDelayMs ?? 1e4));
+	timer.unref?.();
+	return {
+		runNow,
+		stop() {
+			stopped = true;
+			if (timer) {
+				clearTimeout(timer);
+				clearInterval(timer);
+				timer = null;
+			}
+		}
+	};
+}
+//#endregion
+export { startConnectorMemorySyncCoordinator, syncDueMemorySources };

package/dist/src/connectors/memory-sync-profile.d.ts

@@ -0,0 +1,13 @@
+import type { Config } from '../config/schema.js';
+export type ComposioMemorySyncProfile = {
+    enabled: boolean;
+    actionId: string;
+    arguments: Record<string, unknown>;
+    agentId: string;
+    connectionId?: string;
+    intervalMinutes: number;
+    triggerSync: boolean;
+    updatedAt: string;
+};
+export declare function getComposioMemorySyncProfile(config: Config, connectorId: string): ComposioMemorySyncProfile | undefined;
+export declare function updateComposioMemorySyncProfile(config: Config, connectorId: string, input: Omit<ComposioMemorySyncProfile, 'updatedAt'>): ComposioMemorySyncProfile;

package/dist/src/connectors/memory-sync-profile.js

@@ -0,0 +1,73 @@
+import { scopeForComposioAction } from "./composio.js";
+import { getConnectorDefinition } from "./catalog.js";
+import { COMPOSIO_MEMORY_SOURCE_TOOLKITS } from "./connector-memory-sync.js";
+//#region src/connectors/memory-sync-profile.ts
+const SENSITIVE_ARGUMENT_KEY = /(?:api[-_]?key|authorization|cookie|password|secret|token)/i;
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function assertNoPersistedSecrets(value, depth = 0) {
+	if (depth > 12) throw new Error("Memory sync arguments are nested too deeply.");
+	if (Array.isArray(value)) {
+		for (const item of value) assertNoPersistedSecrets(item, depth + 1);
+		return;
+	}
+	const record = asRecord(value);
+	if (!record) return;
+	for (const [key, nested] of Object.entries(record)) {
+		if (SENSITIVE_ARGUMENT_KEY.test(key)) throw new Error(`Memory sync arguments cannot persist sensitive field "${key}".`);
+		assertNoPersistedSecrets(nested, depth + 1);
+	}
+}
+function markerFor(config, connectorId) {
+	return asRecord(config.connectors?.instances?.[connectorId]?.xopcConnector);
+}
+function getComposioMemorySyncProfile(config, connectorId) {
+	const raw = asRecord(asRecord(markerFor(config, connectorId)?.config)?.memorySync);
+	if (!raw) return void 0;
+	const actionId = typeof raw.actionId === "string" ? raw.actionId.trim() : "";
+	const agentId = typeof raw.agentId === "string" ? raw.agentId.trim() : "";
+	if (!actionId || !agentId) return void 0;
+	const interval = Number(raw.intervalMinutes);
+	return {
+		enabled: raw.enabled === true,
+		actionId,
+		arguments: asRecord(raw.arguments) ?? {},
+		agentId,
+		connectionId: typeof raw.connectionId === "string" && raw.connectionId.trim() ? raw.connectionId.trim() : void 0,
+		intervalMinutes: Number.isFinite(interval) ? Math.max(5, Math.min(interval, 1440)) : 15,
+		triggerSync: raw.triggerSync !== false,
+		updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : (/* @__PURE__ */ new Date(0)).toISOString()
+	};
+}
+function updateComposioMemorySyncProfile(config, connectorId, input) {
+	const definition = getConnectorDefinition(connectorId);
+	if (definition?.runtime.type !== "composio" || definition.runtime.role !== "toolkit") throw new Error("Memory sync profiles require an installed Composio toolkit connector.");
+	const toolkit = definition.runtime.toolkit;
+	if (!COMPOSIO_MEMORY_SOURCE_TOOLKITS.has(toolkit)) throw new Error(`Memory sync is not supported for the ${toolkit} connector.`);
+	const marker = markerFor(config, connectorId);
+	if (!marker || marker.managed !== true || marker.enabled === false) throw new Error(`Connector is not installed and enabled: ${connectorId}`);
+	const actionId = input.actionId.trim();
+	const agentId = input.agentId.trim();
+	const risk = scopeForComposioAction(actionId);
+	if (!actionId || risk.toolkit !== toolkit || risk.scope !== "read" || !risk.curated) throw new Error("Memory sync profiles require a curated read-only action from the same toolkit.");
+	if (!agentId) throw new Error("Memory sync profile requires an agentId.");
+	assertNoPersistedSecrets(input.arguments);
+	const profile = {
+		enabled: input.enabled,
+		actionId,
+		arguments: structuredClone(input.arguments),
+		agentId,
+		connectionId: input.connectionId?.trim() || void 0,
+		intervalMinutes: Math.max(5, Math.min(Number(input.intervalMinutes) || 15, 1440)),
+		triggerSync: input.triggerSync,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	marker.config = {
+		...asRecord(marker.config) ?? {},
+		memorySync: profile
+	};
+	return profile;
+}
+//#endregion
+export { getComposioMemorySyncProfile, updateComposioMemorySyncProfile };

package/dist/src/connectors/runtime-adapter-registry.js

@@ -18,7 +18,7 @@ function installedInstance(config, instanceId, connectorId) {
 	if (!instance) throw new Error(`Connector "${connectorId}" was installed but could not be resolved.`);
 	return instance;
 }
-function installRecord(config, definition, extra = {}) {
+function installRecord(config, definition, extra = {}, markerExtra = {}) {
 	const instanceId = definition.id;
 	config.connectors = config.connectors ?? {};
 	config.connectors.instances = {
@@ -31,7 +31,8 @@ function installRecord(config, definition, extra = {}) {
 				enabled: true,
 				displayName: definition.displayName,
 				source: definition.source,
-				artifactSha256: definition.provenance?.sha256
+				artifactSha256: definition.provenance?.sha256,
+				...markerExtra
 			},
 			runtime: definition.runtime,
 			...extra
@@ -136,11 +137,23 @@ for (const type of [
 	"memorySource"
 ]) registerConnectorRuntimeAdapter({
 	type,
-	async install({ config, definition }) {
-		return installRecord(config, definition);
+	async install({ config, definition, input }) {
+		return installRecord(config, definition, {}, { config: input.config ?? {} });
 	},
 	uninstall({ config, instance }) {
 		uninstallRecord(config, instance.instanceId);
+	},
+	update({ config, definition, input, instanceId }) {
+		const record = config.connectors?.instances?.[instanceId];
+		const marker = record?.xopcConnector;
+		if (!marker || typeof marker !== "object" || Array.isArray(marker)) throw new Error(`Connector instance not found: ${instanceId}`);
+		const markerRecord = marker;
+		if (markerRecord.managed !== true) throw new Error(`Connector instance not found: ${instanceId}`);
+		record.xopcConnector = {
+			...markerRecord,
+			config: input.config ?? {}
+		};
+		return installedInstance(config, instanceId, definition.id);
 	}
 });
 function getConnectorRuntimeAdapter(type) {