@xopcai/xopc 0.0.156 → 0.0.158

package/dist/src/connectors/runtime-status.d.ts

@@ -0,0 +1,9 @@
+import type { ConnectorConnection, ConnectorInstance } from './types.js';
+export type ComposioRuntimeProbe = {
+    connectorId: string;
+    checkedAt: string;
+    toolCount?: number;
+    error?: string;
+    connectionError?: boolean;
+};
+export declare function projectComposioRuntimeStatus(instances: ConnectorInstance[], connections: ConnectorConnection[], probes: ComposioRuntimeProbe[]): ConnectorInstance[];

package/dist/src/connectors/runtime-status.js

@@ -0,0 +1,68 @@
+//#region src/connectors/runtime-status.ts
+function projectComposioRuntimeStatus(instances, connections, probes) {
+	const probeByConnectorId = new Map(probes.map((probe) => [probe.connectorId, probe]));
+	return instances.map((instance) => {
+		if (instance.materialized.type !== "composio" || instance.materialized.role !== "toolkit" || !instance.enabled) return instance;
+		const relevant = connections.filter((connection) => connection.provider === "composio" && connection.connectorId === instance.connectorId && connection.status !== "revoked");
+		const active = relevant.filter((connection) => connection.status === "active");
+		const probe = probeByConnectorId.get(instance.connectorId);
+		const lastConnectedAt = active.flatMap((connection) => connection.connectedAt ? [connection.connectedAt] : []).sort().at(-1) ?? instance.lastConnectedAt;
+		if (active.length > 0 && probe && !probe.error && (probe.toolCount ?? 0) > 0) return {
+			...instance,
+			status: "connected",
+			connectionStatus: "connected",
+			authStatus: "connected",
+			lastConnectedAt,
+			lastError: void 0,
+			usage: {
+				...instance.usage,
+				lastHealthCheckAt: probe.checkedAt,
+				lastHealthStatus: "ok",
+				lastToolCount: probe.toolCount
+			}
+		};
+		if (active.length > 0 && probe) {
+			const error = probe.error ?? "The connection did not expose any usable tools.";
+			return {
+				...instance,
+				status: "degraded",
+				connectionStatus: probe.connectionError ? "error" : "connected",
+				authStatus: "connected",
+				lastConnectedAt,
+				lastError: error,
+				usage: {
+					...instance.usage,
+					lastHealthCheckAt: probe.checkedAt,
+					lastHealthStatus: probe.connectionError ? "network_failed" : "tools_list_failed",
+					lastToolCount: probe.toolCount ?? 0
+				}
+			};
+		}
+		if (relevant.some((connection) => connection.status === "pending")) return {
+			...instance,
+			status: "connecting",
+			connectionStatus: "connecting",
+			authStatus: "unknown"
+		};
+		if (relevant.some((connection) => connection.status === "expired")) return {
+			...instance,
+			status: "unauthorized",
+			connectionStatus: "unauthorized",
+			authStatus: "expired"
+		};
+		if (relevant.some((connection) => connection.status === "failed")) return {
+			...instance,
+			status: "failed",
+			connectionStatus: "error",
+			authStatus: "unauthorized"
+		};
+		return {
+			...instance,
+			status: "not_configured",
+			connectionStatus: "disconnected",
+			authStatus: "missing"
+		};
+	});
+}
+//#endregion
+export { projectComposioRuntimeStatus };

package/dist/src/connectors/types.d.ts

@@ -12,6 +12,7 @@ export type ConnectorAuthDefinition = {
 };
 export type ConnectorScope = 'read' | 'write' | 'admin';
 export type ConnectorVerificationLevel = 'verified' | 'beta' | 'experimental';
+export type ConnectorBenefit = 'understand' | 'act' | 'reach';
 export type ConnectorBranding = {
     logoUrl?: string;
     source?: 'builtin' | 'composio-catalog' | 'registry' | 'extension' | 'custom';
@@ -88,6 +89,7 @@ export type ConnectorDefinition = {
     kind: ConnectorKind;
     source: 'builtin' | 'extension' | 'custom' | 'registry' | 'store';
     capabilities: ConnectorCapability[];
+    benefits?: ConnectorBenefit[];
     tags?: string[];
     branding?: ConnectorBranding;
     verificationLevel?: ConnectorVerificationLevel;

package/dist/src/gateway/hono/routes/connectors.js

@@ -1,8 +1,10 @@
-import { decideConnectorApproval, getConnectorApproval, listConnectorApprovals } from "../../../storage/sqlite/connector-repository.js";
+import { decideConnectorApproval, getConnectorApproval, listConnectorApprovals, listConnectorConnections } from "../../../storage/sqlite/connector-repository.js";
 import "../../../storage/sqlite/index.js";
+import { init_agent_scope, resolveDefaultAgentId } from "../../../agent/agent-scope.js";
+import { resolveComposioApiKey } from "../../../connectors/composio-sessions.js";
 import { listComposioConnectorCatalog } from "../../../connectors/composio-catalog.js";
 import { createConnectorSetupSecretRequest, submitConnectorSetupSecret } from "../../../connectors/setup-secrets.js";
-import { executeComposioTool, getComposioInstallationPolicy, getComposioToolkitScope, inspectComposioConnectorHealth, listComposioConnections, listComposioTools, refreshComposioConnection, revokeComposioConnection, setComposioToolkitScope, updateComposioConnection, updateComposioInstallationPolicy } from "../../../connectors/composio.js";
+import { configureComposioApiKey, executeComposioTool, getComposioInstallationPolicy, getComposioToolkitScope, inspectComposioConnectorHealth, listComposioConnections, listComposioTools, refreshComposioConnection, revokeComposioConnection, setComposioToolkitScope, updateComposioConnection, updateComposioInstallationPolicy } from "../../../connectors/composio.js";
 import { listConnectorProviders } from "../../../connectors/providers.js";
 import { getConnectorDefinition, listConnectorCatalog } from "../../../connectors/catalog.js";
 import { recordConnectorHealthUsage } from "../../../connectors/usage.js";
@@ -11,11 +13,15 @@ import { installConnector, installConnectorDefinition, uninstallConnector, updat
 import { startConnectorAuthorization } from "../../../connectors/auth-provider-registry.js";
 import { composioLogoResponse } from "../../../connectors/composio-logo.js";
 import { appendComposioTriggerEvent, listComposioTriggerEvents } from "../../../connectors/composio-triggers.js";
-import { syncComposioResultToMemory } from "../../../connectors/connector-memory-sync.js";
+import { buildConnectedPeopleGraph } from "../../../knowledge/people-graph.js";
+import "../../../knowledge/index.js";
+import { syncComposioResultToMemory, syncLocalFolderToMemory } from "../../../connectors/connector-memory-sync.js";
 import { previewConnectorDefinition, testConnectorInstance } from "../../../connectors/health.js";
 import { setConnectorEnabled } from "../../../connectors/lifecycle.js";
-import { isConnectorRegistrySource, listConnectorRegistries, searchConnectorRegistries } from "../../../connectors/registries/search.js";
+import { getComposioMemorySyncProfile, updateComposioMemorySyncProfile } from "../../../connectors/memory-sync-profile.js";
+import { projectComposioRuntimeStatus } from "../../../connectors/runtime-status.js";
 //#region src/gateway/hono/routes/connectors.ts
+init_agent_scope();
 function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
@@ -29,34 +35,49 @@ function registerConnectorRoutes(authenticated, deps) {
 				providers: listConnectorProviders().map((provider) => ({
 					id: provider.id,
 					displayName: provider.displayName
-				})),
-				registries: listConnectorRegistries()
+				}))
 			}
 		});
 	});
-	authenticated.get("/api/connectors/installed", (c) => {
+	authenticated.get("/api/connectors/installed", async (c) => {
 		const config = service.currentConfig;
-		return c.json({
+		const instances = listConnectorInstances(config);
+		const composioInstances = instances.filter((instance) => instance.materialized.type === "composio" && instance.materialized.role === "toolkit");
+		if (composioInstances.length === 0) return c.json({
 			ok: true,
-			payload: { instances: listConnectorInstances(config) }
-		});
-	});
-	authenticated.get("/api/connectors/registry/search", async (c) => {
-		const query = c.req.query("q") ?? c.req.query("query") ?? "";
-		const sourceParam = c.req.query("source") ?? "all";
-		const results = await searchConnectorRegistries({
-			query,
-			source: sourceParam !== "all" && isConnectorRegistrySource(sourceParam) ? sourceParam : "all",
-			page: Number(c.req.query("page") ?? "1"),
-			pageSize: Number(c.req.query("pageSize") ?? "24"),
-			browse: c.req.query("browse") === "1" || c.req.query("browse") === "true"
+			payload: { instances }
 		});
+		const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+		let connectionError;
+		try {
+			await listComposioConnections();
+		} catch (error) {
+			connectionError = errorMessage(error);
+		}
+		const probes = await Promise.all([...new Map(composioInstances.map((instance) => [instance.connectorId, instance])).values()].map(async (instance) => {
+			try {
+				const tools = await listComposioTools(instance.materialized.type === "composio" ? instance.materialized.toolkit : "", config);
+				return {
+					connectorId: instance.connectorId,
+					checkedAt,
+					toolCount: tools.length,
+					...connectionError ? {
+						error: connectionError,
+						connectionError: true
+					} : {}
+				};
+			} catch (error) {
+				return {
+					connectorId: instance.connectorId,
+					checkedAt,
+					error: errorMessage(error)
+				};
+			}
+		}));
+		const connections = listConnectorConnections({ principalId: "local-owner" });
 		return c.json({
 			ok: true,
-			payload: {
-				results,
-				connectors: results.flatMap((result) => result.connectors)
-			}
+			payload: { instances: projectComposioRuntimeStatus(instances, connections, probes) }
 		});
 	});
 	authenticated.post("/api/connectors/setup/request-secret", strictRateLimitMiddleware, async (c) => {
@@ -147,9 +168,17 @@ function registerConnectorRoutes(authenticated, deps) {
 	authenticated.get("/api/connectors/composio/catalog", async (c) => {
 		try {
 			const refresh = c.req.query("refresh") === "1" || c.req.query("refresh") === "true";
+			const verificationParam = c.req.query("verification");
+			const verification = verificationParam === "verified" || verificationParam === "experimental" ? verificationParam : "all";
 			return c.json({
 				ok: true,
-				payload: await listComposioConnectorCatalog({ refresh })
+				payload: await listComposioConnectorCatalog({
+					refresh,
+					verification,
+					query: c.req.query("q") ?? "",
+					page: Number(c.req.query("page") ?? "1"),
+					pageSize: Number(c.req.query("pageSize") ?? "24")
+				})
 			});
 		} catch (error) {
 			return c.json({
@@ -246,6 +275,7 @@ function registerConnectorRoutes(authenticated, deps) {
 		const body = await c.req.json().catch(() => ({}));
 		try {
 			const event = await appendComposioTriggerEvent(service.currentConfig, body);
+			service.requestConnectorMemorySync(event.toolkit);
 			return c.json({
 				ok: true,
 				payload: { event }
@@ -272,6 +302,54 @@ function registerConnectorRoutes(authenticated, deps) {
 			}, 400);
 		}
 	});
+	authenticated.get("/api/connectors/people", (c) => {
+		const query = c.req.query("q") ?? "";
+		const limit = Number(c.req.query("limit") ?? "100");
+		return c.json({
+			ok: true,
+			payload: buildConnectedPeopleGraph({
+				query,
+				limit
+			})
+		});
+	});
+	authenticated.get("/api/connectors/:id/memory-sync-profile", (c) => {
+		const profile = getComposioMemorySyncProfile(service.currentConfig, c.req.param("id"));
+		return c.json({
+			ok: true,
+			payload: { profile: profile ?? null }
+		});
+	});
+	authenticated.patch("/api/connectors/:id/memory-sync-profile", strictRateLimitMiddleware, async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		const row = body && typeof body === "object" && !Array.isArray(body) ? body : {};
+		try {
+			const config = service.currentConfig;
+			const profile = updateComposioMemorySyncProfile(config, c.req.param("id"), {
+				enabled: row.enabled === true,
+				actionId: typeof row.actionId === "string" ? row.actionId : "",
+				arguments: row.arguments && typeof row.arguments === "object" && !Array.isArray(row.arguments) ? row.arguments : {},
+				agentId: typeof row.agentId === "string" ? row.agentId : "",
+				connectionId: typeof row.connectionId === "string" ? row.connectionId : void 0,
+				intervalMinutes: Number(row.intervalMinutes),
+				triggerSync: row.triggerSync !== false
+			});
+			const saved = await service.saveConfig(config);
+			if (!saved.saved) return c.json({
+				ok: false,
+				error: saved.error
+			}, 500);
+			return c.json({
+				ok: true,
+				payload: { profile }
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: errorMessage(error)
+			}, 400);
+		}
+	});
 	authenticated.get("/api/connectors/:id", (c) => {
 		const connectorId = c.req.param("id");
 		const connector = getConnectorDefinition(connectorId);
@@ -321,15 +399,28 @@ function registerConnectorRoutes(authenticated, deps) {
 		const body = await c.req.json().catch(() => ({}));
 		const row = body && typeof body === "object" && !Array.isArray(body) ? body : {};
 		const actionId = typeof row.actionId === "string" ? row.actionId.trim() : "";
-		const agentId = typeof row.agentId === "string" ? row.agentId.trim() : "";
-		if (!actionId || !agentId) return c.json({
-			ok: false,
-			error: "actionId and agentId are required."
-		}, 400);
+		const config = service.currentConfig;
+		const agentId = typeof row.agentId === "string" && row.agentId.trim() ? row.agentId.trim() : resolveDefaultAgentId(config);
 		try {
+			const connectorId = c.req.param("id");
+			if (getConnectorDefinition(connectorId)?.runtime.type === "memorySource") {
+				const result = await syncLocalFolderToMemory({
+					config,
+					connectorId,
+					agentId
+				});
+				return c.json({
+					ok: true,
+					payload: result
+				});
+			}
+			if (!actionId) return c.json({
+				ok: false,
+				error: "actionId is required for Composio memory sync."
+			}, 400);
 			const result = await syncComposioResultToMemory({
-				config: service.currentConfig,
-				connectorId: c.req.param("id"),
+				config,
+				connectorId,
 				actionId,
 				agentId,
 				connectionId: typeof row.connectionId === "string" ? row.connectionId : void 0,
@@ -463,6 +554,29 @@ function registerConnectorRoutes(authenticated, deps) {
 			}, 400);
 		}
 	});
+	authenticated.get("/api/connectors/composio/setup-status", async (c) => {
+		const configured = Boolean(await resolveComposioApiKey());
+		return c.json({
+			ok: true,
+			payload: { configured }
+		});
+	});
+	authenticated.post("/api/connectors/composio/setup", strictRateLimitMiddleware, async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		const apiKey = body && typeof body === "object" && !Array.isArray(body) ? String(body.apiKey ?? "") : "";
+		try {
+			await configureComposioApiKey(apiKey);
+			return c.json({
+				ok: true,
+				payload: { configured: true }
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: errorMessage(error)
+			}, 400);
+		}
+	});
 	authenticated.post("/api/connectors/:id/install", strictRateLimitMiddleware, async (c) => {
 		const connectorId = c.req.param("id");
 		const body = await c.req.json().catch(() => ({}));

package/dist/src/gateway/hono/routes/public-gateway.js

@@ -70,6 +70,7 @@ function registerPublicGatewayRoutes(app, service) {
 			const normalized = normalizeComposioTriggerPayload(archivedPayload, webhookId);
 			applyComposioConnectionLifecycleEvent(archivedPayload);
 			const event = await appendComposioTriggerEvent(service.currentConfig, archivedPayload);
+			service.requestConnectorMemorySync(normalized.toolkit);
 			const runs = await service.automationServiceInstance.triggerEvent({
 				type: `connector.${normalized.trigger ?? normalized.type}`,
 				source: normalized.toolkit ? `composio:${normalized.toolkit}` : "composio",

package/dist/src/gateway/service.d.ts

@@ -57,6 +57,7 @@ export declare class GatewayService {
     private goalNotifications;
     private mobileNotifications;
     private connectorSupervisor;
+    private connectorMemorySyncCoordinator;
     private connectedKnowledgeCoordinator;
     private stopAutomationProductEventBridge;
     private stopSessionTranscriptAutomationEvents;
@@ -199,6 +200,7 @@ export declare class GatewayService {
     requestHeartbeatNow(opts?: {
         reason?: string;
     }): void;
+    requestConnectorMemorySync(toolkit?: string): void;
     /**
      * Register graceful shutdown used after spawning a replacement gateway process (foreground CLI server).
      */

package/dist/src/gateway/service.js

@@ -44,6 +44,7 @@ import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import "../config/index.js";
 import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
 import "../knowledge/index.js";
+import { startConnectorMemorySyncCoordinator } from "../connectors/memory-sync-coordinator.js";
 import { startConnectorSupervisor } from "../connectors/supervisor.js";
 import { assertGatewayAuthConfigured, extractToken, resolveGatewayAuth, validateToken } from "./auth.js";
 import { reconcileDreamingAutomations } from "./dreaming-automation-reconciler.js";
@@ -136,6 +137,7 @@ var GatewayService = class {
 	goalNotifications = null;
 	mobileNotifications = null;
 	connectorSupervisor = null;
+	connectorMemorySyncCoordinator = null;
 	connectedKnowledgeCoordinator = null;
 	stopAutomationProductEventBridge = null;
 	stopSessionTranscriptAutomationEvents = null;
@@ -683,6 +685,10 @@ var GatewayService = class {
 			getConfig: () => this.config,
 			saveConfig: (cfg) => this.saveConfig(cfg)
 		});
+		this.connectorMemorySyncCoordinator = startConnectorMemorySyncCoordinator({
+			getConfig: () => this.config,
+			resolveAgentId: () => resolveDefaultAgentId(this.config)
+		});
 		this.connectedKnowledgeCoordinator = startConnectedKnowledgeCoordinator({ resolvePipelineOptions: () => ({
 			agentId: resolveDefaultAgentId(this.config),
 			workspaceId: this.currentWorkspacePath
@@ -806,6 +812,8 @@ var GatewayService = class {
 		this.heartbeatService?.stop();
 		this.connectorSupervisor?.stop();
 		this.connectorSupervisor = null;
+		this.connectorMemorySyncCoordinator?.stop();
+		this.connectorMemorySyncCoordinator = null;
 		this.connectedKnowledgeCoordinator?.stop();
 		this.connectedKnowledgeCoordinator = null;
 		if (this.browserExtensionRelease) {
@@ -1045,6 +1053,12 @@ var GatewayService = class {
 	requestHeartbeatNow(opts) {
 		this.heartbeatService?.requestNow({ reason: opts?.reason ?? "manual" });
 	}
+	requestConnectorMemorySync(toolkit) {
+		this.connectorMemorySyncCoordinator?.runNow({
+			toolkit,
+			force: true
+		});
+	}
 	/**
 	* Register graceful shutdown used after spawning a replacement gateway process (foreground CLI server).
 	*/

package/dist/src/knowledge/index.d.ts

@@ -2,3 +2,5 @@ export * from './types.js';
 export * from './ingestion-service.js';
 export * from './connected-knowledge-pipeline.js';
 export * from './coordinator.js';
+export * from './local-folder-adapter.js';
+export * from './people-graph.js';

package/dist/src/knowledge/index.js

@@ -1,4 +1,6 @@
 import { KnowledgeIngestionService, SqliteKnowledgeSourceStateStore } from "./ingestion-service.js";
 import { ConnectedKnowledgePipeline } from "./connected-knowledge-pipeline.js";
 import { startConnectedKnowledgeCoordinator } from "./coordinator.js";
-export { ConnectedKnowledgePipeline, KnowledgeIngestionService, SqliteKnowledgeSourceStateStore, startConnectedKnowledgeCoordinator };
+import { LocalFolderKnowledgeSourceAdapter } from "./local-folder-adapter.js";
+import { buildConnectedPeopleGraph } from "./people-graph.js";
+export { ConnectedKnowledgePipeline, KnowledgeIngestionService, LocalFolderKnowledgeSourceAdapter, SqliteKnowledgeSourceStateStore, buildConnectedPeopleGraph, startConnectedKnowledgeCoordinator };

package/dist/src/knowledge/ingestion-service.js

@@ -1,9 +1,44 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { finishKnowledgeSyncRun, getKnowledgeSourceCursor, setKnowledgeSourceCursor, startKnowledgeSyncRun, upsertKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
+import { finishKnowledgeSyncRun, getKnowledgeSourceCursor, listKnowledgeSourceItems, setKnowledgeSourceCursor, startKnowledgeSyncRun, upsertKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
 //#region src/knowledge/ingestion-service.ts
 init_logger();
 const log = createLogger("KnowledgeIngestion");
+function deletionInputs(instanceId, snapshotExternalIds) {
+	if (!snapshotExternalIds) return [];
+	const seen = new Set(snapshotExternalIds);
+	const deletedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const missing = [];
+	for (let offset = 0;; offset += 500) {
+		const page = listKnowledgeSourceItems({
+			sourceInstanceId: instanceId,
+			limit: 500,
+			offset
+		});
+		for (const item of page) {
+			if (seen.has(item.externalId)) continue;
+			missing.push({
+				id: item.id,
+				sourceInstanceId: item.sourceInstanceId,
+				externalId: item.externalId,
+				itemType: item.itemType,
+				authorRole: item.authorRole,
+				occurredAt: item.occurredAt,
+				sourceUpdatedAt: item.sourceUpdatedAt,
+				contentHash: item.contentHash,
+				normalizedText: item.normalizedText,
+				payloadRef: item.payloadRef,
+				metadata: item.metadata,
+				sensitivity: item.sensitivity,
+				retentionClass: item.retentionClass,
+				synthesisPipeline: item.synthesisPipeline,
+				deletedAt
+			});
+		}
+		if (page.length < 500) break;
+	}
+	return missing;
+}
 var SqliteKnowledgeSourceStateStore = class {
 	getCursor(instanceId) {
 		return getKnowledgeSourceCursor(instanceId);
@@ -62,7 +97,8 @@ var KnowledgeIngestionService = class {
 				windowStart: params.windowStart,
 				signal
 			});
-			const stored = upsertKnowledgeSourceItems(pulled.items);
+			const tombstones = deletionInputs(params.instanceId, pulled.snapshotExternalIds);
+			const stored = upsertKnowledgeSourceItems([...pulled.items, ...tombstones]);
 			this.state.setCursor(params.instanceId, pulled.nextCursor);
 			const completed = finishKnowledgeSyncRun({
 				runId: run.id,
@@ -78,7 +114,8 @@ var KnowledgeIngestionService = class {
 				sourceInstanceId: params.instanceId,
 				itemsSeen: pulled.items.length,
 				itemsCreated: stored.created,
-				itemsUpdated: stored.updated
+				itemsUpdated: stored.updated,
+				itemsDeleted: tombstones.length
 			}, "Knowledge source sync completed");
 			return completed;
 		} catch (err) {

package/dist/src/knowledge/local-folder-adapter.d.ts

@@ -0,0 +1,7 @@
+import type { KnowledgePullInput, KnowledgePullResult, KnowledgeSourceAdapter } from './types.js';
+export declare class LocalFolderKnowledgeSourceAdapter implements KnowledgeSourceAdapter {
+    private readonly rootPath;
+    readonly kind = "local-folder";
+    constructor(rootPath: string);
+    pull(input: KnowledgePullInput): Promise<KnowledgePullResult>;
+}

package/dist/src/knowledge/local-folder-adapter.js

@@ -0,0 +1,86 @@
+import { extname, relative, resolve, sep } from "node:path";
+import { createHash } from "node:crypto";
+import { readFile, readdir, realpath, stat } from "node:fs/promises";
+//#region src/knowledge/local-folder-adapter.ts
+const SUPPORTED_EXTENSIONS = new Set([
+	".md",
+	".mdx",
+	".txt",
+	".json",
+	".yaml",
+	".yml",
+	".csv",
+	".tsv"
+]);
+const IGNORED_DIRECTORIES = new Set([
+	".git",
+	".svn",
+	"node_modules"
+]);
+const MAX_FILES = 2e3;
+const MAX_FILE_BYTES = 2 * 1024 * 1024;
+var LocalFolderKnowledgeSourceAdapter = class {
+	kind = "local-folder";
+	constructor(rootPath) {
+		this.rootPath = rootPath;
+	}
+	async pull(input) {
+		const scanStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const root = await realpath(resolve(this.rootPath));
+		if (!(await stat(root)).isDirectory()) throw new Error(`Local knowledge source is not a directory: ${root}`);
+		const cursorMs = input.cursor ? Date.parse(input.cursor) : NaN;
+		const windowMs = input.windowStart ? Date.parse(input.windowStart) : NaN;
+		const changedAfter = Math.max(Number.isFinite(cursorMs) ? cursorMs : 0, Number.isFinite(windowMs) ? windowMs : 0);
+		const paths = [];
+		const warnings = [];
+		const walk = async (directory) => {
+			if (input.signal.aborted) throw input.signal.reason ?? /* @__PURE__ */ new Error("Local folder sync aborted.");
+			for (const entry of await readdir(directory, { withFileTypes: true })) {
+				if (paths.length >= MAX_FILES) return;
+				if (entry.isSymbolicLink()) continue;
+				const path = resolve(directory, entry.name);
+				if (entry.isDirectory()) {
+					if (!IGNORED_DIRECTORIES.has(entry.name)) await walk(path);
+					continue;
+				}
+				if (entry.isFile() && SUPPORTED_EXTENSIONS.has(extname(entry.name).toLowerCase())) paths.push(path);
+			}
+		};
+		await walk(root);
+		if (paths.length >= MAX_FILES) warnings.push(`Local folder sync was limited to ${MAX_FILES} files.`);
+		const items = [];
+		for (const path of paths) {
+			if (input.signal.aborted) throw input.signal.reason ?? /* @__PURE__ */ new Error("Local folder sync aborted.");
+			const fileStat = await stat(path);
+			if (fileStat.size > MAX_FILE_BYTES || fileStat.mtimeMs <= changedAfter) continue;
+			const canonicalPath = await realpath(path);
+			if (canonicalPath !== root && !canonicalPath.startsWith(`${root}${sep}`)) continue;
+			const normalizedText = await readFile(canonicalPath, "utf8");
+			const externalId = relative(root, canonicalPath).split(sep).join("/");
+			items.push({
+				sourceInstanceId: input.instanceId,
+				externalId,
+				itemType: "local_file",
+				authorRole: "user",
+				sourceUpdatedAt: fileStat.mtime.toISOString(),
+				contentHash: createHash("sha256").update(normalizedText).digest("hex"),
+				normalizedText,
+				metadata: {
+					path: externalId,
+					rootPath: root
+				},
+				sensitivity: "personal",
+				retentionClass: "durable",
+				synthesisPipeline: "connected_knowledge"
+			});
+		}
+		return {
+			items,
+			nextCursor: scanStartedAt,
+			warnings,
+			snapshotExternalIds: paths.length < MAX_FILES ? paths.map((path) => relative(root, path).split(sep).join("/")) : void 0
+		};
+	}
+};
+//#endregion
+export { LocalFolderKnowledgeSourceAdapter };

package/dist/src/knowledge/people-graph.d.ts

@@ -0,0 +1,28 @@
+export type ConnectedPersonNode = {
+    id: string;
+    label: string;
+    names: string[];
+    emails: string[];
+    usernames: string[];
+    roles: string[];
+    mentionCount: number;
+    lastObservedAt: string;
+};
+export type ConnectedPersonSourceEdge = {
+    personId: string;
+    sourceInstanceId: string;
+    connectorId?: string;
+    toolkit?: string;
+    mentionCount: number;
+    lastObservedAt: string;
+};
+export type ConnectedPeopleGraph = {
+    people: ConnectedPersonNode[];
+    sourceEdges: ConnectedPersonSourceEdge[];
+    scannedItems: number;
+    truncated: boolean;
+};
+export declare function buildConnectedPeopleGraph(options?: {
+    query?: string;
+    limit?: number;
+}): ConnectedPeopleGraph;