@opengeni/worker-bundle 2.2.0 → 2.2.1-canary.36919050519001

package/dist/index.d.ts

@@ -64,6 +64,21 @@ export declare function createDefaultWorkerActivities(role: OpenGeniWorkerRole,
     } | null>;
     reconcileCodexCapacityWait: (input: import("./activities.js").ReconcileCodexCapacityWaitInput) => Promise<import("./activities.js").ReconcileCodexCapacityWaitResult>;
     maintainBrowserStateArtifacts: () => Promise<import("./activities/browser-state-artifact-reaper.js").MaintainBrowserStateArtifactsResult>;
+    listDueBrowserCheckpoints(): Promise<{
+        accountId: string;
+        workspaceId: string;
+        sandboxGroupId: string;
+        leaseId: string;
+        leaseEpoch: number;
+        instanceId: string;
+        browserSessionId: string;
+        controllerGeneration: string;
+    }[]>;
+    checkpointBrowserBeforeDeadline(target: import("@opengeni/db").BrowserDeadlineCheckpointTarget): Promise<{
+        status: "skipped";
+    } | {
+        status: "suspended";
+    }>;
     settleAutomationRunFailure: (input: import("./activities.js").DispatchAutomationRunInput) => Promise<void>;
     dispatchAutomationRun: (input: import("./activities.js").DispatchAutomationRunInput) => Promise<import("./activities.js").DispatchAutomationRunResult>;
     indexDocument: (input: import("./activities.js").IndexDocumentInput) => Promise<{

package/dist/index.js

@@ -768,6 +768,13 @@ function installWorkerUnhandledRejectionBoundary(runtimeProcess = process, repor
   return () => runtimeProcess.off("unhandledRejection", onUnhandledRejection);
 }
 
+// src/browser-deadline-checkpoint-contract.ts
+var BROWSER_DEADLINE_CHECKPOINT_SWEEP_ID = "opengeni-browser-deadline-checkpoints-v1";
+var QUEUE_SUFFIX = "-browser-checkpoint-v1";
+function browserDeadlineCheckpointTaskQueue(base) {
+  return base.endsWith(QUEUE_SUFFIX) ? base : `${base}${QUEUE_SUFFIX}`;
+}
+
 // src/index.ts
 var SANDBOX_REAPER_SCHEDULE_ID = "opengeni-sandbox-lease-reaper";
 var KNOWLEDGE_INDEXING_SCHEDULE_ID = "opengeni-knowledge-indexing";
@@ -790,7 +797,7 @@ function temporalWorkflowExecutionNotFound(error) {
   return isGrpcServiceError(error) && error.code === 5;
 }
 async function createDefaultWorkerActivities(role, dependencies = {}) {
-  return role === "control" ? (await import("./activities-control-MHNA3CYV.js")).createControlActivities(dependencies) : (await import("./activities-turn-FQ5OO2WW.js")).createTurnActivities(dependencies);
+  return role === "control" ? (await import("./activities-control-55ECL47G.js")).createControlActivities(dependencies) : (await import("./activities-turn-T7Y3BWYO.js")).createTurnActivities(dependencies);
 }
 function resolveOpenGeniWorkflowDefinition(moduleUrl = import.meta.url) {
   const modulePath = fileURLToPath(moduleUrl).replaceAll("\\", "/");
@@ -885,25 +892,34 @@ async function createOpenGeniWorker(options) {
         turnConcurrency?.admission?.finalizeStartupBaseline();
         return { worker, connection };
       }
+      const ownedWorkers = [worker];
       try {
-        const sandboxLifecycleWorker = await Worker.create({
-          ...sharedWorkerOptions,
-          ...workflowDefinition,
-          taskQueue: sandboxLifecycleTaskQueue(settings.temporalTaskQueue),
-          reuseV8Context: true,
-          workflowThreadPoolSize: 1,
-          maxCachedWorkflows: CONTROL_WORKER_MAX_CACHED_WORKFLOWS,
-          maxConcurrentWorkflowTaskExecutions: CONTROL_WORKER_MAX_CONCURRENT_WORKFLOW_TASKS,
-          maxConcurrentActivityTaskExecutions: CONTROL_WORKER_MAX_CONCURRENT_ACTIVITIES
-        });
+        for (const taskQueue of [
+          sandboxLifecycleTaskQueue(settings.temporalTaskQueue),
+          browserDeadlineCheckpointTaskQueue(settings.temporalTaskQueue)
+        ]) {
+          const lifecycleWorker = await Worker.create({
+            ...sharedWorkerOptions,
+            ...workflowDefinition,
+            taskQueue,
+            reuseV8Context: true,
+            workflowThreadPoolSize: 1,
+            maxCachedWorkflows: CONTROL_WORKER_MAX_CACHED_WORKFLOWS,
+            maxConcurrentWorkflowTaskExecutions: CONTROL_WORKER_MAX_CONCURRENT_WORKFLOW_TASKS,
+            maxConcurrentActivityTaskExecutions: CONTROL_WORKER_MAX_CONCURRENT_ACTIVITIES
+          });
+          ownedWorkers.push(lifecycleWorker);
+        }
         return {
-          worker: combineWorkerRunTargets([worker, sandboxLifecycleWorker]),
+          worker: combineWorkerRunTargets(ownedWorkers),
           connection
         };
       } catch (error) {
-        try {
-          worker.shutdown();
-        } catch {
+        for (const ownedWorker of ownedWorkers) {
+          try {
+            ownedWorker.shutdown();
+          } catch {
+          }
         }
         throw error;
       }
@@ -1012,20 +1028,26 @@ async function createWorkerWorkflowSignaler(settings, db) {
       return normalizeTurnTaskQueueStats(response.stats);
     },
     startSandboxReaperWorkflow: async () => {
-      try {
-        await temporal.workflow.start("sandboxReaperWorkflowV2", {
+      const starts = await Promise.allSettled([
+        temporal.workflow.start("sandboxReaperWorkflowV2", {
           taskQueue: sandboxLifecycleTaskQueue(settings.temporalTaskQueue),
           workflowId: SANDBOX_REAPER_V2_WORKFLOW_ID,
           workflowIdReusePolicy: "ALLOW_DUPLICATE",
           args: []
-        });
-        return "started";
-      } catch (error) {
-        if (error instanceof WorkflowExecutionAlreadyStartedError) {
-          return "already_running";
+        }),
+        temporal.workflow.start("browserDeadlineCheckpointSweepWorkflow", {
+          taskQueue: browserDeadlineCheckpointTaskQueue(settings.temporalTaskQueue),
+          workflowId: BROWSER_DEADLINE_CHECKPOINT_SWEEP_ID,
+          workflowIdReusePolicy: "ALLOW_DUPLICATE",
+          args: []
+        })
+      ]);
+      for (const start of starts) {
+        if (start.status === "rejected" && !(start.reason instanceof WorkflowExecutionAlreadyStartedError)) {
+          throw start.reason;
         }
-        throw error;
       }
+      return starts[0].status === "fulfilled" ? "started" : "already_running";
     },
     startVideoGenerationWorkflow: async ({ accountId, workspaceId, operationId }) => {
       try {