@rigkit/engine 0.0.0-canary-20260518T014918-c5bc0c2

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/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

@@ -0,0 +1,46 @@
+export { createDevMachineEngine, DevMachineEngine } from "./engine.ts";
+export {
+  EngineOperationNotFoundError,
+  EngineOperationValidationError,
+} from "./engine.ts";
+export type {
+  EngineOperationCli,
+  EngineOperationCliOption,
+  EngineOperationCliPosition,
+  EngineOperationKind,
+  EngineOperationSource,
+  EngineOperationSummary,
+  EngineCacheClearResult,
+  EngineCacheClearScope,
+  EngineCacheEntry,
+  EngineCacheList,
+  EngineCacheScope,
+  GlobalFragmentStateLocationInput,
+  GlobalFragmentStateLocator,
+  InteractionPresenter,
+  InteractionPresentationRequest,
+} 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 {
+  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 { ProviderHostStorageFactory, ProviderHostStorageOptions } from "./host-storage.ts";
+export type * from "./provider/types.ts";
+export type * from "./state.ts";

package/src/provider/types.ts

@@ -0,0 +1,113 @@
+import type {
+  EventHandler,
+  ExecOptions,
+  ExecResult,
+  JsonObject,
+  JsonValue,
+  LoadedProviderDefinition,
+  LocalWorkspaceRuntime,
+  MaybePromise,
+} 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 {
+  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>;
+  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 interface WorkflowProviderController<Runtime = unknown> {
+  readonly providerId: string;
+  runtime(context: ProviderRuntimeContext): MaybePromise<Runtime>;
+  validateArtifact?(ref: JsonValue): MaybePromise<boolean>;
+}
+
+export type ProviderFactoryInput = {
+  provider: LoadedProviderDefinition;
+  storage: ProviderStorage;
+  hostStorage: ProviderStorage;
+  local: LocalWorkspaceRuntime;
+};
+
+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;