@rigkit/engine 0.2.2 → 0.2.4

package/src/host-storage.ts

@@ -0,0 +1,128 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { hash } from "./hash.ts";
+import type { ProviderStorage, ProviderStorageRecord } from "./provider/types.ts";
+import type { JsonValue } from "./types.ts";
+
+export type ProviderHostStorageOptions = {
+  providerId: string;
+  rootDir?: string;
+};
+
+export type ProviderHostStorageFactory = (options: ProviderHostStorageOptions) => ProviderStorage;
+
+type ProviderHostStorageFile = {
+  providerId: string;
+  records: Record<string, Omit<ProviderStorageRecord, "providerId" | "key">>;
+};
+
+export function defaultProviderHostStorageDir(): string {
+  return process.env.RIGKIT_HOST_STORAGE_DIR ?? join(homedir(), ".rigkit", "providers");
+}
+
+export function createFileProviderHostStorage(options: ProviderHostStorageOptions): ProviderStorage {
+  return new FileProviderHostStorage(options.providerId, providerHostStoragePath(options));
+}
+
+function providerHostStoragePath(options: ProviderHostStorageOptions): string {
+  const rootDir = options.rootDir ?? defaultProviderHostStorageDir();
+  const slug = options.providerId.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "provider";
+  return join(rootDir, `${slug}-${hash(options.providerId).slice(0, 12)}.json`);
+}
+
+class FileProviderHostStorage implements ProviderStorage {
+  constructor(
+    private readonly providerId: string,
+    private readonly path: string,
+  ) {}
+
+  get<Value extends JsonValue = JsonValue>(key: string): ProviderStorageRecord<Value> | undefined {
+    const file = this.read();
+    const record = file.records[key];
+    return record
+      ? {
+        providerId: this.providerId,
+        key,
+        value: record.value as Value,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+      }
+      : undefined;
+  }
+
+  set<Value extends JsonValue = JsonValue>(key: string, value: Value): ProviderStorageRecord<Value> {
+    const file = this.read();
+    const now = new Date().toISOString();
+    const existing = file.records[key];
+    const record: ProviderStorageRecord<Value> = {
+      providerId: this.providerId,
+      key,
+      value,
+      createdAt: existing?.createdAt ?? now,
+      updatedAt: now,
+    };
+    file.records[key] = {
+      value,
+      createdAt: record.createdAt,
+      updatedAt: record.updatedAt,
+    };
+    this.write(file);
+    return record;
+  }
+
+  delete(key: string): void {
+    const file = this.read();
+    delete file.records[key];
+    this.write(file);
+  }
+
+  entries(prefix = ""): ProviderStorageRecord[] {
+    const file = this.read();
+    return Object.entries(file.records)
+      .filter(([key]) => key.startsWith(prefix))
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([key, record]) => ({
+        providerId: this.providerId,
+        key,
+        value: record.value,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+      }));
+  }
+
+  private read(): ProviderHostStorageFile {
+    if (!existsSync(this.path)) {
+      return { providerId: this.providerId, records: {} };
+    }
+
+    const parsed = JSON.parse(readFileSync(this.path, "utf8")) as unknown;
+    if (!isHostStorageFile(parsed, this.providerId)) {
+      throw new Error(`Invalid Rigkit provider host storage at ${this.path}`);
+    }
+    return parsed;
+  }
+
+  private write(file: ProviderHostStorageFile): void {
+    mkdirSync(dirname(this.path), { recursive: true, mode: 0o700 });
+    writeFileSync(this.path, `${JSON.stringify(file, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    chmodSync(this.path, 0o600);
+  }
+}
+
+function isHostStorageFile(value: unknown, providerId: string): value is ProviderHostStorageFile {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value as { providerId?: unknown; records?: unknown };
+  if (record.providerId !== providerId) return false;
+  if (!record.records || typeof record.records !== "object" || Array.isArray(record.records)) return false;
+  return Object.values(record.records).every((entry) =>
+    Boolean(
+      entry &&
+        typeof entry === "object" &&
+        !Array.isArray(entry) &&
+        typeof (entry as { createdAt?: unknown }).createdAt === "string" &&
+        typeof (entry as { updatedAt?: unknown }).updatedAt === "string" &&
+        "value" in entry
+    )
+  );
+}

package/src/index.ts

@@ -15,6 +15,10 @@ export type {
 } from "./engine.ts";
 export { createRigkitDatabase, RIGKIT_STATE_SCHEMA_VERSION, syncRigkitDatabaseSchema } from "./db/index.ts";
 export { coreSchema } from "./db/schema/index.ts";
+export {
+  createFileProviderHostStorage,
+  defaultProviderHostStorageDir,
+} from "./host-storage.ts";
 export { createStateStore } from "./state.ts";
 export { RIGKIT_ENGINE_VERSION } from "./version.ts";
 export {
@@ -30,5 +34,6 @@ export {
 } from "./authoring.ts";
 export type * from "./types.ts";
 export type { RigkitDatabase, RigkitDatabaseSchema, SchemaSyncResult } from "./db/index.ts";
+export type { ProviderHostStorageFactory, ProviderHostStorageOptions } from "./host-storage.ts";
 export type * from "./provider/types.ts";
 export type * from "./state.ts";

package/src/provider/types.ts

@@ -7,8 +7,6 @@ import type {
   LoadedProviderDefinition,
   LocalWorkspaceRuntime,
   MaybePromise,
-  ProviderWorkspaceContext,
-  WorkspaceRecord,
 } from "../types.ts";
 
 export type VmHandle = {
@@ -33,9 +31,7 @@ export type SshConnection = {
   command: string;
 };
 
-export interface BaseDevMachineProvider<
-  WorkspaceContext extends ProviderWorkspaceContext = ProviderWorkspaceContext,
-> {
+export interface BaseDevMachineProvider {
   readonly providerId: string;
   createVm(): Promise<VmHandle>;
   createVmFromSnapshot(input: { snapshotId: string }): Promise<VmHandle>;
@@ -44,7 +40,6 @@ export interface BaseDevMachineProvider<
   writeFile(vm: VmHandle, path: string, content: string): Promise<void>;
   snapshot(vm: VmHandle): Promise<SnapshotHandle>;
   ssh(vm: VmHandle, options?: SshOptions): Promise<SshConnection>;
-  workspaceContext?(vm: VmHandle, input: { workspace: WorkspaceRecord }): MaybePromise<WorkspaceContext>;
   deleteVm(vm: VmHandle): Promise<void>;
 }
 
@@ -78,38 +73,17 @@ export type ProviderRuntimeContext = {
   metadata(metadata: JsonObject): void;
 };
 
-export type WorkflowWorkspaceCreateResult = {
-  providerId?: string;
-  resourceId: string;
-  snapshotId?: string;
-  sourceRef?: JsonValue;
-  metadata?: JsonObject;
-};
-
-export interface WorkflowWorkspaceProvider<
-  WorkspaceContext extends ProviderWorkspaceContext = ProviderWorkspaceContext,
-> {
-  canUse(sourceRef: JsonValue): boolean;
-  createWorkspace(sourceRef: JsonValue, input: { name: string }): Promise<WorkflowWorkspaceCreateResult>;
-  deleteWorkspace(workspace: WorkspaceRecord): Promise<void>;
-  snapshotWorkspace(workspace: WorkspaceRecord): Promise<WorkflowWorkspaceCreateResult>;
-  ssh(workspaceOrResourceId: string, options?: SshOptions): Promise<SshConnection>;
-  workspaceContext?(workspace: WorkspaceRecord): MaybePromise<WorkspaceContext>;
-}
-
-export interface WorkflowProviderController<
-  Runtime = unknown,
-  WorkspaceContext extends ProviderWorkspaceContext = ProviderWorkspaceContext,
-> {
+export interface WorkflowProviderController<Runtime = unknown> {
   readonly providerId: string;
   runtime(context: ProviderRuntimeContext): MaybePromise<Runtime>;
   validateArtifact?(ref: JsonValue): MaybePromise<boolean>;
-  workspace?: WorkflowWorkspaceProvider<WorkspaceContext>;
 }
 
 export type ProviderFactoryInput = {
   provider: LoadedProviderDefinition;
   storage: ProviderStorage;
+  hostStorage: ProviderStorage;
+  local: LocalWorkspaceRuntime;
 };
 
 export type ProviderFactory = (

package/src/state.ts

@@ -1,5 +1,5 @@
 import { join } from "node:path";
-import { and, asc, desc, eq, or } from "drizzle-orm";
+import { and, asc, desc, eq } from "drizzle-orm";
 import type { ProviderStorage, ProviderStorageRecord } from "./provider/types.ts";
 import type { JsonValue, WorkspaceRecord } from "./types.ts";
 import {
@@ -60,6 +60,10 @@ export interface StateService {
     upstreamRunIds: readonly string[];
   }): WorkflowNodeRunRecord | undefined;
   saveNodeRun(run: WorkflowNodeRunRecord): void;
+  invalidateNodeRuns(input: {
+    workflow: string;
+    nodePaths: readonly string[];
+  }): string[];
   providerStorage(providerId: string): ProviderStorage;
 }
 
@@ -96,7 +100,7 @@ export class StateStore implements StateService {
     const row = this.db
       .select()
       .from(workspaces)
-      .where(or(eq(workspaces.name, nameOrResourceId), eq(workspaces.resourceId, nameOrResourceId)))
+      .where(eq(workspaces.name, nameOrResourceId))
       .get();
     return row ? toWorkspaceRecord(row) : undefined;
   }
@@ -114,14 +118,10 @@ export class StateStore implements StateService {
         target: workspaces.name,
         set: {
           id: workspace.id,
-          providerId: workspace.providerId,
           workflow: workspace.workflow,
-          resourceId: workspace.resourceId,
-          snapshotId: workspace.snapshotId,
-          sourceRef: workspace.sourceRef,
-          context: workspace.context,
+          workflowCtx: workspace.workflowCtx,
           updatedAt: workspace.updatedAt,
-          metadata: workspace.metadata,
+          ctx: workspace.ctx,
         },
       })
       .run();
@@ -174,6 +174,42 @@ export class StateStore implements StateService {
     this.db.insert(workflowNodeRuns).values(run).run();
   }
 
+  invalidateNodeRuns(input: {
+    workflow: string;
+    nodePaths: readonly string[];
+  }): string[] {
+    const targetPaths = new Set(input.nodePaths);
+    if (targetPaths.size === 0) return [];
+
+    const rows = this.db
+      .select()
+      .from(workflowNodeRuns)
+      .where(eq(workflowNodeRuns.workflow, input.workflow))
+      .orderBy(asc(workflowNodeRuns.createdAt))
+      .all()
+      .map(toNodeRunRecord);
+
+    const invalidatedIds = new Set<string>();
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const row of rows) {
+        if (row.invalidated || invalidatedIds.has(row.id)) continue;
+        const isTarget = targetPaths.has(row.nodePath);
+        const dependsOnInvalidated = row.upstreamRunIds.some((id) => invalidatedIds.has(id));
+        if (!isTarget && !dependsOnInvalidated) continue;
+        invalidatedIds.add(row.id);
+        changed = true;
+      }
+    }
+
+    for (const id of invalidatedIds) {
+      this.db.update(workflowNodeRuns).set({ invalidated: true }).where(eq(workflowNodeRuns.id, id)).run();
+    }
+
+    return [...invalidatedIds];
+  }
+
   providerStorage(providerId: string): ProviderStorage {
     return new StateProviderStorage(this.db, providerId);
   }
@@ -218,15 +254,11 @@ function toWorkspaceRecord(row: typeof workspaces.$inferSelect): WorkspaceRecord
   return {
     id: row.id,
     name: row.name,
-    providerId: row.providerId,
     workflow: row.workflow,
-    resourceId: row.resourceId,
-    snapshotId: row.snapshotId ?? undefined,
-    sourceRef: row.sourceRef,
-    context: row.context,
+    workflowCtx: row.workflowCtx,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt,
-    metadata: row.metadata,
+    ctx: row.ctx,
   };
 }