@opengeni/core 0.4.6 → 0.4.8

package/src/domain/scheduled-tasks.ts

@@ -9,6 +9,7 @@ import type {
 import {
   createScheduledTask,
   deleteScheduledTask,
+  getRig,
   getScheduledTask,
   updateScheduledTask,
   type Database,
@@ -19,8 +20,8 @@ import { requirePermission } from "../access";
 import type { SessionWorkflowClient } from "../dependencies";
 import type { ObjectStorageDependency } from "../dependencies";
 import { settingsWithEnabledCapabilityMcpServers } from "./capabilities";
-import { validateEnvironmentAttachment } from "./environments";
-import { assertConfiguredModel } from "./sessions";
+import { validateVariableSetAttachment } from "./environments";
+import { assertConfiguredModel, assertWorkspaceModelPolicyAllows } from "./sessions";
 import {
   normalizeResources,
   validateFileResources,
@@ -43,9 +44,9 @@ export function scheduledTaskToolsProvided(rawPayload: unknown): boolean {
   }
   const agentConfig = (rawPayload as { agentConfig?: unknown }).agentConfig;
   return Boolean(
-    agentConfig
-    && typeof agentConfig === "object"
-    && Object.prototype.hasOwnProperty.call(agentConfig, "tools"),
+    agentConfig &&
+    typeof agentConfig === "object" &&
+    Object.prototype.hasOwnProperty.call(agentConfig, "tools"),
   );
 }
 
@@ -60,21 +61,31 @@ export async function createValidatedScheduledTask(input: {
   // capability MCP servers, mirroring session creation.
   toolsProvided?: boolean;
   // Set for pack-installation-inherited attachments that were already
-  // authorized with environments:use when the pack was enabled.
-  environmentPreauthorized?: boolean;
+  // authorized with variable-sets:use when the pack was enabled.
+  variableSetPreauthorized?: boolean;
 }): Promise<ScheduledTask> {
-  const agentConfig = await validateScheduledTaskAgentConfig({ ...input, workspaceId: input.grant.workspaceId });
+  const agentConfig = await validateScheduledTaskAgentConfig({
+    ...input,
+    workspaceId: input.grant.workspaceId,
+  });
   const id = crypto.randomUUID();
   validateScheduledTaskSchedule(input.payload.schedule);
-  if (input.payload.environmentId) {
-    await validateEnvironmentAttachment(
+  if (input.payload.variableSetId) {
+    await validateVariableSetAttachment(
       { settings: input.settings, db: input.db },
       input.grant,
       input.grant.workspaceId,
-      input.payload.environmentId,
-      { preauthorized: input.environmentPreauthorized ?? false },
+      input.payload.variableSetId,
+      { preauthorized: input.variableSetPreauthorized ?? false },
     );
   }
+  // The rig is stored on the task and resolved to its ACTIVE version per fire
+  // (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) {
+    await requireScheduledTaskRig(input.db, input.grant.workspaceId, input.payload.rigId);
+  }
   return await createScheduledTask(input.db, {
     id,
     accountId: input.grant.accountId,
@@ -86,11 +97,25 @@ export async function createValidatedScheduledTask(input: {
     runMode: input.payload.runMode,
     overlapPolicy: input.payload.overlapPolicy,
     agentConfig,
-    environmentId: input.payload.environmentId ?? null,
+    variableSetId: input.payload.variableSetId ?? null,
+    rigId: input.payload.rigId ?? null,
     metadata: input.payload.metadata,
   });
 }
 
+// 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(
+  db: Database,
+  workspaceId: string,
+  rigId: string,
+): Promise<void> {
+  const rig = await getRig(db, workspaceId, rigId);
+  if (!rig) {
+    throw new HTTPException(422, { message: `unknown rigId: ${rigId}` });
+  }
+}
+
 export async function validatedScheduledTaskUpdate(input: {
   settings: Settings;
   db: Database;
@@ -121,39 +146,54 @@ export async function validatedScheduledTaskUpdate(input: {
   if (input.payload.metadata !== undefined) {
     update.metadata = input.payload.metadata;
   }
-  if (input.payload.environmentId !== undefined) {
-    const nextEnvironmentId = input.payload.environmentId;
-    if ((input.existing.environmentId ?? null) !== (nextEnvironmentId ?? null)
-      && input.existing.runMode === "reusable_session"
-      && input.existing.reusableSessionId) {
-      throw new HTTPException(409, { message: "cannot change environment of a task with a live reusable session; recreate the task" });
+  if (input.payload.variableSetId !== undefined) {
+    const nextVariableSetId = input.payload.variableSetId;
+    if (
+      (input.existing.variableSetId ?? null) !== (nextVariableSetId ?? null) &&
+      input.existing.runMode === "reusable_session" &&
+      input.existing.reusableSessionId
+    ) {
+      throw new HTTPException(409, {
+        message:
+          "cannot change variableSet of a task with a live reusable session; recreate the task",
+      });
     }
-    if (nextEnvironmentId === null) {
-      if (input.existing.environmentId !== null) {
+    if (nextVariableSetId === null) {
+      if (input.existing.variableSetId !== null) {
         // Detaching is also an attachment change: it strips the secrets a
         // task's instructions were designed around.
-        requirePermission(input.grant, "environments:use");
+        requirePermission(input.grant, "variable-sets:use");
       }
-      update.environmentId = null;
+      update.variableSetId = null;
     } else {
-      await validateEnvironmentAttachment(
+      await validateVariableSetAttachment(
         { settings: input.settings, db: input.db },
         input.grant,
         input.existing.workspaceId,
-        nextEnvironmentId,
+        nextVariableSetId,
       );
-      update.environmentId = nextEnvironmentId;
+      update.variableSetId = nextVariableSetId;
     }
   }
+  if (input.payload.rigId !== undefined) {
+    // The rig binds fresh per fire, so changing it on a reusable-session task is
+    // harmless for the LIVE session (which keeps its own frozen version) and
+    // only affects subsequent new-session fires — no live-session guard needed.
+    if (input.payload.rigId !== null) {
+      await requireScheduledTaskRig(input.db, input.existing.workspaceId, input.payload.rigId);
+    }
+    update.rigId = input.payload.rigId;
+  }
   if (input.payload.agentConfig !== undefined) {
     // Editing the instructions of a task that injects workspace secrets is
     // equivalent to attaching those secrets to new instructions, so it
-    // requires environments:use even though plain task edits do not.
-    const willHaveEnvironment = input.payload.environmentId !== undefined
-      ? input.payload.environmentId !== null
-      : Boolean(input.existing.environmentId);
-    if (willHaveEnvironment) {
-      requirePermission(input.grant, "environments:use");
+    // requires variable-sets:use even though plain task edits do not.
+    const willHaveVariableSet =
+      input.payload.variableSetId !== undefined
+        ? input.payload.variableSetId !== null
+        : Boolean(input.existing.variableSetId);
+    if (willHaveVariableSet) {
+      requirePermission(input.grant, "variable-sets:use");
     }
     update.agentConfig = await validateScheduledTaskAgentConfig({
       settings: input.settings,
@@ -167,7 +207,11 @@ export async function validatedScheduledTaskUpdate(input: {
   return update;
 }
 
-export async function requireScheduledTaskForApi(db: Database, workspaceId: string, taskId: string): Promise<ScheduledTask> {
+export async function requireScheduledTaskForApi(
+  db: Database,
+  workspaceId: string,
+  taskId: string,
+): Promise<ScheduledTask> {
   const task = await getScheduledTask(db, workspaceId, taskId);
   if (!task) {
     throw new HTTPException(404, { message: "scheduled task not found" });
@@ -175,7 +219,10 @@ export async function requireScheduledTaskForApi(db: Database, workspaceId: stri
   return task;
 }
 
-export async function restoreScheduledTask(db: Database, task: ScheduledTask): Promise<ScheduledTask> {
+export async function restoreScheduledTask(
+  db: Database,
+  task: ScheduledTask,
+): Promise<ScheduledTask> {
   return await updateScheduledTask(db, task.workspaceId, task.id, {
     name: task.name,
     status: task.status,
@@ -184,7 +231,7 @@ export async function restoreScheduledTask(db: Database, task: ScheduledTask): P
     overlapPolicy: task.overlapPolicy,
     agentConfig: task.agentConfig,
     reusableSessionId: task.reusableSessionId,
-    environmentId: task.environmentId,
+    variableSetId: task.variableSetId,
     metadata: task.metadata,
   });
 }
@@ -197,7 +244,9 @@ 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);
+    await deleteScheduledTask(input.db, input.task.workspaceId, input.task.id).catch(
+      () => undefined,
+    );
     throw error;
   }
 }
@@ -257,7 +306,11 @@ export function manualScheduledTaskTriggerWorkflowId(taskId: string, triggerToke
  * charge. Shares the stable trigger token with the workflow id so the charge
  * and the run dedupe together under retry.
  */
-export function manualScheduledTaskTriggerUsageKey(workspaceId: string, taskId: string, triggerToken: string): string {
+export function manualScheduledTaskTriggerUsageKey(
+  workspaceId: string,
+  taskId: string,
+  triggerToken: string,
+): string {
   return `agent_run.created:scheduled-trigger:${workspaceId}:${taskId}:${triggerToken}`;
 }
 
@@ -275,17 +328,30 @@ async function validateScheduledTaskAgentConfig(input: {
   // a model the host does not expose). An omitted model inherits the host
   // default downstream, which is always configured.
   assertConfiguredModel(input.settings, input.payload.agentConfig.model);
+  // Same policy vetting as the session choke points; an omitted model flows
+  // through session creation later, where the effective default is vetted.
+  await assertWorkspaceModelPolicyAllows(
+    input.db,
+    input.settings,
+    input.workspaceId,
+    input.payload.agentConfig.model,
+  );
   const resources = normalizeResources(input.payload.agentConfig.resources ?? []);
-  const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(input.db, input.workspaceId, input.settings);
+  const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(
+    input.db,
+    input.workspaceId,
+    input.settings,
+  );
   const requestedTools = validateToolRefs(input.payload.agentConfig.tools ?? [], runtimeSettings);
   // A task whose creator did not choose tools gets the workspace's enabled
   // capability MCP servers, exactly like a session created without a tools
   // key. Scheduled runs are sessions too; "no MCP servers at all" was a trap
   // every pack/template instantiation path kept falling into (a maintenance
   // task that cannot reach its workspace's notebook MCP cannot do its job).
-  const tools = (input.toolsProvided ?? true)
-    ? requestedTools
-    : withDefaultEnabledCapabilityMcpTools(requestedTools, input.settings, runtimeSettings);
+  const tools =
+    (input.toolsProvided ?? true)
+      ? requestedTools
+      : withDefaultEnabledCapabilityMcpTools(requestedTools, input.settings, runtimeSettings);
   const prompt = input.payload.agentConfig.prompt.trim();
   if (!prompt) {
     throw new HTTPException(422, { message: "scheduled task prompt is required" });