@rigkit/engine 0.1.8

package/src/env-file.ts

@@ -0,0 +1,52 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+export function loadDotEnv(projectDir: string): void {
+  for (const path of findDotEnvFiles(projectDir)) {
+    loadDotEnvFile(path);
+  }
+}
+
+function loadDotEnvFile(path: string): void {
+  const content = readFileSync(path, "utf8");
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+
+    const match = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/.exec(line);
+    if (!match) continue;
+
+    const [, key, rawValue] = match;
+    if (process.env[key] !== undefined) continue;
+
+    process.env[key] = parseEnvValue(rawValue);
+  }
+}
+
+function findDotEnvFiles(projectDir: string): string[] {
+  const files: string[] = [];
+  let current = projectDir;
+
+  while (true) {
+    const candidate = join(current, ".env");
+    if (existsSync(candidate)) files.unshift(candidate);
+
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+
+  return files;
+}
+
+function parseEnvValue(rawValue: string): string {
+  const trimmed = rawValue.trim();
+  if (
+    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+    (trimmed.startsWith("'") && trimmed.endsWith("'"))
+  ) {
+    return trimmed.slice(1, -1);
+  }
+
+  return trimmed;
+}

package/src/hash.ts

@@ -0,0 +1,21 @@
+import { createHash } from "node:crypto";
+
+export function stableJson(value: unknown): string {
+  return JSON.stringify(sortValue(value));
+}
+
+export function hash(value: unknown): string {
+  return createHash("sha256").update(stableJson(value)).digest("hex");
+}
+
+function sortValue(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(sortValue);
+  if (!value || typeof value !== "object") return value;
+
+  return Object.fromEntries(
+    Object.entries(value as Record<string, unknown>)
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([key, inner]) => [key, sortValue(inner)]),
+  );
+}
+

package/src/index.ts

@@ -0,0 +1,34 @@
+export { createDevMachineEngine, DevMachineEngine } from "./engine.ts";
+export {
+  EngineOperationNotFoundError,
+  EngineOperationValidationError,
+} from "./engine.ts";
+export type {
+  EngineOperationCli,
+  EngineOperationCliOption,
+  EngineOperationCliPosition,
+  EngineOperationKind,
+  EngineOperationSource,
+  EngineOperationSummary,
+  InteractionPresenter,
+  InteractionPresentationRequest,
+} from "./engine.ts";
+export { createRigkitDatabase, RIGKIT_STATE_SCHEMA_VERSION, syncRigkitDatabaseSchema } from "./db/index.ts";
+export { coreSchema } from "./db/schema/index.ts";
+export { createStateStore } from "./state.ts";
+export { RIGKIT_ENGINE_VERSION } from "./version.ts";
+export {
+  defineConfig,
+  defineProvider,
+  env,
+  isRigkitConfig,
+  isProviderDefinition,
+  isWorkflow,
+  isWorkflowNode,
+  sequence,
+  workflow,
+} from "./authoring.ts";
+export type * from "./types.ts";
+export type { RigkitDatabase, RigkitDatabaseSchema, SchemaSyncResult } from "./db/index.ts";
+export type * from "./provider/types.ts";
+export type * from "./state.ts";

package/src/provider/types.ts

@@ -0,0 +1,139 @@
+import type {
+  EventHandler,
+  ExecOptions,
+  ExecResult,
+  JsonObject,
+  JsonValue,
+  LoadedProviderDefinition,
+  LocalWorkspaceRuntime,
+  MaybePromise,
+  ProviderWorkspaceContext,
+  WorkspaceRecord,
+} from "../types.ts";
+
+export type VmHandle = {
+  vmId: string;
+};
+
+export type SnapshotHandle = {
+  snapshotId: string;
+  sourceVmId: string;
+};
+
+export type SshOptions = {
+  user?: string;
+};
+
+export type SshConnection = {
+  kind: "ssh";
+  host: string;
+  port?: number;
+  username: string;
+  auth: { type: "token"; token: string } | { type: "privateKey"; privateKey: string };
+  command: string;
+};
+
+export interface BaseDevMachineProvider<
+  WorkspaceContext extends ProviderWorkspaceContext = ProviderWorkspaceContext,
+> {
+  readonly providerId: string;
+  createVm(): Promise<VmHandle>;
+  createVmFromSnapshot(input: { snapshotId: string }): Promise<VmHandle>;
+  exec(vm: VmHandle, command: string, options?: ExecOptions): Promise<ExecResult>;
+  readFile(vm: VmHandle, path: string): Promise<string>;
+  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>;
+}
+
+export type InteractionPresentationRequest = {
+  id: string;
+  nodePath: string;
+  title: string;
+  url: string;
+  instructions?: string;
+};
+
+export type InteractionPresenter = (request: InteractionPresentationRequest) => Promise<void>;
+
+export type ProviderInteractionSession<Result = void> = {
+  id?: string;
+  title: string;
+  url: string;
+  instructions?: string;
+  completed: Promise<Result>;
+  stop(): MaybePromise<void>;
+};
+
+export type ProviderRuntimeContext = {
+  workflow: string;
+  nodePath: string;
+  emit: EventHandler;
+  interaction: {
+    present<Result>(session: ProviderInteractionSession<Result>): Promise<Result>;
+  };
+  local: LocalWorkspaceRuntime;
+  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,
+> {
+  readonly providerId: string;
+  runtime(context: ProviderRuntimeContext): MaybePromise<Runtime>;
+  validateArtifact?(ref: JsonValue): MaybePromise<boolean>;
+  workspace?: WorkflowWorkspaceProvider<WorkspaceContext>;
+}
+
+export type ProviderFactoryInput = {
+  provider: LoadedProviderDefinition;
+  storage: ProviderStorage;
+};
+
+export type ProviderFactory = (
+  input: ProviderFactoryInput,
+) => WorkflowProviderController | Promise<WorkflowProviderController>;
+
+export type ProviderStorageRecord<Value extends JsonValue = JsonValue> = {
+  providerId: string;
+  key: string;
+  value: Value;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export interface ProviderStorage {
+  get<Value extends JsonValue = JsonValue>(key: string): ProviderStorageRecord<Value> | undefined;
+  set<Value extends JsonValue = JsonValue>(key: string, value: Value): ProviderStorageRecord<Value>;
+  delete(key: string): void;
+  entries(prefix?: string): ProviderStorageRecord[];
+}
+
+export type BaseProviderPlugin = {
+  providerId: string;
+  createProvider(input: ProviderFactoryInput): WorkflowProviderController | Promise<WorkflowProviderController>;
+};
+
+export type DevMachineProvider = BaseDevMachineProvider;

package/src/state.ts

@@ -0,0 +1,318 @@
+import { join } from "node:path";
+import { and, asc, desc, eq, or } from "drizzle-orm";
+import type { ProviderStorage, ProviderStorageRecord } from "./provider/types.ts";
+import type { JsonValue, WorkspaceRecord } from "./types.ts";
+import {
+  createRigkitDatabase,
+  syncRigkitDatabaseSchema,
+  type RigkitDatabase,
+  type SchemaSyncResult,
+} from "./db/index.ts";
+import { coreSchema, type CoreSchema } from "./db/schema/index.ts";
+import { providerState, runtimeMetadata, workflowNodeRuns, workspaces } from "./db/schema/index.ts";
+import { stableJson } from "./hash.ts";
+import { RIGKIT_ENGINE_VERSION } from "./version.ts";
+
+export type WorkflowNodeRunRecord = {
+  id: string;
+  workflow: string;
+  nodePath: string;
+  nodeName: string;
+  nodeKind: string;
+  nodeKey: string;
+  providerFingerprint: string;
+  upstreamRunIds: string[];
+  output: Record<string, JsonValue>;
+  artifacts: JsonValue[];
+  invalidated: boolean;
+  createdAt: string;
+  metadata: Record<string, JsonValue>;
+};
+
+export type SnapshotRecord = WorkflowNodeRunRecord;
+
+export type StateServiceOptions = {
+  projectDir: string;
+  statePath?: string;
+  projectId?: string;
+  configPath?: string;
+  runtimeVersion?: string;
+  source?: JsonValue;
+};
+
+export type StateServiceFactory = (options: StateServiceOptions) => StateService;
+
+export interface StateService {
+  readonly path: string;
+  syncSchema(): Promise<SchemaSyncResult>;
+  listWorkspaces(): WorkspaceRecord[];
+  findWorkspace(nameOrResourceId: string): WorkspaceRecord | undefined;
+  getWorkspace(name: string): WorkspaceRecord | undefined;
+  saveWorkspace(workspace: WorkspaceRecord): void;
+  deleteWorkspace(name: string): void;
+  listNodeRuns(): WorkflowNodeRunRecord[];
+  listSnapshots(): SnapshotRecord[];
+  findReusableNodeRun(input: {
+    workflow: string;
+    nodePath: string;
+    nodeKey: string;
+    providerFingerprint: string;
+    upstreamRunIds: readonly string[];
+  }): WorkflowNodeRunRecord | undefined;
+  saveNodeRun(run: WorkflowNodeRunRecord): void;
+  providerStorage(providerId: string): ProviderStorage;
+}
+
+export class StateStore implements StateService {
+  readonly path: string;
+  readonly db: RigkitDatabase<CoreSchema>;
+  private readonly schema = coreSchema;
+  private readonly projectDir: string;
+  private readonly metadata: Omit<StateServiceOptions, "projectDir" | "statePath">;
+  private schemaSync?: Promise<SchemaSyncResult>;
+
+  constructor(projectDir: string, options: Omit<StateServiceOptions, "projectDir"> = {}) {
+    this.projectDir = projectDir;
+    this.path = options.statePath ?? join(projectDir, ".rigkit", "state.sqlite");
+    this.metadata = {
+      projectId: options.projectId,
+      configPath: options.configPath,
+      runtimeVersion: options.runtimeVersion,
+      source: options.source,
+    };
+    this.db = createRigkitDatabase(this.path, { schema: this.schema });
+  }
+
+  async syncSchema(): Promise<SchemaSyncResult> {
+    this.schemaSync ??= this.syncSchemaOnce();
+    return await this.schemaSync;
+  }
+
+  listWorkspaces(): WorkspaceRecord[] {
+    return this.db.select().from(workspaces).orderBy(asc(workspaces.name)).all().map(toWorkspaceRecord);
+  }
+
+  findWorkspace(nameOrResourceId: string): WorkspaceRecord | undefined {
+    const row = this.db
+      .select()
+      .from(workspaces)
+      .where(or(eq(workspaces.name, nameOrResourceId), eq(workspaces.resourceId, nameOrResourceId)))
+      .get();
+    return row ? toWorkspaceRecord(row) : undefined;
+  }
+
+  getWorkspace(name: string): WorkspaceRecord | undefined {
+    const row = this.db.select().from(workspaces).where(eq(workspaces.name, name)).get();
+    return row ? toWorkspaceRecord(row) : undefined;
+  }
+
+  saveWorkspace(workspace: WorkspaceRecord): void {
+    this.db
+      .insert(workspaces)
+      .values(workspace)
+      .onConflictDoUpdate({
+        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,
+          updatedAt: workspace.updatedAt,
+          metadata: workspace.metadata,
+        },
+      })
+      .run();
+  }
+
+  deleteWorkspace(name: string): void {
+    this.db.delete(workspaces).where(eq(workspaces.name, name)).run();
+  }
+
+  listNodeRuns(): WorkflowNodeRunRecord[] {
+    return this.db
+      .select()
+      .from(workflowNodeRuns)
+      .orderBy(desc(workflowNodeRuns.createdAt))
+      .all()
+      .map(toNodeRunRecord);
+  }
+
+  listSnapshots(): SnapshotRecord[] {
+    return this.listNodeRuns();
+  }
+
+  findReusableNodeRun(input: {
+    workflow: string;
+    nodePath: string;
+    nodeKey: string;
+    providerFingerprint: string;
+    upstreamRunIds: readonly string[];
+  }): WorkflowNodeRunRecord | undefined {
+    const upstream = stableJson([...input.upstreamRunIds]);
+    const candidates = this.db
+      .select()
+      .from(workflowNodeRuns)
+      .where(eq(workflowNodeRuns.workflow, input.workflow))
+      .orderBy(desc(workflowNodeRuns.createdAt))
+      .all()
+      .filter((run) =>
+        !run.invalidated &&
+        run.nodePath === input.nodePath &&
+        run.nodeKey === input.nodeKey &&
+        run.providerFingerprint === input.providerFingerprint &&
+        stableJson(run.upstreamRunIds) === upstream
+      );
+
+    const row = candidates[0];
+    return row ? toNodeRunRecord(row) : undefined;
+  }
+
+  saveNodeRun(run: WorkflowNodeRunRecord): void {
+    this.db.insert(workflowNodeRuns).values(run).run();
+  }
+
+  providerStorage(providerId: string): ProviderStorage {
+    return new StateProviderStorage(this.db, providerId);
+  }
+
+  private async syncSchemaOnce(): Promise<SchemaSyncResult> {
+    const result = await syncRigkitDatabaseSchema(this.db, this.schema);
+    this.writeRuntimeMetadata(result.schemaVersion);
+    return result;
+  }
+
+  private writeRuntimeMetadata(schemaVersion: string): void {
+    const now = new Date().toISOString();
+    const entries: Array<[string, JsonValue]> = [
+      ["engine.version", RIGKIT_ENGINE_VERSION],
+      ["state.schemaVersion", schemaVersion],
+      ["project.dir", this.projectDir],
+      ["state.path", this.path],
+    ];
+
+    if (this.metadata.projectId) entries.push(["project.id", this.metadata.projectId]);
+    if (this.metadata.configPath) entries.push(["config.path", this.metadata.configPath]);
+    if (this.metadata.runtimeVersion) entries.push(["runtime.version", this.metadata.runtimeVersion]);
+    if (this.metadata.source !== undefined) entries.push(["source", this.metadata.source]);
+
+    for (const [key, value] of entries) {
+      this.db
+        .insert(runtimeMetadata)
+        .values({ key, value, updatedAt: now })
+        .onConflictDoUpdate({
+          target: runtimeMetadata.key,
+          set: { value, updatedAt: now },
+        })
+        .run();
+    }
+  }
+}
+
+export const createStateStore: StateServiceFactory = (options) =>
+  new StateStore(options.projectDir, options);
+
+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,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    metadata: row.metadata,
+  };
+}
+
+function toNodeRunRecord(row: typeof workflowNodeRuns.$inferSelect): WorkflowNodeRunRecord {
+  return {
+    id: row.id,
+    workflow: row.workflow,
+    nodePath: row.nodePath,
+    nodeName: row.nodeName,
+    nodeKind: row.nodeKind,
+    nodeKey: row.nodeKey,
+    providerFingerprint: row.providerFingerprint,
+    upstreamRunIds: row.upstreamRunIds,
+    output: row.output,
+    artifacts: row.artifacts,
+    invalidated: row.invalidated,
+    createdAt: row.createdAt,
+    metadata: row.metadata,
+  };
+}
+
+class StateProviderStorage implements ProviderStorage {
+  constructor(
+    private readonly db: RigkitDatabase<CoreSchema>,
+    private readonly providerId: string,
+  ) {}
+
+  get<Value extends JsonValue = JsonValue>(key: string): ProviderStorageRecord<Value> | undefined {
+    const row = this.db
+      .select()
+      .from(providerState)
+      .where(and(eq(providerState.providerId, this.providerId), eq(providerState.key, key)))
+      .get();
+    return row ? toProviderStorageRecord(row) as ProviderStorageRecord<Value> : undefined;
+  }
+
+  set<Value extends JsonValue = JsonValue>(key: string, value: Value): ProviderStorageRecord<Value> {
+    const now = new Date().toISOString();
+    const existing = this.get(key);
+    const record: ProviderStorageRecord<Value> = {
+      providerId: this.providerId,
+      key,
+      value,
+      createdAt: existing?.createdAt ?? now,
+      updatedAt: now,
+    };
+    this.db
+      .insert(providerState)
+      .values(record)
+      .onConflictDoUpdate({
+        target: [providerState.providerId, providerState.key],
+        set: {
+          value,
+          updatedAt: record.updatedAt,
+        },
+      })
+      .run();
+    return record;
+  }
+
+  delete(key: string): void {
+    this.db
+      .delete(providerState)
+      .where(and(eq(providerState.providerId, this.providerId), eq(providerState.key, key)))
+      .run();
+  }
+
+  entries(prefix = ""): ProviderStorageRecord[] {
+    const rows = this.db
+      .select()
+      .from(providerState)
+      .where(eq(providerState.providerId, this.providerId))
+      .orderBy(asc(providerState.key))
+      .all();
+    return rows
+      .filter((row) => row.key.startsWith(prefix))
+      .map(toProviderStorageRecord);
+  }
+}
+
+function toProviderStorageRecord(row: typeof providerState.$inferSelect): ProviderStorageRecord {
+  return {
+    providerId: row.providerId,
+    key: row.key,
+    value: row.value,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}