@osolmaz/pi-workflows 0.12.1 → 0.13.0

package/src/controllers/store.ts

@@ -1,7 +1,3 @@
-import { createHash } from "node:crypto";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
 import type {
   ChildWorkflowRecord,
   ControllerEvent,
@@ -13,8 +9,6 @@ import type {
   JsonObject,
 } from "./types.js";
 
-export const CONTROLLER_STORE_SCHEMA = "pi-workflows.controller-store.v1" as const;
-
 export type QueueRequeueOptions = {
   availableAt: string;
   error?: string;
@@ -65,6 +59,7 @@ export interface ControllerStore {
   updateStatus<TStatus>(options: {
     ref: ControllerResourceRef;
     expectedResourceVersion: number;
+    claim: ControllerQueueClaim;
     status: ControllerResourceStatus<TStatus>;
     finalizers?: string[];
     now?: string;
@@ -76,11 +71,16 @@ export interface ControllerStore {
     finalizers: string[];
     now?: string;
   }): ControllerResource;
-  deleteResource(ref: ControllerResourceRef, expectedResourceVersion: number): boolean;
+  deleteResource(
+    ref: ControllerResourceRef,
+    expectedResourceVersion: number,
+    claim: ControllerQueueClaim,
+  ): boolean;
 
   enqueue(ref: ControllerResourceRef, availableAt?: string): void;
   claimNext(options: {
     controllers: string[];
+    ownerId: string;
     leaseMs: number;
     now?: string;
   }): ControllerQueueClaim | undefined;
@@ -92,6 +92,7 @@ export interface ControllerStore {
   reserveEffect(options: {
     key: string;
     resourceUid: string;
+    claim: ControllerQueueClaim;
     generation: number;
     kind: string;
     requestFingerprint: string;
@@ -101,6 +102,7 @@ export interface ControllerStore {
   updateEffect(options: {
     resourceUid: string;
     key: string;
+    claim: ControllerQueueClaim;
     state: EffectRecord["state"];
     externalRef?: string;
     error?: string;
@@ -110,51 +112,28 @@ export interface ControllerStore {
 
   reserveWorkflow(options: {
     resourceUid: string;
+    claim: ControllerQueueClaim;
     requestKey: string;
     workflow: string;
     inputFingerprint: string;
   }): WorkflowReservation;
   getWorkflow(resourceUid: string, requestKey: string): ChildWorkflowRecord | undefined;
   getWorkflowByRequestId(requestId: string): ChildWorkflowRecord | undefined;
-  updateWorkflow(requestId: string, update: WorkflowRecordUpdate): ChildWorkflowRecord;
+  updateWorkflow(
+    requestId: string,
+    update: WorkflowRecordUpdate,
+    claim: ControllerQueueClaim,
+  ): ChildWorkflowRecord;
+  completeWorkflow(requestId: string, update: WorkflowRecordUpdate): ChildWorkflowRecord;
   listWorkflows(resourceUid: string): ChildWorkflowRecord[];
 
   recordEvent(options: {
     controller: string;
     key: string;
+    claim?: ControllerQueueClaim;
     type: string;
     payload?: JsonObject;
     now?: string;
   }): ControllerEvent;
   listEvents(options?: { controller?: string; key?: string; limit?: number }): ControllerEvent[];
 }
-
-export function controllerStoreBaseDir(homeDir: string = os.homedir()): string {
-  const override = process.env.PI_WORKFLOWS_CONTROLLER_DIR;
-  if (override !== undefined && override.length > 0) {
-    return override;
-  }
-  return path.join(homeDir, ".pi", "agent", "workflows", "controllers");
-}
-
-export function controllerStorePath(homeDir: string = os.homedir()): string {
-  return path.join(controllerStoreBaseDir(homeDir), "controller.sqlite");
-}
-
-export function controllerProjectScope(cwd: string): string {
-  let canonicalCwd: string;
-  try {
-    canonicalCwd = fs.realpathSync.native(cwd);
-  } catch {
-    canonicalCwd = path.resolve(cwd);
-  }
-  return createHash("sha256").update(canonicalCwd).digest("hex").slice(0, 24);
-}
-
-export function projectControllerStoreBaseDir(cwd: string, homeDir: string = os.homedir()): string {
-  return path.join(controllerStoreBaseDir(homeDir), "projects", controllerProjectScope(cwd));
-}
-
-export function projectControllerStorePath(cwd: string, homeDir: string = os.homedir()): string {
-  return path.join(projectControllerStoreBaseDir(cwd, homeDir), "controller.sqlite");
-}

package/src/controllers/types.ts

@@ -167,8 +167,11 @@ export type AnyControllerDefinition = {
 export type ControllerQueueClaim = {
   controller: string;
   key: string;
+  ownerId: string;
   token: string;
+  generation: number;
   queueVersion: number;
+  resourceVersion: number;
   consecutiveErrors: number;
   expiresAt: string;
 };

package/src/controllers/workflow-engine-scheduler.ts

@@ -1,5 +1,5 @@
 import { WorkflowEngine } from "../workflows/engine.js";
-import { readLastTraceEvent, readRunBundle, type WorkflowRunStore } from "../workflows/store.js";
+import type { WorkflowRunStore } from "../workflows/store.js";
 import type {
   WorkflowDefinition,
   WorkflowRunResult,
@@ -47,17 +47,14 @@ export class WorkflowEngineScheduler implements ControllerWorkflowScheduler {
       return { state: "running", runId: active.runId };
     }
 
-    const bundle = await readRunBundle(this.options.store.runDirFor(request.runId));
+    const bundle = this.options.store.readRun(request.runId, { includeTrace: true });
     if (bundle !== null) {
       const recovered =
         bundle.state.status === "running"
           ? await this.options.store.markRunInterrupted(request.runId)
           : bundle;
       if (recovered !== null) {
-        const lastTraceEvent = await readLastTraceEvent(
-          recovered.runDir,
-          recovered.manifest.paths.trace,
-        );
+        const lastTraceEvent = recovered.traceEvents?.at(-1) ?? null;
         return resultFromStatus(
           recovered.state.status,
           request.runId,
@@ -68,7 +65,6 @@ export class WorkflowEngineScheduler implements ControllerWorkflowScheduler {
       return { state: "pending" };
     }
 
-    await this.options.store.quarantineIncompleteRun(request.runId);
     const resolved = await this.options.resolveWorkflow(request.workflow);
     if (signal.aborted) {
       throw signal.reason ?? new Error("Workflow scheduling aborted");
@@ -112,7 +108,7 @@ function callCompletion(
   try {
     callback(result);
   } catch {
-    // A later reconciliation recovers completion from the immutable run bundle.
+    // A later reconciliation recovers completion from the immutable run event.
   }
 }
 

package/src/controllers/workflows.ts

@@ -5,6 +5,7 @@ import type {
   ChildWorkflowRecord,
   ChildWorkflowRequest,
   ChildWorkflowState,
+  ControllerQueueClaim,
   ControllerResource,
   ControllerWorkflows,
 } from "./types.js";
@@ -37,9 +38,13 @@ export class ControllerWorkflowCoordinator {
     private readonly scheduler?: ControllerWorkflowScheduler,
   ) {}
 
-  forResource(resource: ControllerResource, signal: AbortSignal): ControllerWorkflows {
+  forResource(
+    resource: ControllerResource,
+    claim: ControllerQueueClaim,
+    signal: AbortSignal,
+  ): ControllerWorkflows {
     return {
-      ensure: async (request) => await this.ensure(resource, request, signal),
+      ensure: async (request) => await this.ensure(resource, claim, request, signal),
     };
   }
 
@@ -48,24 +53,25 @@ export class ControllerWorkflowCoordinator {
     if (previous === undefined) {
       throw new Error(`Workflow request not found: ${requestId}`);
     }
-    const record = this.store.updateWorkflow(requestId, {
+    const record = this.store.completeWorkflow(requestId, {
       state: result.state,
       ...(result.runId !== undefined ? { runId: result.runId } : {}),
       ...(result.error !== undefined ? { error: result.error } : { error: null }),
     });
     this.enqueueParent(record.resourceUid);
-    this.recordEvent(record, "workflow_state_changed");
     return record;
   }
 
   private async ensure(
     resource: ControllerResource,
+    claim: ControllerQueueClaim,
     request: ChildWorkflowRequest,
     signal: AbortSignal,
   ): Promise<ChildWorkflowRecord> {
     const inputFingerprint = jsonFingerprint(request.input);
     const reservation = this.store.reserveWorkflow({
       resourceUid: resource.metadata.uid,
+      claim,
       requestKey: request.requestKey,
       workflow: request.workflow,
       inputFingerprint,
@@ -78,18 +84,26 @@ export class ControllerWorkflowCoordinator {
       return record;
     }
     if (record.state === "interrupted" || record.attempt === 0) {
-      record = this.store.updateWorkflow(record.requestId, {
-        state: "pending",
-        attempt: record.attempt + 1,
-        runId: createRunId(record.workflow),
-        error: null,
-      });
+      record = this.store.updateWorkflow(
+        record.requestId,
+        {
+          state: "pending",
+          attempt: record.attempt + 1,
+          runId: createRunId(record.workflow),
+          error: null,
+        },
+        claim,
+      );
     } else if (record.runId === undefined) {
-      record = this.store.updateWorkflow(record.requestId, {
-        state: "pending",
-        runId: createRunId(record.workflow),
-        error: null,
-      });
+      record = this.store.updateWorkflow(
+        record.requestId,
+        {
+          state: "pending",
+          runId: createRunId(record.workflow),
+          error: null,
+        },
+        claim,
+      );
     }
     if (record.runId === undefined) {
       throw new Error(`Workflow request has no reserved run ID: ${record.requestId}`);
@@ -107,15 +121,20 @@ export class ControllerWorkflowCoordinator {
         this.complete(record.requestId, completed);
       },
     );
-    record = this.store.updateWorkflow(record.requestId, {
-      state: result.state,
-      ...(result.runId !== undefined ? { runId: result.runId } : {}),
-      ...(result.error !== undefined ? { error: result.error } : { error: null }),
-    });
+    record = this.store.updateWorkflow(
+      record.requestId,
+      {
+        state: result.state,
+        ...(result.runId !== undefined ? { runId: result.runId } : {}),
+        ...(result.error !== undefined ? { error: result.error } : { error: null }),
+      },
+      claim,
+    );
     if (reservation.created || result.state !== "running") {
       this.recordEvent(
         record,
         reservation.created ? "workflow_requested" : "workflow_state_changed",
+        claim,
       );
     }
     return record;
@@ -131,7 +150,11 @@ export class ControllerWorkflowCoordinator {
     }
   }
 
-  private recordEvent(record: ChildWorkflowRecord, type: string): void {
+  private recordEvent(
+    record: ChildWorkflowRecord,
+    type: string,
+    claim: ControllerQueueClaim,
+  ): void {
     const resource = this.store.getResourceByUid(record.resourceUid);
     if (resource === undefined) {
       return;
@@ -139,6 +162,7 @@ export class ControllerWorkflowCoordinator {
     this.store.recordEvent({
       controller: resource.metadata.controller,
       key: resource.metadata.key,
+      claim,
       type,
       payload: {
         requestId: record.requestId,

package/src/extension/controller-host.ts

@@ -1,7 +1,6 @@
 import {
   ControllerManager,
   SqliteControllerStore,
-  projectControllerStorePath,
   loadDiscoveredControllers,
   type AnyControllerDefinition,
   type ControllerResource,
@@ -86,7 +85,7 @@ export class PiControllerHost {
     if (definitions.length === 0) {
       return undefined;
     }
-    const store = new SqliteControllerStore(projectControllerStorePath(options.cwd));
+    const store = new SqliteControllerStore(undefined, { projectPath: options.cwd });
     const manager = new ControllerManager({
       store,
       controllers: definitions,