@opengeni/core 0.21.2 → 0.24.1

package/src/domain/scheduled-tasks.ts

@@ -2,8 +2,12 @@ import type { Settings } from "@opengeni/config";
 import type {
   AccessGrant,
   McpPersonalConnectionDelegation,
+  KnowledgeSourceSyncAction,
   ScheduledTask,
   ScheduledTaskAgentConfig,
+  Session,
+  SessionAuthorizationPort,
+  SessionAuthorizationSurface,
   CreateScheduledTaskRequest as CreateScheduledTaskPayload,
   UpdateScheduledTaskRequest as UpdateScheduledTaskPayload,
 } from "@opengeni/contracts";
@@ -11,17 +15,26 @@ import { OPENGENI_SLACK_BOT_SESSION_METADATA_KEY } from "@opengeni/contracts";
 import {
   createScheduledTask,
   deleteScheduledTask,
+  getConnectionMetadata,
+  getKnowledgeSourceForSyncAuthority,
   getNestedAgentDepthDeploymentPolicy,
   getRig,
   getScheduledTask,
   getScheduledTaskPersonalConnectionDelegations,
+  getSession,
   requireWorkspace,
+  scopedKnowledgeScopeKey,
   updateScheduledTask,
   type Database,
   type UpdateScheduledTaskInput,
 } from "@opengeni/db";
 import { HTTPException } from "hono/http-exception";
 import { hasPermission, requirePermission } from "../access";
+import {
+  requireSessionAuthorization,
+  SessionAuthorizationDeniedError,
+  SessionAuthorizationUnavailableError,
+} from "../session-authorization";
 import type { SessionWorkflowClient } from "../dependencies";
 import type { ObjectStorageDependency } from "../dependencies";
 import { settingsWithEnabledCapabilityMcpServers } from "./capabilities";
@@ -38,6 +51,7 @@ import {
 } from "./sessions";
 import {
   hasReservedOpenGeniSlackBotSessionMetadata,
+  scheduledSlackBotConnectionId,
   validateOpenGeniSlackBotConnectionSelection,
 } from "./slack-bot";
 import {
@@ -81,14 +95,42 @@ export async function createValidatedScheduledTask(input: {
   // Set for pack-installation-inherited attachments that were already
   // authorized with variable-sets:use when the pack was enabled.
   variableSetPreauthorized?: boolean;
+  sessionAuthorization?: SessionAuthorizationPort | null | undefined;
+  authorizationSurface?: SessionAuthorizationSurface | undefined;
 }): Promise<ScheduledTask> {
-  const agentConfig = await validateScheduledTaskAgentConfig({
-    ...input,
-    workspaceId: input.grant.workspaceId,
-  });
+  // API parsing fills this default, but pack installers and older internal
+  // callers can still invoke the shared validator with the pre-action shape.
+  const action = input.payload.action ?? ({ kind: "agent_turn" } as const);
+  const knowledgeAction = action.kind === "knowledge_source_sync" ? action : null;
+  if (knowledgeAction) {
+    await validateKnowledgeSourceSyncAction({
+      db: input.db,
+      grant: input.grant,
+      action: knowledgeAction,
+    });
+  }
+  const agentConfig = knowledgeAction
+    ? input.payload.agentConfig
+    : await validateScheduledTaskAgentConfig({
+        ...input,
+        workspaceId: input.grant.workspaceId,
+      });
   const id = crypto.randomUUID();
   validateScheduledTaskSchedule(input.payload.schedule);
-  if (input.payload.variableSetId) {
+  const target = knowledgeAction
+    ? null
+    : await validateScheduledTaskTarget({
+        db: input.db,
+        sessionAuthorization: input.sessionAuthorization,
+        authorizationSurface: input.authorizationSurface,
+        grant: input.grant,
+        targetSessionId: input.payload.targetSessionId,
+        runMode: input.payload.runMode,
+        variableSetId: input.payload.variableSetId,
+        rigId: input.payload.rigId,
+        agentConfig,
+      });
+  if (!knowledgeAction && input.payload.variableSetId) {
     await validateVariableSetAttachment(
       { settings: input.settings, db: input.db },
       input.grant,
@@ -101,21 +143,23 @@ export async function createValidatedScheduledTask(input: {
   // (at dispatch), so validate only that the id names a rig in the workspace —
   // NOT that it has an active version now (that is a fire-time concern). RLS
   // makes a cross-workspace id indistinguishable from missing → both 422.
-  if (input.payload.rigId) {
+  if (!knowledgeAction && input.payload.rigId) {
     await requireScheduledTaskRig(input.db, input.grant.workspaceId, input.payload.rigId);
   }
-  const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(
-    input.db,
-    input.grant.workspaceId,
-    input.settings,
-  );
-  const personalConnectionDelegations = await freezePersonalConnectionDelegations({
-    db: input.db,
-    workspaceId: input.grant.workspaceId,
-    settings: runtimeSettings,
-    tools: [...agentConfig.tools, { kind: "mcp", id: "opengeni" }],
-    source: personalConnectionDelegationSourceForGrant(input.grant),
-  });
+  const personalConnectionDelegations = knowledgeAction
+    ? []
+    : await freezePersonalConnectionDelegations({
+        db: input.db,
+        workspaceId: input.grant.workspaceId,
+        settings: await settingsWithEnabledCapabilityMcpServers(
+          input.db,
+          input.grant.workspaceId,
+          input.settings,
+          { subjectId: input.grant.subjectId },
+        ),
+        tools: [...agentConfig.tools, { kind: "mcp", id: "opengeni" }],
+        source: personalConnectionDelegationSourceForGrant(input.grant),
+      });
   const creationInitiator = creationInitiatorForGrant(input.grant);
   return await createScheduledTask(input.db, {
     id,
@@ -127,17 +171,132 @@ export async function createValidatedScheduledTask(input: {
     temporalScheduleId: scheduledTaskTemporalScheduleId(id),
     runMode: input.payload.runMode,
     overlapPolicy: input.payload.overlapPolicy,
+    action,
     agentConfig,
     ...(creationInitiator.initiator ? { createdBy: creationInitiator.initiator } : {}),
     ...(creationInitiator.context ? { createdByContext: creationInitiator.context } : {}),
     createdByActor: creationInitiator.actor ?? null,
     personalConnectionDelegations,
+    targetSessionId: target?.id ?? null,
     variableSetId: input.payload.variableSetId ?? null,
     rigId: input.payload.rigId ?? null,
     metadata: input.payload.metadata,
   });
 }
 
+export async function validateScheduledTaskTarget(input: {
+  db: Database;
+  sessionAuthorization?: SessionAuthorizationPort | null | undefined;
+  authorizationSurface?: SessionAuthorizationSurface | undefined;
+  grant: AccessGrant;
+  targetSessionId: string | null | undefined;
+  runMode: ScheduledTask["runMode"];
+  variableSetId: string | null | undefined;
+  rigId: string | null | undefined;
+  agentConfig: ScheduledTaskAgentConfig;
+  missingTargetStatus?: 404 | 422;
+}): Promise<Session | null> {
+  if (input.runMode !== "existing_session") {
+    if (input.targetSessionId) {
+      throw new HTTPException(422, {
+        message: "targetSessionId requires runMode=existing_session",
+      });
+    }
+    return null;
+  }
+  if (!input.targetSessionId) {
+    throw new HTTPException(input.missingTargetStatus ?? 422, {
+      message:
+        input.missingTargetStatus === 404
+          ? "target session not found"
+          : "targetSessionId is required when runMode=existing_session",
+    });
+  }
+  requirePermission(input.grant, "sessions:control");
+  if (input.agentConfig.goal) {
+    throw new HTTPException(422, {
+      message: "agentConfig.goal cannot be used with an existing-session target",
+    });
+  }
+  try {
+    await requireSessionAuthorization(
+      {
+        db: input.db,
+        ...(input.sessionAuthorization !== undefined
+          ? { sessionAuthorization: input.sessionAuthorization }
+          : {}),
+      },
+      input.grant,
+      {
+        sessionId: input.targetSessionId,
+        operation: "session.control",
+        surface: input.authorizationSurface ?? "http",
+      },
+    );
+  } catch (error) {
+    if (error instanceof SessionAuthorizationDeniedError) {
+      throw new HTTPException(404, { message: "target session not found" });
+    }
+    if (error instanceof SessionAuthorizationUnavailableError) {
+      throw new HTTPException(503, { message: "session authorization is unavailable" });
+    }
+    throw error;
+  }
+  const session = await getSession(input.db, input.grant.workspaceId, input.targetSessionId);
+  if (!session || session.accountId !== input.grant.accountId) {
+    throw new HTTPException(404, { message: "target session not found" });
+  }
+  if (session.status === "cancelled") {
+    throw new HTTPException(409, {
+      message: "target session is cancelled; choose a revivable session",
+    });
+  }
+  if ((session.variableSetId ?? null) !== (input.variableSetId ?? null)) {
+    throw new HTTPException(422, {
+      message: "target session variableSet attachment does not match the scheduled task",
+    });
+  }
+  if (input.rigId && input.rigId !== session.rigId) {
+    throw new HTTPException(422, {
+      message: "target session rig does not match the scheduled task",
+    });
+  }
+  if (
+    input.agentConfig.sandboxBackend !== undefined &&
+    input.agentConfig.sandboxBackend !== session.sandboxBackend
+  ) {
+    throw new HTTPException(422, {
+      message: "target session sandbox backend does not match the scheduled task",
+    });
+  }
+  if (
+    scheduledSlackBotConnectionId(session.metadata) !==
+    (input.agentConfig.slackBotConnectionId ?? null)
+  ) {
+    throw new HTTPException(422, {
+      message: "target session OpenGeni Slack bot binding does not match the scheduled task",
+    });
+  }
+  return session;
+}
+
+export function scheduledTaskForGrant(task: ScheduledTask, grant: AccessGrant): ScheduledTask {
+  if (hasPermission(grant.permissions, "sessions:control") || task.targetSessionId === null) {
+    return task;
+  }
+  return { ...task, targetSessionId: null };
+}
+
+export function scheduledTaskRunForGrant<T extends { sessionId: string | null }>(
+  run: T,
+  grant: AccessGrant,
+): T {
+  if (hasPermission(grant.permissions, "sessions:control") || run.sessionId === null) {
+    return run;
+  }
+  return { ...run, sessionId: null };
+}
+
 // Validate a scheduled task's rig reference: it must name a rig in the
 // workspace. A missing/cross-workspace id is a 422 (RLS-invisible == missing).
 async function requireScheduledTaskRig(
@@ -160,8 +319,72 @@ export async function validatedScheduledTaskUpdate(input: {
   payload: UpdateScheduledTaskPayload;
   /** See createValidatedScheduledTask; only consulted when agentConfig is updated. */
   toolsProvided?: boolean;
+  sessionAuthorization?: SessionAuthorizationPort | null | undefined;
+  authorizationSurface?: SessionAuthorizationSurface | undefined;
 }): Promise<UpdateScheduledTaskInput> {
   const update: UpdateScheduledTaskInput = {};
+  const existingKnowledge = input.existing.action.kind === "knowledge_source_sync";
+  if (input.payload.action && input.payload.action.kind !== input.existing.action.kind) {
+    throw new HTTPException(409, {
+      message: "scheduled task action kind is immutable; create a new schedule",
+    });
+  }
+  if (existingKnowledge) {
+    if (
+      input.payload.agentConfig !== undefined ||
+      input.payload.runMode !== undefined ||
+      input.payload.targetSessionId !== undefined ||
+      input.payload.variableSetId !== undefined ||
+      input.payload.rigId !== undefined
+    ) {
+      throw new HTTPException(422, {
+        message: "knowledge source schedules do not accept agent/session configuration",
+      });
+    }
+    if (input.payload.overlapPolicy === "allow_concurrent") {
+      throw new HTTPException(422, {
+        message: "knowledge source schedules require skip or buffer_one overlap",
+      });
+    }
+    if (input.payload.action?.kind === "knowledge_source_sync") {
+      await validateKnowledgeSourceSyncAction({
+        db: input.db,
+        grant: input.grant,
+        action: input.payload.action,
+      });
+      update.action = input.payload.action;
+    }
+    if (input.payload.name !== undefined)
+      update.name = trimmedScheduledTaskName(input.payload.name);
+    if (input.payload.status !== undefined) update.status = input.payload.status;
+    if (input.payload.schedule !== undefined) {
+      validateScheduledTaskSchedule(input.payload.schedule);
+      update.schedule = input.payload.schedule;
+    }
+    if (input.payload.overlapPolicy !== undefined) {
+      update.overlapPolicy = input.payload.overlapPolicy;
+    }
+    if (input.payload.metadata !== undefined) update.metadata = input.payload.metadata;
+    return update;
+  }
+  const existingTarget = input.existing.targetSessionId;
+  const nextRunMode = input.payload.runMode ?? input.existing.runMode;
+  const nextTargetSessionId =
+    input.payload.targetSessionId !== undefined
+      ? input.payload.targetSessionId
+      : nextRunMode === "existing_session"
+        ? existingTarget
+        : null;
+  if (
+    input.existing.runMode === "reusable_session" &&
+    input.existing.reusableSessionId &&
+    nextRunMode === "existing_session"
+  ) {
+    throw new HTTPException(409, {
+      message:
+        "cannot target an existing session after this task created its reusable session; create a new task",
+    });
+  }
   if (input.payload.name !== undefined) {
     update.name = trimmedScheduledTaskName(input.payload.name);
   }
@@ -255,6 +478,7 @@ export async function validatedScheduledTaskUpdate(input: {
       input.db,
       input.existing.workspaceId,
       input.settings,
+      { subjectId: input.grant.subjectId },
     );
     const personalConnectionDelegations = await freezePersonalConnectionDelegations({
       db: input.db,
@@ -278,6 +502,43 @@ export async function validatedScheduledTaskUpdate(input: {
     }
     update.personalConnectionDelegations = personalConnectionDelegations;
   }
+  if (
+    existingTarget &&
+    (nextRunMode !== "existing_session" || nextTargetSessionId !== existingTarget)
+  ) {
+    await validateScheduledTaskTarget({
+      db: input.db,
+      sessionAuthorization: input.sessionAuthorization,
+      authorizationSurface: input.authorizationSurface,
+      grant: input.grant,
+      targetSessionId: existingTarget,
+      runMode: "existing_session",
+      variableSetId: input.existing.variableSetId,
+      rigId: input.existing.rigId,
+      agentConfig: input.existing.agentConfig,
+    });
+  }
+  await validateScheduledTaskTarget({
+    db: input.db,
+    sessionAuthorization: input.sessionAuthorization,
+    authorizationSurface: input.authorizationSurface,
+    grant: input.grant,
+    targetSessionId: nextTargetSessionId,
+    runMode: nextRunMode,
+    variableSetId:
+      input.payload.variableSetId !== undefined
+        ? input.payload.variableSetId
+        : input.existing.variableSetId,
+    rigId: input.payload.rigId !== undefined ? input.payload.rigId : input.existing.rigId,
+    agentConfig: update.agentConfig ?? input.existing.agentConfig,
+  });
+  if (
+    input.payload.targetSessionId !== undefined ||
+    input.existing.runMode === "existing_session" ||
+    nextRunMode === "existing_session"
+  ) {
+    update.targetSessionId = nextTargetSessionId;
+  }
   return update;
 }
 
@@ -323,15 +584,85 @@ export async function restoreScheduledTask(
     schedule: task.schedule,
     runMode: task.runMode,
     overlapPolicy: task.overlapPolicy,
+    action: task.action,
     agentConfig: task.agentConfig,
     personalConnectionDelegations: previous.personalConnectionDelegations,
-    reusableSessionId: task.reusableSessionId,
+    ...(task.runMode === "existing_session"
+      ? { targetSessionId: task.targetSessionId }
+      : { reusableSessionId: task.reusableSessionId }),
     variableSetId: task.variableSetId,
     rigId: task.rigId,
     metadata: task.metadata,
   });
 }
 
+async function validateKnowledgeSourceSyncAction(input: {
+  db: Database;
+  grant: AccessGrant;
+  action: KnowledgeSourceSyncAction;
+}): Promise<void> {
+  if (input.action.initiatingSubjectId !== input.grant.subjectId) {
+    throw new HTTPException(403, {
+      message: "knowledge source sync must preserve the exact initiating subject",
+    });
+  }
+  if (input.action.connection.ownerSubjectId !== input.grant.subjectId) {
+    throw new HTTPException(403, {
+      message: "knowledge source connection must belong to the initiating subject",
+    });
+  }
+  const resolved = await getKnowledgeSourceForSyncAuthority(input.db, {
+    accountId: input.grant.accountId,
+    workspaceId: input.grant.workspaceId,
+    sourceId: input.action.sourceId,
+    initiatingSubjectId: input.grant.subjectId,
+  });
+  if (!resolved || resolved.source.lifecycleState !== "active") {
+    throw new HTTPException(404, { message: "knowledge source not found" });
+  }
+  if (
+    resolved.source.syncGeneration !== input.action.sourceGeneration ||
+    resolved.source.lifecycleGeneration !== input.action.sourceLifecycleGeneration ||
+    scopedKnowledgeScopeKey(resolved.source.scope) !==
+      scopedKnowledgeScopeKey(input.action.destination)
+  ) {
+    throw new HTTPException(409, {
+      message: "knowledge source authority or generation changed",
+    });
+  }
+  const connection = await getConnectionMetadata(
+    input.db,
+    input.grant.workspaceId,
+    input.action.connection.connectionId,
+    input.grant.subjectId,
+  );
+  if (
+    !connection ||
+    connection.accountId !== input.grant.accountId ||
+    connection.workspaceId !== input.grant.workspaceId ||
+    connection.subjectId !== input.action.connection.ownerSubjectId ||
+    connection.version !== input.action.connection.connectionVersion ||
+    connection.providerDomain.toLowerCase() !==
+      input.action.connection.providerDomain.toLowerCase() ||
+    connection.kind !== input.action.connection.kind ||
+    connection.status !== "active"
+  ) {
+    throw new HTTPException(409, {
+      message: "knowledge source connection authority changed or requires reconnect",
+    });
+  }
+}
+
+export class ScheduledTaskSyncError extends Error {
+  readonly persistenceRestored: boolean;
+
+  constructor(cause: unknown, persistenceRestored: boolean) {
+    super(cause instanceof Error ? cause.message : String(cause), { cause });
+    this.name = "ScheduledTaskSyncError";
+    this.persistenceRestored = persistenceRestored;
+  }
+}
+
 export async function syncCreatedScheduledTask(input: {
   db: Database;
   workflowClient: SessionWorkflowClient;
@@ -340,10 +671,13 @@ export async function syncCreatedScheduledTask(input: {
   try {
     await input.workflowClient.syncScheduledTask({ task: input.task });
   } catch (error) {
-    await deleteScheduledTask(input.db, input.task.workspaceId, input.task.id).catch(
-      () => undefined,
-    );
-    throw error;
+    let persistenceRestored = true;
+    try {
+      await deleteScheduledTask(input.db, input.task.workspaceId, input.task.id);
+    } catch {
+      persistenceRestored = false;
+    }
+    throw new ScheduledTaskSyncError(error, persistenceRestored);
   }
 }
 
@@ -356,8 +690,13 @@ export async function syncUpdatedScheduledTask(input: {
   try {
     await input.workflowClient.syncScheduledTask({ task: input.task });
   } catch (error) {
-    await restoreScheduledTask(input.db, input.previous).catch(() => undefined);
-    throw error;
+    let persistenceRestored = true;
+    try {
+      await restoreScheduledTask(input.db, input.previous);
+    } catch {
+      persistenceRestored = false;
+    }
+    throw new ScheduledTaskSyncError(error, persistenceRestored);
   }
 }
 
@@ -433,6 +772,7 @@ async function validateScheduledTaskAgentConfig(input: {
     input.db,
     input.workspaceId,
     input.settings,
+    { subjectId: input.grant.subjectId },
   );
   const requestedTools = validateToolRefs(input.payload.agentConfig.tools ?? [], runtimeSettings);
   // A task whose creator did not choose tools gets the workspace's enabled

package/src/domain/session-tool-policy.ts

@@ -169,8 +169,11 @@ export async function workspaceSessionToolPolicyServerIds(
   db: Database,
   workspaceId: string,
   settings: Settings,
+  subjectId?: string,
 ): Promise<string[]> {
-  const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(db, workspaceId, settings);
+  const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(db, workspaceId, settings, {
+    ...(subjectId ? { subjectId } : {}),
+  });
   return sortedIds(runtimeSettings.mcpServers.map((server) => server.id));
 }
 
@@ -179,8 +182,11 @@ export async function workspaceSessionToolPolicyDefaultServerIds(
   db: Database,
   workspaceId: string,
   settings: Settings,
+  subjectId?: string,
 ): Promise<string[]> {
-  const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(db, workspaceId, settings);
+  const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(db, workspaceId, settings, {
+    ...(subjectId ? { subjectId } : {}),
+  });
   return defaultSessionMcpServerIds(runtimeSettings.mcpServers);
 }