@inkeep/agents-core 0.58.13 → 0.58.15

package/dist/data-access/runtime/workAppSlack.js

@@ -1,4 +1,5 @@
 import { workAppSlackChannelAgentConfigs, workAppSlackUserMappings, workAppSlackWorkspaces } from "../../db/runtime/runtime-schema.js";
+import { projectScopedWhere, tenantScopedWhere } from "../manage/scope-helpers.js";
 import { and, eq } from "drizzle-orm";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -18,7 +19,7 @@ const createWorkAppSlackWorkspace = (db) => async (data) => {
 	return result;
 };
 const findWorkAppSlackWorkspaceByTeamId = (db) => async (tenantId, slackTeamId) => {
-	return (await db.select().from(workAppSlackWorkspaces).where(and(eq(workAppSlackWorkspaces.tenantId, tenantId), eq(workAppSlackWorkspaces.slackTeamId, slackTeamId))).limit(1))[0] || null;
+	return (await db.select().from(workAppSlackWorkspaces).where(and(tenantScopedWhere(workAppSlackWorkspaces, { tenantId }), eq(workAppSlackWorkspaces.slackTeamId, slackTeamId))).limit(1))[0] || null;
 };
 /**
 * Find a workspace by Slack team ID only (without tenant filter).
@@ -39,7 +40,7 @@ const findWorkAppSlackWorkspaceByNangoConnectionId = (db) => async (nangoConnect
 	return (await db.select().from(workAppSlackWorkspaces).where(eq(workAppSlackWorkspaces.nangoConnectionId, nangoConnectionId)))[0] || null;
 };
 const listWorkAppSlackWorkspacesByTenant = (db) => async (tenantId) => {
-	return db.select().from(workAppSlackWorkspaces).where(eq(workAppSlackWorkspaces.tenantId, tenantId));
+	return db.select().from(workAppSlackWorkspaces).where(tenantScopedWhere(workAppSlackWorkspaces, { tenantId }));
 };
 const updateWorkAppSlackWorkspace = (db) => async (id, data) => {
 	const [result] = await db.update(workAppSlackWorkspaces).set({
@@ -55,7 +56,7 @@ const deleteWorkAppSlackWorkspaceByNangoConnectionId = (db) => async (nangoConne
 	return (await db.delete(workAppSlackWorkspaces).where(eq(workAppSlackWorkspaces.nangoConnectionId, nangoConnectionId)).returning()).length > 0;
 };
 const findWorkAppSlackUserMapping = (db) => async (tenantId, slackUserId, slackTeamId, clientId = DEFAULT_CLIENT_ID) => {
-	return (await db.select().from(workAppSlackUserMappings).where(and(eq(workAppSlackUserMappings.tenantId, tenantId), eq(workAppSlackUserMappings.clientId, clientId), eq(workAppSlackUserMappings.slackUserId, slackUserId), eq(workAppSlackUserMappings.slackTeamId, slackTeamId))).limit(1))[0] || null;
+	return (await db.select().from(workAppSlackUserMappings).where(and(tenantScopedWhere(workAppSlackUserMappings, { tenantId }), eq(workAppSlackUserMappings.clientId, clientId), eq(workAppSlackUserMappings.slackUserId, slackUserId), eq(workAppSlackUserMappings.slackTeamId, slackTeamId))).limit(1))[0] || null;
 };
 const findWorkAppSlackUserMappingByInkeepUserId = (db) => async (inkeepUserId) => {
 	return db.select().from(workAppSlackUserMappings).where(eq(workAppSlackUserMappings.inkeepUserId, inkeepUserId));
@@ -68,7 +69,7 @@ const findWorkAppSlackUserMappingBySlackUser = (db) => async (slackUserId, slack
 	return (await db.select().from(workAppSlackUserMappings).where(and(eq(workAppSlackUserMappings.clientId, clientId), eq(workAppSlackUserMappings.slackUserId, slackUserId), eq(workAppSlackUserMappings.slackTeamId, slackTeamId))).limit(1))[0] || null;
 };
 const listWorkAppSlackUserMappingsByTeam = (db) => async (tenantId, slackTeamId) => {
-	return db.select().from(workAppSlackUserMappings).where(and(eq(workAppSlackUserMappings.tenantId, tenantId), eq(workAppSlackUserMappings.slackTeamId, slackTeamId)));
+	return db.select().from(workAppSlackUserMappings).where(and(tenantScopedWhere(workAppSlackUserMappings, { tenantId }), eq(workAppSlackUserMappings.slackTeamId, slackTeamId)));
 };
 const createWorkAppSlackUserMapping = (db) => async (data) => {
 	const id = `wsum_${nanoid(21)}`;
@@ -84,10 +85,10 @@ const createWorkAppSlackUserMapping = (db) => async (data) => {
 	return result;
 };
 const deleteWorkAppSlackUserMapping = (db) => async (tenantId, slackUserId, slackTeamId, clientId = DEFAULT_CLIENT_ID) => {
-	return (await db.delete(workAppSlackUserMappings).where(and(eq(workAppSlackUserMappings.tenantId, tenantId), eq(workAppSlackUserMappings.clientId, clientId), eq(workAppSlackUserMappings.slackUserId, slackUserId), eq(workAppSlackUserMappings.slackTeamId, slackTeamId))).returning()).length > 0;
+	return (await db.delete(workAppSlackUserMappings).where(and(tenantScopedWhere(workAppSlackUserMappings, { tenantId }), eq(workAppSlackUserMappings.clientId, clientId), eq(workAppSlackUserMappings.slackUserId, slackUserId), eq(workAppSlackUserMappings.slackTeamId, slackTeamId))).returning()).length > 0;
 };
 const deleteAllWorkAppSlackUserMappingsByTeam = (db) => async (tenantId, slackTeamId, clientId = DEFAULT_CLIENT_ID) => {
-	return (await db.delete(workAppSlackUserMappings).where(and(eq(workAppSlackUserMappings.tenantId, tenantId), eq(workAppSlackUserMappings.clientId, clientId), eq(workAppSlackUserMappings.slackTeamId, slackTeamId))).returning()).length;
+	return (await db.delete(workAppSlackUserMappings).where(and(tenantScopedWhere(workAppSlackUserMappings, { tenantId }), eq(workAppSlackUserMappings.clientId, clientId), eq(workAppSlackUserMappings.slackTeamId, slackTeamId))).returning()).length;
 };
 const createWorkAppSlackChannelAgentConfig = (db) => async (data) => {
 	const id = `wscac_${nanoid(21)}`;
@@ -101,10 +102,10 @@ const createWorkAppSlackChannelAgentConfig = (db) => async (data) => {
 	return result;
 };
 const findWorkAppSlackChannelAgentConfig = (db) => async (tenantId, slackTeamId, slackChannelId) => {
-	return (await db.select().from(workAppSlackChannelAgentConfigs).where(and(eq(workAppSlackChannelAgentConfigs.tenantId, tenantId), eq(workAppSlackChannelAgentConfigs.slackTeamId, slackTeamId), eq(workAppSlackChannelAgentConfigs.slackChannelId, slackChannelId))).limit(1))[0] || null;
+	return (await db.select().from(workAppSlackChannelAgentConfigs).where(and(tenantScopedWhere(workAppSlackChannelAgentConfigs, { tenantId }), eq(workAppSlackChannelAgentConfigs.slackTeamId, slackTeamId), eq(workAppSlackChannelAgentConfigs.slackChannelId, slackChannelId))).limit(1))[0] || null;
 };
 const listWorkAppSlackChannelAgentConfigsByTeam = (db) => async (tenantId, slackTeamId) => {
-	return db.select().from(workAppSlackChannelAgentConfigs).where(and(eq(workAppSlackChannelAgentConfigs.tenantId, tenantId), eq(workAppSlackChannelAgentConfigs.slackTeamId, slackTeamId)));
+	return db.select().from(workAppSlackChannelAgentConfigs).where(and(tenantScopedWhere(workAppSlackChannelAgentConfigs, { tenantId }), eq(workAppSlackChannelAgentConfigs.slackTeamId, slackTeamId)));
 };
 /**
 * Atomic upsert using onConflictDoUpdate to avoid TOCTOU race conditions.
@@ -138,16 +139,22 @@ const upsertWorkAppSlackChannelAgentConfig = (db) => async (data) => {
 	return result;
 };
 const deleteWorkAppSlackChannelAgentConfig = (db) => async (tenantId, slackTeamId, slackChannelId) => {
-	return (await db.delete(workAppSlackChannelAgentConfigs).where(and(eq(workAppSlackChannelAgentConfigs.tenantId, tenantId), eq(workAppSlackChannelAgentConfigs.slackTeamId, slackTeamId), eq(workAppSlackChannelAgentConfigs.slackChannelId, slackChannelId))).returning()).length > 0;
+	return (await db.delete(workAppSlackChannelAgentConfigs).where(and(tenantScopedWhere(workAppSlackChannelAgentConfigs, { tenantId }), eq(workAppSlackChannelAgentConfigs.slackTeamId, slackTeamId), eq(workAppSlackChannelAgentConfigs.slackChannelId, slackChannelId))).returning()).length > 0;
 };
 const deleteAllWorkAppSlackChannelAgentConfigsByTeam = (db) => async (tenantId, slackTeamId) => {
-	return (await db.delete(workAppSlackChannelAgentConfigs).where(and(eq(workAppSlackChannelAgentConfigs.tenantId, tenantId), eq(workAppSlackChannelAgentConfigs.slackTeamId, slackTeamId))).returning()).length;
+	return (await db.delete(workAppSlackChannelAgentConfigs).where(and(tenantScopedWhere(workAppSlackChannelAgentConfigs, { tenantId }), eq(workAppSlackChannelAgentConfigs.slackTeamId, slackTeamId))).returning()).length;
 };
 const deleteWorkAppSlackChannelAgentConfigsByAgent = (db) => async (tenantId, projectId, agentId) => {
-	return (await db.delete(workAppSlackChannelAgentConfigs).where(and(eq(workAppSlackChannelAgentConfigs.tenantId, tenantId), eq(workAppSlackChannelAgentConfigs.projectId, projectId), eq(workAppSlackChannelAgentConfigs.agentId, agentId))).returning()).length;
+	return (await db.delete(workAppSlackChannelAgentConfigs).where(and(projectScopedWhere(workAppSlackChannelAgentConfigs, {
+		tenantId,
+		projectId
+	}), eq(workAppSlackChannelAgentConfigs.agentId, agentId))).returning()).length;
 };
 const deleteWorkAppSlackChannelAgentConfigsByProject = (db) => async (tenantId, projectId) => {
-	return (await db.delete(workAppSlackChannelAgentConfigs).where(and(eq(workAppSlackChannelAgentConfigs.tenantId, tenantId), eq(workAppSlackChannelAgentConfigs.projectId, projectId))).returning()).length;
+	return (await db.delete(workAppSlackChannelAgentConfigs).where(projectScopedWhere(workAppSlackChannelAgentConfigs, {
+		tenantId,
+		projectId
+	})).returning()).length;
 };
 const clearWorkspaceDefaultsByAgent = (db) => async (tenantId, projectId, agentId) => {
 	return (await db.update(workAppSlackWorkspaces).set({
@@ -155,7 +162,7 @@ const clearWorkspaceDefaultsByAgent = (db) => async (tenantId, projectId, agentI
 		defaultProjectId: null,
 		defaultGrantAccessToMembers: null,
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-	}).where(and(eq(workAppSlackWorkspaces.tenantId, tenantId), eq(workAppSlackWorkspaces.defaultProjectId, projectId), eq(workAppSlackWorkspaces.defaultAgentId, agentId))).returning()).length;
+	}).where(and(tenantScopedWhere(workAppSlackWorkspaces, { tenantId }), eq(workAppSlackWorkspaces.defaultProjectId, projectId), eq(workAppSlackWorkspaces.defaultAgentId, agentId))).returning()).length;
 };
 const clearWorkspaceDefaultsByProject = (db) => async (tenantId, projectId) => {
 	return (await db.update(workAppSlackWorkspaces).set({
@@ -163,7 +170,7 @@ const clearWorkspaceDefaultsByProject = (db) => async (tenantId, projectId) => {
 		defaultProjectId: null,
 		defaultGrantAccessToMembers: null,
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-	}).where(and(eq(workAppSlackWorkspaces.tenantId, tenantId), eq(workAppSlackWorkspaces.defaultProjectId, projectId))).returning()).length;
+	}).where(and(tenantScopedWhere(workAppSlackWorkspaces, { tenantId }), eq(workAppSlackWorkspaces.defaultProjectId, projectId))).returning()).length;
 };
 const DEV_CONFIG_FILENAME = ".slack-dev.json";
 function findSlackDevConfigPath() {

package/dist/data-reconciliation/audit.d.ts

@@ -0,0 +1,6 @@
+import { AuditContext, AuditReport, EntityEffectRegistry } from "./types.js";
+
+//#region src/data-reconciliation/audit.d.ts
+declare function audit(registry: EntityEffectRegistry, ctx: AuditContext): Promise<AuditReport>;
+//#endregion
+export { audit };

package/dist/data-reconciliation/audit.js

@@ -0,0 +1,37 @@
+//#region src/data-reconciliation/audit.ts
+async function audit(registry, ctx) {
+	const report = {
+		entries: [],
+		checkedEntities: [],
+		skippedEntities: []
+	};
+	for (const [table, handlers] of Object.entries(registry)) {
+		if (!handlers?.check) {
+			report.skippedEntities.push(table);
+			continue;
+		}
+		report.checkedEntities.push(table);
+		try {
+			const result = await handlers.check(ctx);
+			report.entries.push({
+				table,
+				result
+			});
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			ctx.logger.warn({
+				table,
+				error: errorMessage
+			}, `Audit check failed for entity: ${table}`);
+			report.entries.push({
+				table,
+				result: null,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	return report;
+}
+
+//#endregion
+export { audit };

package/dist/data-reconciliation/index.d.ts

@@ -0,0 +1,4 @@
+import { AppliedEffect, AuditContext, AuditReport, EntityAuditEntry, EntityDiff, EntityEffectHandlers, EntityEffectRegistry, EntityOperation, EntityRowByTable, FailedEffect, OrphanedRuntimeRowsResult, ReconcileContext, ReconcileResult, ScheduledTriggerAuditResult, SkippedDiff, defineHandlers } from "./types.js";
+import { audit } from "./audit.js";
+import { reconcile } from "./reconcile.js";
+export { AppliedEffect, AuditContext, AuditReport, EntityAuditEntry, EntityDiff, EntityEffectHandlers, EntityEffectRegistry, EntityOperation, EntityRowByTable, FailedEffect, OrphanedRuntimeRowsResult, ReconcileContext, ReconcileResult, ScheduledTriggerAuditResult, SkippedDiff, audit, defineHandlers, reconcile };

package/dist/data-reconciliation/index.js

@@ -0,0 +1,5 @@
+import { audit } from "./audit.js";
+import { reconcile } from "./reconcile.js";
+import { defineHandlers } from "./types.js";
+
+export { audit, defineHandlers, reconcile };

package/dist/data-reconciliation/reconcile.d.ts

@@ -0,0 +1,6 @@
+import { EntityDiff, EntityEffectRegistry, ReconcileContext, ReconcileResult } from "./types.js";
+
+//#region src/data-reconciliation/reconcile.d.ts
+declare function reconcile(registry: EntityEffectRegistry, diffs: EntityDiff[], ctx: ReconcileContext): Promise<ReconcileResult>;
+//#endregion
+export { reconcile };

package/dist/data-reconciliation/reconcile.js

@@ -0,0 +1,58 @@
+//#region src/data-reconciliation/reconcile.ts
+async function reconcile(registry, diffs, ctx) {
+	const result = {
+		applied: [],
+		skipped: [],
+		failed: []
+	};
+	const operations = diffs.map(async (diff) => {
+		const handlers = registry[diff.table];
+		if (!handlers) {
+			result.skipped.push({
+				table: diff.table,
+				operation: diff.operation,
+				primaryKey: diff.primaryKey,
+				reason: "no registry entry"
+			});
+			return;
+		}
+		try {
+			if (diff.operation === "insert" && handlers.onCreated && diff.after) await handlers.onCreated(diff.after, ctx);
+			else if (diff.operation === "update" && handlers.onUpdated && diff.before && diff.after) await handlers.onUpdated(diff.before, diff.after, ctx);
+			else if (diff.operation === "delete" && handlers.onDeleted && diff.before) await handlers.onDeleted(diff.before, ctx);
+			else {
+				result.skipped.push({
+					table: diff.table,
+					operation: diff.operation,
+					primaryKey: diff.primaryKey,
+					reason: `no handler for ${diff.operation}`
+				});
+				return;
+			}
+			result.applied.push({
+				table: diff.table,
+				operation: diff.operation,
+				primaryKey: diff.primaryKey
+			});
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			ctx.logger.error({
+				table: diff.table,
+				operation: diff.operation,
+				primaryKey: diff.primaryKey,
+				error: errorMessage
+			}, `Reconcile effect failed for ${diff.table}.${diff.operation}`);
+			result.failed.push({
+				table: diff.table,
+				operation: diff.operation,
+				primaryKey: diff.primaryKey,
+				error: errorMessage
+			});
+		}
+	});
+	await Promise.allSettled(operations);
+	return result;
+}
+
+//#endregion
+export { reconcile };

package/dist/data-reconciliation/types.d.ts

@@ -0,0 +1,116 @@
+import { PinoLogger } from "../utils/logger.js";
+import { AgentsManageDatabaseClient } from "../db/manage/manage-client.js";
+import { AgentsRunDatabaseClient } from "../db/runtime/runtime-client.js";
+import { ScheduledTrigger } from "../validation/schemas.js";
+import { AgentSelect, ContextConfigSelect, SubAgentSelect, ToolSelect } from "../types/entities.js";
+
+//#region src/data-reconciliation/types.d.ts
+type EntityRowByTable = {
+  scheduled_triggers: ScheduledTrigger;
+  tools: ToolSelect;
+  context_configs: ContextConfigSelect;
+  agent: AgentSelect;
+  sub_agents: SubAgentSelect;
+};
+type EntityOperation = 'insert' | 'update' | 'delete';
+type EntityDiff<TTable extends keyof EntityRowByTable = keyof EntityRowByTable> = {
+  table: TTable;
+  operation: 'insert';
+  primaryKey: Record<string, string>;
+  before: null;
+  after: EntityRowByTable[TTable];
+} | {
+  table: TTable;
+  operation: 'update';
+  primaryKey: Record<string, string>;
+  before: EntityRowByTable[TTable];
+  after: EntityRowByTable[TTable];
+} | {
+  table: TTable;
+  operation: 'delete';
+  primaryKey: Record<string, string>;
+  before: EntityRowByTable[TTable];
+  after: null;
+};
+type EntityEffectHandlers<TTable extends keyof EntityRowByTable> = {
+  onCreated?: (after: EntityRowByTable[TTable], ctx: ReconcileContext) => Promise<void>;
+  onUpdated?: (before: EntityRowByTable[TTable], after: EntityRowByTable[TTable], ctx: ReconcileContext) => Promise<void>;
+  onDeleted?: (before: EntityRowByTable[TTable], ctx: ReconcileContext) => Promise<void>;
+  check?: (ctx: AuditContext) => Promise<unknown>;
+};
+type EntityEffectRegistry = { [K in keyof EntityRowByTable]?: EntityEffectHandlers<K> };
+declare function defineHandlers<TTable extends keyof EntityRowByTable>(_table: TTable, handlers: EntityEffectHandlers<TTable>): EntityEffectHandlers<TTable>;
+type ReconcileContext = {
+  manageDb: AgentsManageDatabaseClient;
+  runDb: AgentsRunDatabaseClient;
+  scopes: {
+    tenantId: string;
+    projectId: string;
+  };
+  fullBranchName: string;
+  logger: PinoLogger;
+};
+type AuditContext = ReconcileContext;
+type AppliedEffect = {
+  table: string;
+  operation: EntityOperation;
+  primaryKey: Record<string, string>;
+};
+type FailedEffect = AppliedEffect & {
+  error: string;
+};
+type SkippedDiff = {
+  table: string;
+  operation: EntityOperation;
+  primaryKey: Record<string, string>;
+  reason: string;
+};
+type ReconcileResult = {
+  applied: AppliedEffect[];
+  skipped: SkippedDiff[];
+  failed: FailedEffect[];
+};
+type EntityAuditEntry<TResult = unknown> = {
+  table: string;
+  result: TResult;
+  error?: string;
+};
+type AuditReport = {
+  entries: EntityAuditEntry[];
+  checkedEntities: string[];
+  skippedEntities: string[];
+};
+type ScheduledTriggerAuditResult = {
+  missingWorkflows: Array<{
+    triggerId: string;
+    triggerName: string;
+  }>;
+  orphanedWorkflows: Array<{
+    workflowRunId: string;
+    scheduledTriggerId: string;
+  }>;
+  staleWorkflows: Array<{
+    triggerId: string;
+    triggerName: string;
+    workflowId: string;
+  }>;
+  deadWorkflows: Array<{
+    triggerId: string;
+    triggerName: string;
+    workflowRunId: string;
+    runStatus: string;
+  }>;
+  verificationFailures: Array<{
+    workflowRunId: string;
+    error: string;
+  }>;
+};
+type OrphanedRuntimeRowsResult = {
+  orphanedRows: Array<{
+    table: string;
+    id: string;
+    referencedEntityId: string;
+  }>;
+};
+//#endregion
+export { AppliedEffect, AuditContext, AuditReport, EntityAuditEntry, EntityDiff, EntityEffectHandlers, EntityEffectRegistry, EntityOperation, EntityRowByTable, FailedEffect, OrphanedRuntimeRowsResult, ReconcileContext, ReconcileResult, ScheduledTriggerAuditResult, SkippedDiff, defineHandlers };

package/dist/data-reconciliation/types.js

@@ -0,0 +1,7 @@
+//#region src/data-reconciliation/types.ts
+function defineHandlers(_table, handlers) {
+	return handlers;
+}
+
+//#endregion
+export { defineHandlers };