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

package/src/console-intercept.test.ts

@@ -0,0 +1,121 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import {
+  __resetConsoleInterceptForTests,
+  runWithStepConsole,
+  type ConsoleLevel,
+  type StepConsoleSink,
+} from "./console-intercept.ts";
+
+type Captured = { level: ConsoleLevel; message: string };
+
+function collector(): { sink: StepConsoleSink; entries: Captured[] } {
+  const entries: Captured[] = [];
+  return { sink: (input) => entries.push(input), entries };
+}
+
+afterEach(() => {
+  __resetConsoleInterceptForTests();
+  delete process.env.RIGKIT_NO_CONSOLE_INTERCEPT;
+});
+
+describe("runWithStepConsole", () => {
+  test("captures console.{log,info,debug,warn,error} with the right level", async () => {
+    const { sink, entries } = collector();
+    await runWithStepConsole(sink, async () => {
+      console.log("a log line");
+      console.info("an info line");
+      console.debug("a debug line");
+      console.warn("a warn line");
+      console.error("an error line");
+    });
+
+    expect(entries).toEqual([
+      { level: "log", message: "a log line" },
+      { level: "info", message: "an info line" },
+      { level: "debug", message: "a debug line" },
+      { level: "warn", message: "a warn line" },
+      { level: "error", message: "an error line" },
+    ]);
+  });
+
+  test("formats objects and printf args like the real console", async () => {
+    const { sink, entries } = collector();
+    await runWithStepConsole(sink, async () => {
+      console.log("counts:", { a: 1, b: 2 });
+      console.log("user %s scored %d", "alice", 42);
+    });
+
+    expect(entries[0]!.message).toBe("counts: { a: 1, b: 2 }");
+    expect(entries[1]!.message).toBe("user alice scored 42");
+  });
+
+  test("preserves the scope across async boundaries", async () => {
+    const { sink, entries } = collector();
+    const inner = async () => {
+      await Promise.resolve();
+      console.log("inside async helper");
+    };
+    await runWithStepConsole(sink, async () => {
+      await inner();
+    });
+
+    expect(entries).toEqual([{ level: "log", message: "inside async helper" }]);
+  });
+
+  test("isolates concurrent step contexts", async () => {
+    const a = collector();
+    const b = collector();
+    await Promise.all([
+      runWithStepConsole(a.sink, async () => {
+        await Promise.resolve();
+        console.log("from A");
+      }),
+      runWithStepConsole(b.sink, async () => {
+        await Promise.resolve();
+        console.warn("from B");
+      }),
+    ]);
+
+    expect(a.entries).toEqual([{ level: "log", message: "from A" }]);
+    expect(b.entries).toEqual([{ level: "warn", message: "from B" }]);
+  });
+
+  test("RIGKIT_NO_CONSOLE_INTERCEPT=1 disables capture", async () => {
+    process.env.RIGKIT_NO_CONSOLE_INTERCEPT = "1";
+    const { sink, entries } = collector();
+    const consoleLogSpy: string[] = [];
+    const originalLog = console.log;
+    console.log = (...args: unknown[]) => consoleLogSpy.push(String(args[0] ?? ""));
+    try {
+      await runWithStepConsole(sink, async () => {
+        console.log("should fall through to original");
+      });
+    } finally {
+      console.log = originalLog;
+    }
+
+    expect(entries).toEqual([]);
+    expect(consoleLogSpy).toEqual(["should fall through to original"]);
+  });
+
+  test("outside the scope, console.* falls through to its original implementation", async () => {
+    const { sink, entries } = collector();
+    // Install the patch by running a scoped call once.
+    await runWithStepConsole(sink, async () => {
+      console.log("inside");
+    });
+
+    // Now call outside — should not show up in entries.
+    const originalLog = console.log;
+    const outsideCalls: unknown[][] = [];
+    console.log = (...args: unknown[]) => outsideCalls.push(args);
+    try {
+      console.log("outside");
+    } finally {
+      console.log = originalLog;
+    }
+
+    expect(entries).toEqual([{ level: "log", message: "inside" }]);
+    expect(outsideCalls).toEqual([["outside"]]);
+  });
+});

package/src/console-intercept.ts

@@ -0,0 +1,75 @@
+// Captures `console.log` / `info` / `debug` / `warn` / `error` invoked inside a
+// step handler and routes the output through that step's logger. This lets
+// users write `console.log("foo")` instead of threading `step.log` through
+// every helper, and surfaces third-party SDK output for free.
+//
+// Scoped via AsyncLocalStorage so:
+//   - Engine/runtime code that itself uses `console.*` is never touched.
+//   - Concurrent step executions each get their own logger.
+//
+// Disabled by `RIGKIT_NO_CONSOLE_INTERCEPT=1`.
+
+import { AsyncLocalStorage } from "node:async_hooks";
+import { formatWithOptions } from "node:util";
+
+export type ConsoleLevel = "debug" | "info" | "log" | "warn" | "error";
+
+export type StepConsoleSink = (input: { level: ConsoleLevel; message: string }) => void;
+
+type ConsoleMethod = "debug" | "info" | "log" | "warn" | "error";
+
+const METHODS: readonly ConsoleMethod[] = ["debug", "info", "log", "warn", "error"] as const;
+const STORAGE = new AsyncLocalStorage<StepConsoleSink>();
+
+let installed = false;
+const originalMethods: Partial<Record<ConsoleMethod, (...args: unknown[]) => void>> = {};
+
+export function runWithStepConsole<T>(sink: StepConsoleSink, fn: () => Promise<T> | T): Promise<T> | T {
+  if (process.env.RIGKIT_NO_CONSOLE_INTERCEPT === "1") return fn();
+  ensureInstalled();
+  return STORAGE.run(sink, fn);
+}
+
+function ensureInstalled(): void {
+  if (installed) return;
+  installed = true;
+
+  // util.formatWithOptions colors based on the second arg. We disable colors so
+  // the captured output is plain (the CLI presenter colors it on the render
+  // side based on level, which is the right place for terminal styling).
+  const formatOptions = { colors: false, depth: 4, breakLength: 80 } as const;
+
+  for (const method of METHODS) {
+    const original = console[method].bind(console);
+    originalMethods[method] = original;
+    console[method] = (...args: unknown[]) => {
+      const sink = STORAGE.getStore();
+      if (!sink) {
+        original(...args);
+        return;
+      }
+      try {
+        const message = formatWithOptions(formatOptions, ...args);
+        sink({ level: methodToLevel(method), message });
+      } catch {
+        // If formatting fails, fall back to the original so users at least see
+        // something instead of swallowing their log.
+        original(...args);
+      }
+    };
+  }
+}
+
+function methodToLevel(method: ConsoleMethod): ConsoleLevel {
+  return method;
+}
+
+// Test-only: restore the original console methods. Not exported from the
+// package's public surface but used by engine.test.ts.
+export function __resetConsoleInterceptForTests(): void {
+  for (const method of METHODS) {
+    const original = originalMethods[method];
+    if (original) console[method] = original;
+  }
+  installed = false;
+}

package/src/db/index.ts

@@ -0,0 +1,157 @@
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { Database } from "bun:sqlite";
+import { drizzle, type BunSQLiteDatabase } from "drizzle-orm/bun-sqlite";
+import { coreSchema, type CoreSchema } from "./schema/index.ts";
+
+export const RIGKIT_STATE_SCHEMA_VERSION = "drizzle-push";
+
+export type RigkitDatabase<TSchema extends Record<string, unknown> = CoreSchema> =
+  BunSQLiteDatabase<TSchema> & { $client: Database };
+
+export type RigkitDatabaseSchema = Record<string, unknown>;
+
+export type CreateRigkitDatabaseOptions<TSchema extends RigkitDatabaseSchema = CoreSchema> = {
+  schema?: TSchema;
+};
+
+export type SchemaSyncResult = {
+  applied: string[];
+  schemaVersion: string;
+  statements: string[];
+  warnings: string[];
+  hasDataLoss: boolean;
+};
+
+type DrizzleKitBunSQLiteDatabase = Pick<RigkitDatabase<RigkitDatabaseSchema>, "all" | "run">;
+
+type PushSQLiteSchemaResult = {
+  hasDataLoss: boolean;
+  warnings: string[];
+  statementsToExecute: string[];
+  apply(): Promise<void>;
+};
+
+type PushSQLiteSchemaForBun = (
+  imports: RigkitDatabaseSchema,
+  drizzleInstance: DrizzleKitBunSQLiteDatabase,
+) => Promise<PushSQLiteSchemaResult>;
+
+export function createRigkitDatabase<TSchema extends RigkitDatabaseSchema = CoreSchema>(
+  path: string,
+  options: CreateRigkitDatabaseOptions<TSchema> = {},
+): RigkitDatabase<TSchema> {
+  mkdirSync(dirname(path), { recursive: true });
+  const db = drizzle(new Database(path, { create: true }), {
+    schema: options.schema ?? (coreSchema as unknown as TSchema),
+  });
+  db.run("PRAGMA journal_mode = WAL");
+  db.run("PRAGMA foreign_keys = ON");
+  return db;
+}
+
+export async function syncRigkitDatabaseSchema<TSchema extends RigkitDatabaseSchema>(
+  db: RigkitDatabase<TSchema>,
+  schema: TSchema,
+): Promise<SchemaSyncResult> {
+  try {
+    const result = await pushRigkitDatabaseSchema(db, schema);
+    return toSchemaSyncResult(result);
+  } catch (error) {
+    const resetStatements = resetRigkitDatabase(db);
+    const result = await pushRigkitDatabaseSchema(db, schema);
+    return toSchemaSyncResult(result, {
+      resetStatements,
+      resetReason: errorMessage(error),
+    });
+  }
+}
+
+async function pushRigkitDatabaseSchema<TSchema extends RigkitDatabaseSchema>(
+  db: RigkitDatabase<TSchema>,
+  schema: TSchema,
+): Promise<PushSQLiteSchemaResult> {
+  const drizzleKitApi = ["drizzle-kit", "api"].join("/");
+  const { pushSQLiteSchema } = await import(drizzleKitApi);
+  const pushSchema = pushSQLiteSchema as unknown as PushSQLiteSchemaForBun;
+  const result = await silenceStdout(() => pushSchema(schema, db));
+  await silenceStdout(() => result.apply());
+  return result;
+}
+
+function toSchemaSyncResult(
+  result: PushSQLiteSchemaResult,
+  reset?: { resetStatements: string[]; resetReason: string },
+): SchemaSyncResult {
+  const statements = [...(reset?.resetStatements ?? []), ...result.statementsToExecute];
+  const warnings = [...result.warnings];
+  if (reset) {
+    warnings.unshift(`Reset Rigkit state database after Drizzle push failed: ${reset.resetReason}`);
+  }
+  return {
+    applied: statements.length > 0 ? [RIGKIT_STATE_SCHEMA_VERSION] : [],
+    schemaVersion: RIGKIT_STATE_SCHEMA_VERSION,
+    statements,
+    warnings,
+    hasDataLoss: reset !== undefined || result.hasDataLoss,
+  };
+}
+
+function resetRigkitDatabase<TSchema extends RigkitDatabaseSchema>(db: RigkitDatabase<TSchema>): string[] {
+  const rows = db.$client
+    .query(`
+      SELECT type, name
+      FROM sqlite_schema
+      WHERE type IN ('table', 'view', 'trigger')
+        AND name NOT LIKE 'sqlite_%'
+      ORDER BY CASE type
+        WHEN 'view' THEN 0
+        WHEN 'trigger' THEN 1
+        ELSE 2
+      END
+    `)
+    .all() as Array<{ type: "table" | "view" | "trigger"; name: string }>;
+
+  const statements = [
+    "PRAGMA foreign_keys=OFF",
+    ...rows.map((row) => `DROP ${row.type.toUpperCase()} IF EXISTS ${quoteSqlIdentifier(row.name)}`),
+    "PRAGMA foreign_keys=ON",
+  ];
+  const dropStatements = statements.slice(1, -1);
+  const reset = db.$client.transaction(() => {
+    for (const sql of dropStatements) {
+      db.$client.run(sql);
+    }
+  });
+  db.$client.run("PRAGMA foreign_keys=OFF");
+  try {
+    reset();
+  } finally {
+    db.$client.run("PRAGMA foreign_keys=ON");
+  }
+  return statements;
+}
+
+function quoteSqlIdentifier(name: string): string {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+
+async function silenceStdout<T>(run: () => Promise<T>): Promise<T> {
+  const write = process.stdout.write;
+  process.stdout.write = (() => true) as typeof process.stdout.write;
+  try {
+    return await run();
+  } finally {
+    process.stdout.write = write;
+  }
+}
+
+function errorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}

package/src/db/schema/core.ts

@@ -0,0 +1,71 @@
+import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+import type { JsonValue } from "../../types.ts";
+
+export const workspaces = sqliteTable(
+  "workspaces",
+  {
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    workflow: text("workflow").notNull(),
+    workflowCtx: text("workflow_ctx_json", { mode: "json" }).$type<Record<string, JsonValue>>().notNull(),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+    ctx: text("ctx_json", { mode: "json" }).$type<Record<string, JsonValue>>().notNull(),
+  },
+  (table) => [
+    uniqueIndex("workspaces_name_idx").on(table.name),
+    index("workspaces_workflow_idx").on(table.workflow),
+  ],
+);
+
+export const workflowNodeRuns = sqliteTable(
+  "workflow_node_runs",
+  {
+    id: text("id").primaryKey(),
+    workflow: text("workflow").notNull(),
+    nodePath: text("node_path").notNull(),
+    nodeName: text("node_name").notNull(),
+    nodeKind: text("node_kind").notNull(),
+    nodeKey: text("node_key").notNull(),
+    providerFingerprint: text("provider_fingerprint").notNull(),
+    upstreamRunIds: text("upstream_run_ids_json", { mode: "json" }).$type<string[]>().notNull(),
+    output: text("output_json", { mode: "json" }).$type<Record<string, JsonValue>>().notNull(),
+    artifacts: text("artifacts_json", { mode: "json" }).$type<JsonValue[]>().notNull(),
+    invalidated: integer("invalidated", { mode: "boolean" }).notNull().default(false),
+    createdAt: text("created_at").notNull(),
+    metadata: text("metadata_json", { mode: "json" }).$type<Record<string, JsonValue>>().notNull(),
+  },
+  (table) => [
+    index("workflow_node_runs_lookup_idx").on(
+      table.workflow,
+      table.nodePath,
+      table.nodeKey,
+      table.providerFingerprint,
+    ),
+    index("workflow_node_runs_created_idx").on(table.createdAt),
+  ],
+);
+
+export const providerState = sqliteTable(
+  "provider_state",
+  {
+    providerId: text("provider_id").notNull(),
+    key: text("key").notNull(),
+    value: text("value_json", { mode: "json" }).$type<JsonValue>().notNull(),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("provider_state_provider_key_idx").on(table.providerId, table.key),
+    index("provider_state_provider_idx").on(table.providerId),
+  ],
+);
+
+export const runtimeMetadata = sqliteTable(
+  "runtime_metadata",
+  {
+    key: text("key").primaryKey(),
+    value: text("value_json", { mode: "json" }).$type<JsonValue>().notNull(),
+    updatedAt: text("updated_at").notNull(),
+  },
+);

package/src/db/schema/index.ts

@@ -0,0 +1,7 @@
+import * as core from "./core.ts";
+
+export const coreSchema = core;
+
+export type CoreSchema = typeof coreSchema;
+
+export * from "./core.ts";