forgeos 0.1.0-alpha.4 → 0.1.0-alpha.41

package/src/forge/runtime/db/memory-adapter.ts

@@ -7,6 +7,7 @@ interface MemoryRow {
 interface MemoryTable {
   rows: MemoryRow[];
   nextSerial: number;
+  columnTypes: Map<string, string>;
 }
 
 function normalizeRows(rows: MemoryRow[]): DbQueryResult {
@@ -16,8 +17,8 @@ function normalizeRows(rows: MemoryRow[]): DbQueryResult {
   };
 }
 
-function parseNow(): string {
-  return new Date().toISOString();
+function parseNow(): Date {
+  return new Date();
 }
 
 function compareValue(left: unknown, right: unknown): boolean {
@@ -52,6 +53,42 @@ function parseTableName(sql: string): string | null {
   return null;
 }
 
+function parseColumnTypes(sql: string): Map<string, string> {
+  if (!parseTableName(sql)) {
+    return new Map();
+  }
+  const tableNameMatch =
+    sql.match(/CREATE TABLE IF NOT EXISTS\s+"?([^"\s(]+)"?/i) ??
+    sql.match(/CREATE TABLE\s+"?([^"\s(]+)"?/i);
+  if (!tableNameMatch?.[0]) {
+    return new Map();
+  }
+
+  const start = sql.indexOf("(", tableNameMatch.index! + tableNameMatch[0].length);
+  const end = sql.lastIndexOf(")");
+  if (start < 0 || end <= start) {
+    return new Map();
+  }
+
+  const types = new Map<string, string>();
+  for (const definition of splitSqlList(sql.slice(start + 1, end))) {
+    const trimmed = definition.trim();
+    if (/^(CONSTRAINT|PRIMARY|UNIQUE|FOREIGN|CHECK)\b/i.test(trimmed)) {
+      continue;
+    }
+    const match = trimmed.match(/^"?(\w+)"?\s+([a-zA-Z][a-zA-Z0-9_]*(?:\s+precision)?)/);
+    if (match?.[1] && match?.[2]) {
+      types.set(match[1], match[2].toLowerCase());
+    }
+  }
+  return types;
+}
+
+function isTimestampType(sqlType: string | undefined): boolean {
+  if (!sqlType) return false;
+  return ["timestamp", "timestamptz", "timestamp with time zone", "timestamp without time zone"].includes(sqlType);
+}
+
 function splitSqlList(value: string): string[] {
   const parts: string[] = [];
   let current = "";
@@ -111,10 +148,68 @@ function parseSqlLiteral(token: string, params: unknown[]): unknown {
   return Number.isFinite(numeric) ? numeric : token;
 }
 
+function parseUpdateExpression(
+  row: MemoryRow,
+  column: string,
+  expression: string,
+  params: unknown[],
+): unknown {
+  const paramMatch = expression.match(/\$(\d+)/);
+  const normalizedExpression = expression.replace(/"/g, "").replace(/\s+/g, " ");
+
+  if (normalizedExpression.toLowerCase() === `${column.toLowerCase()} + 1`) {
+    return Number(row[column] ?? 0) + 1;
+  }
+
+  const coalesceMatch = expression.match(/^COALESCE\(\s*"?(\w+)"?\s*,\s*(.+)\)$/i);
+  if (coalesceMatch?.[1] && coalesceMatch[2]) {
+    const existing = row[coalesceMatch[1]];
+    return existing ?? parseUpdateExpression(row, column, coalesceMatch[2].trim(), params);
+  }
+
+  if (paramMatch?.[1]) {
+    return params[Number(paramMatch[1]) - 1];
+  }
+
+  return parseSqlLiteral(expression, params);
+}
+
 function deterministicUuid(serial: number): string {
   return `00000000-0000-0000-0000-${String(serial).padStart(12, "0")}`;
 }
 
+function coerceColumnValue(tableName: string, table: MemoryTable, column: string, value: unknown): unknown {
+  if (!isTimestampType(table.columnTypes.get(column))) {
+    return value;
+  }
+  if (value === null || value === undefined) {
+    return value;
+  }
+  if (value === "") {
+    throw new Error(`FORGE_DB_INVALID_TIMESTAMP: empty timestamp value for ${tableName}.${column}`);
+  }
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) {
+      throw new Error(`FORGE_DB_INVALID_TIMESTAMP: invalid timestamp value for ${tableName}.${column}`);
+    }
+    return value;
+  }
+  if (typeof value === "string" || typeof value === "number") {
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) {
+      throw new Error(`FORGE_DB_INVALID_TIMESTAMP: invalid timestamp value for ${tableName}.${column}`);
+    }
+    return date;
+  }
+  throw new Error(`FORGE_DB_INVALID_TIMESTAMP: unsupported timestamp value for ${tableName}.${column}`);
+}
+
+function coerceRowValues(tableName: string, table: MemoryTable, row: MemoryRow): void {
+  for (const column of Object.keys(row)) {
+    row[column] = coerceColumnValue(tableName, table, column, row[column]);
+  }
+}
+
 function applySystemDefaults(tableName: string, row: MemoryRow): void {
   const now = parseNow();
 
@@ -203,6 +298,16 @@ function projectRows(sql: string, rows: MemoryRow[]): MemoryRow[] {
   });
 }
 
+function extractWhereClause(sql: string): string | null {
+  const whereIndex = sql.search(/\bWHERE\b/i);
+  if (whereIndex < 0) {
+    return null;
+  }
+  const afterWhere = sql.slice(whereIndex);
+  const endMatch = afterWhere.match(/\b(ORDER\s+BY|GROUP\s+BY|LIMIT|RETURNING)\b/i);
+  return endMatch?.index === undefined ? afterWhere : afterWhere.slice(0, endMatch.index);
+}
+
 export class MemoryAdapter implements DbAdapter {
   readonly kind = "memory" as const;
   private tables = new Map<string, MemoryTable>();
@@ -215,8 +320,11 @@ export class MemoryAdapter implements DbAdapter {
       const match =
         trimmed.match(/CREATE TABLE IF NOT EXISTS "([^"]+)"/i) ??
         trimmed.match(/CREATE TABLE IF NOT EXISTS ([a-z_][a-z0-9_]*)/i);
-      if (match?.[1] && !this.tables.has(match[1])) {
-        this.tables.set(match[1], { rows: [], nextSerial: 1 });
+      if (match?.[1]) {
+        const table = this.ensureTable(match[1]);
+        for (const [column, sqlType] of parseColumnTypes(trimmed)) {
+          table.columnTypes.set(column, sqlType);
+        }
       }
       return { rows: [], rowCount: 0 };
     }
@@ -331,6 +439,7 @@ export class MemoryAdapter implements DbAdapter {
     }
 
     applySystemDefaults(tableName, row);
+    coerceRowValues(tableName, table, row);
 
     table.rows.push(row);
 
@@ -474,31 +583,33 @@ export class MemoryAdapter implements DbAdapter {
   }
 
   private filterRows(rows: MemoryRow[], sql: string, params: unknown[]): MemoryRow[] {
-    if (/status\s*=\s*'pending'/i.test(sql) && /next_attempt_at\s*<=\s*now\(\)/i.test(sql)) {
+    const whereSql = extractWhereClause(sql) ?? sql;
+
+    if (/status\s*=\s*'pending'/i.test(whereSql) && /next_attempt_at\s*<=\s*now\(\)/i.test(whereSql)) {
       return rows.filter((row) => row.status === "pending");
     }
 
-    if (/trace_id\s*=\s*\$\d+/i.test(sql)) {
+    if (/trace_id\s*=\s*\$\d+/i.test(whereSql)) {
       return rows.filter((row) => row.trace_id === params[0]);
     }
 
-    if (/status\s+IN\s*\(\s*'pending'\s*,\s*'running'\s*,\s*'failed'\s*\)/i.test(sql)) {
+    if (/status\s+IN\s*\(\s*'pending'\s*,\s*'running'\s*,\s*'failed'\s*\)/i.test(whereSql)) {
       return rows.filter((row) =>
         ["pending", "running", "failed"].includes(String(row.status)),
       );
     }
 
-    if (/status\s+NOT\s+IN\s*\(\s*'completed'\s*,\s*'skipped'\s*\)/i.test(sql)) {
+    if (/status\s+NOT\s+IN\s*\(\s*'completed'\s*,\s*'skipped'\s*\)/i.test(whereSql)) {
       return rows.filter(
         (row) => !["completed", "skipped"].includes(String(row.status)),
       );
     }
 
-    if (/status\s*=\s*'dead'/i.test(sql) && /COUNT/i.test(sql)) {
+    if (/status\s*=\s*'dead'/i.test(whereSql) && /COUNT/i.test(sql)) {
       return rows.filter((row) => row.status === "dead");
     }
 
-    if (/step_index\s*<\s*\$\d+/i.test(sql) && /status\s*!=\s*'completed'/i.test(sql)) {
+    if (/step_index\s*<\s*\$\d+/i.test(whereSql) && /status\s*!=\s*'completed'/i.test(whereSql)) {
       const threshold = Number(params[1]);
       const runId = params[0];
       return rows.filter(
@@ -509,16 +620,16 @@ export class MemoryAdapter implements DbAdapter {
       );
     }
 
-    if (/idempotency_key\s*=\s*\$\d+/i.test(sql)) {
+    if (/idempotency_key\s*=\s*\$\d+/i.test(whereSql)) {
       return rows.filter((row) => row.idempotency_key === params[0]);
     }
 
-    if (/status\s*=\s*'dead'/i.test(sql)) {
+    if (/status\s*=\s*'dead'/i.test(whereSql)) {
       return rows.filter((row) => row.status === "dead");
     }
 
     const conditions = [
-      ...sql.matchAll(
+      ...whereSql.matchAll(
         /(?:^|\s|AND\s)(?:\w+\.)?"?(\w+)"?\s*(=|<=|>=|>|<|!=)\s*(\$\d+|now\(\)|'[^']*'|"[^"]*"|\d+)/gi,
       ),
     ];
@@ -569,14 +680,12 @@ export class MemoryAdapter implements DbAdapter {
     }
 
     const setMatch = sql.match(/SET (.+?) WHERE/i);
-    const assignments = setMatch?.[1]?.split(",") ?? [];
-    const whereMatch = sql.match(/WHERE\s+"?(\w+)"?\s*=\s*\$\d+/i);
-    const whereColumn = whereMatch?.[1] ?? "id";
-    const whereValue = params[params.length - 1];
+    const assignments = setMatch?.[1] ? splitSqlList(setMatch[1]) : [];
+    const matchingRows = /WHERE/i.test(sql) ? new Set(this.filterRows(table.rows, sql, params)) : new Set(table.rows);
 
     let updated = 0;
     for (const row of table.rows) {
-      if (row[whereColumn] !== whereValue) {
+      if (!matchingRows.has(row)) {
         continue;
       }
 
@@ -608,23 +717,20 @@ export class MemoryAdapter implements DbAdapter {
       }
 
       for (const assignment of assignments) {
-        const [rawColumn, rawExpression] = assignment.split("=");
-        const column = rawColumn?.trim().replace(/"/g, "");
+        const equalsIndex = assignment.indexOf("=");
+        if (equalsIndex < 0) {
+          continue;
+        }
+        const rawColumn = assignment.slice(0, equalsIndex);
+        const rawExpression = assignment.slice(equalsIndex + 1);
+        const column = rawColumn.trim().replace(/"/g, "");
         if (!column) {
           continue;
         }
 
-        const expression = rawExpression?.trim() ?? "";
-        const paramMatch = expression.match(/\$(\d+)/);
-        const normalizedExpression = expression.replace(/"/g, "").replace(/\s+/g, " ");
-
-        if (normalizedExpression.toLowerCase() === `${column.toLowerCase()} + 1`) {
-          row[column] = Number(row[column] ?? 0) + 1;
-        } else if (paramMatch?.[1]) {
-          row[column] = params[Number(paramMatch[1]) - 1];
-        } else {
-          row[column] = parseSqlLiteral(expression, params);
-        }
+        const expression = rawExpression.trim();
+        row[column] = parseUpdateExpression(row, column, expression, params);
+        row[column] = coerceColumnValue(tableName, table, column, row[column]);
       }
 
       updated += 1;
@@ -668,6 +774,7 @@ export class MemoryAdapter implements DbAdapter {
       snapshot.set(name, {
         rows: table.rows.map((row) => ({ ...row })),
         nextSerial: table.nextSerial,
+        columnTypes: new Map(table.columnTypes),
       });
     }
     const sequenceSnapshot = new Map(this.sequences);
@@ -695,7 +802,7 @@ export class MemoryAdapter implements DbAdapter {
     if (existing) {
       return existing;
     }
-    const created = { rows: [], nextSerial: 1 };
+    const created = { rows: [], nextSerial: 1, columnTypes: new Map<string, string>() };
     this.tables.set(name, created);
     return created;
   }

package/src/forge/runtime/db/pglite-adapter.ts

@@ -1,6 +1,40 @@
 import { PGlite } from "@electric-sql/pglite";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, unlinkSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
 import type { DbAdapter, DbQueryResult, DbTransaction } from "./adapter.ts";
 
+export const DEFAULT_PGLITE_DIR = ".forge/pglite";
+
+export type PgliteStoreState =
+  | "missing"
+  | "healthy"
+  | "active"
+  | "aborted"
+  | "unhealthy";
+
+export interface PgliteStoreInspection {
+  dataDir: string;
+  exists: boolean;
+  state: PgliteStoreState;
+  openable: boolean;
+  postmasterPid?: number;
+  postmasterAlive?: boolean;
+  lockFiles: string[];
+  error?: string;
+  nextActions: string[];
+}
+
+export interface PgliteStoreRepairResult {
+  ok: boolean;
+  repaired: boolean;
+  dataDir: string;
+  backupPath: string | null;
+  before: PgliteStoreInspection;
+  after: PgliteStoreInspection;
+  message: string;
+  nextActions: string[];
+}
+
 function toQueryResult(result: {
   rows: Record<string, unknown>[];
   affectedRows?: number;
@@ -45,7 +79,234 @@ export class PgliteAdapter implements DbAdapter {
 }
 
 export async function createPgliteAdapter(dataDir: string): Promise<DbAdapter> {
+  mkdirSync(dataDir, { recursive: true });
+  repairStalePgliteStore(dataDir);
   const adapter = new PgliteAdapter(dataDir);
-  await adapter.query("SELECT 1");
-  return adapter;
+  try {
+    await adapter.query("SELECT 1");
+    return adapter;
+  } catch (error) {
+    await adapter.close().catch(() => undefined);
+    throw error;
+  }
+}
+
+export async function inspectPgliteStore(dataDir: string): Promise<PgliteStoreInspection> {
+  const exists = existsSync(dataDir);
+  const lockFiles = [
+    "postmaster.pid",
+    ".s.PGSQL.5432.lock",
+    ".s.PGSQL.5432.lock.out",
+  ].filter((file) => existsSync(join(dataDir, file)));
+
+  if (!exists) {
+    return {
+      dataDir,
+      exists: false,
+      state: "missing",
+      openable: true,
+      lockFiles,
+      nextActions: ["forge dev --db pglite --json"],
+    };
+  }
+
+  const pid = readPglitePostmasterPid(dataDir);
+  const postmasterAlive = Number.isInteger(pid) && pid > 0 ? isProcessAlive(pid) : undefined;
+  if (postmasterAlive) {
+    return {
+      dataDir,
+      exists: true,
+      state: "active",
+      openable: false,
+      postmasterPid: pid,
+      postmasterAlive,
+      lockFiles,
+      error: `PGlite store is currently owned by live pid ${pid}`,
+      nextActions: [
+        "stop the running forge dev process that owns .forge/pglite",
+        "forge doctor pglite --json",
+      ],
+    };
+  }
+
+  let adapter: DbAdapter | null = null;
+  const previousExitCode = process.exitCode;
+  let restoreExitCode = false;
+  try {
+    adapter = new PgliteAdapter(dataDir);
+    await adapter.query("SELECT 1");
+    return {
+      dataDir,
+      exists: true,
+      state: "healthy",
+      openable: true,
+      ...(Number.isInteger(pid) && pid > 0 ? { postmasterPid: pid, postmasterAlive: false } : {}),
+      lockFiles,
+      nextActions: ["forge dev --db pglite --json"],
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const aborted = isPgliteAbortMessage(message);
+    if (aborted) {
+      restoreExitCode = true;
+      process.exitCode = previousExitCode;
+    }
+    return {
+      dataDir,
+      exists: true,
+      state: aborted ? "aborted" : "unhealthy",
+      openable: false,
+      ...(Number.isInteger(pid) && pid > 0 ? { postmasterPid: pid, postmasterAlive: false } : {}),
+      lockFiles,
+      error: message,
+      nextActions: [
+        "forge db repair --local --adapter pglite --json",
+        "forge dev --db memory --json",
+      ],
+    };
+  } finally {
+    await adapter?.close().catch(() => undefined);
+    if (restoreExitCode) {
+      process.exitCode = previousExitCode;
+    }
+  }
+}
+
+export async function repairLocalPgliteStore(dataDir: string): Promise<PgliteStoreRepairResult> {
+  const before = await inspectPgliteStore(dataDir);
+  if (before.state === "active") {
+    return {
+      ok: false,
+      repaired: false,
+      dataDir,
+      backupPath: null,
+      before,
+      after: before,
+      message: "PGlite store is active; stop the owning forge dev process before repair.",
+      nextActions: before.nextActions,
+    };
+  }
+
+  if (before.state === "missing") {
+    return {
+      ok: true,
+      repaired: false,
+      dataDir,
+      backupPath: null,
+      before,
+      after: before,
+      message: "No local PGlite store exists; nothing to repair.",
+      nextActions: before.nextActions,
+    };
+  }
+
+  if (before.state === "healthy") {
+    return {
+      ok: true,
+      repaired: false,
+      dataDir,
+      backupPath: null,
+      before,
+      after: before,
+      message: "Local PGlite store is healthy; no repair needed.",
+      nextActions: before.nextActions,
+    };
+  }
+
+  const backupPath = archivePgliteStore(dataDir, before.state);
+  const after = await inspectPgliteStore(dataDir);
+  const ok = after.state === "missing" || after.state === "healthy";
+  return {
+    ok,
+    repaired: true,
+    dataDir,
+    backupPath,
+    before,
+    after,
+    message: backupPath
+      ? `Archived local PGlite store to ${backupPath}.`
+      : "Removed stale local PGlite lock files; retry forge dev.",
+    nextActions: ok
+      ? ["forge dev --db pglite --json"]
+      : ["forge dev --db memory --json", "forge doctor pglite --json"],
+  };
+}
+
+export function isPgliteAbortMessage(message: string): boolean {
+  return /Aborted\(\)\. Build with -sASSERTIONS/i.test(message) ||
+    (/pglite/i.test(message) && /abort/i.test(message));
+}
+
+function repairStalePgliteStore(dataDir: string): void {
+  const pidPath = join(dataDir, "postmaster.pid");
+  if (!existsSync(pidPath)) {
+    return;
+  }
+
+  const pid = readPglitePostmasterPid(dataDir);
+  const stale =
+    !Number.isInteger(pid) ||
+    pid <= 0 ||
+    !isProcessAlive(pid);
+
+  if (!stale) {
+    return;
+  }
+
+  removeStalePgliteLocks(dataDir);
+}
+
+function readPglitePostmasterPid(dataDir: string): number {
+  try {
+    const rawPid = readFileSync(join(dataDir, "postmaster.pid"), "utf8").split(/\r?\n/, 1)[0]?.trim();
+    return rawPid ? Number(rawPid) : NaN;
+  } catch {
+    return NaN;
+  }
+}
+
+function removeStalePgliteLocks(dataDir: string): void {
+  for (const file of [
+    "postmaster.pid",
+    ".s.PGSQL.5432.lock",
+    ".s.PGSQL.5432.lock.out",
+  ]) {
+    try {
+      unlinkSync(join(dataDir, file));
+    } catch {
+      // Best effort. If PGlite still cannot open, the caller reports the real open error.
+    }
+  }
+}
+
+export function archivePgliteStore(dataDir: string, reason = "repair"): string | null {
+  if (!existsSync(dataDir)) {
+    return null;
+  }
+
+  const parent = dirname(dataDir);
+  const backupsDir = join(parent, `${basename(dataDir)}.backups`);
+  mkdirSync(backupsDir, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupPath = join(backupsDir, `${basename(dataDir)}.${reason}.${stamp}`);
+
+  try {
+    renameSync(dataDir, backupPath);
+    mkdirSync(dataDir, { recursive: true });
+    return backupPath;
+  } catch {
+    rmSync(join(dataDir, "postmaster.pid"), { force: true });
+    rmSync(join(dataDir, ".s.PGSQL.5432.lock"), { force: true });
+    rmSync(join(dataDir, ".s.PGSQL.5432.lock.out"), { force: true });
+    return null;
+  }
+}
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
 }

package/src/forge/runtime/db/postgres-adapter.ts

@@ -12,7 +12,7 @@ function loadBunSql(databaseUrl: string): PostgresClient | null {
   try {
     const bunGlobal = globalThis as {
       Bun?: {
-        SQL?: new (url: string) => {
+        SQL?: new (options: string | { url: string; max?: number }) => {
           unsafe: (sql: string, params?: unknown[]) => Promise<Record<string, unknown>[]>;
           close: () => Promise<void>;
         };
@@ -23,7 +23,7 @@ function loadBunSql(databaseUrl: string): PostgresClient | null {
       return null;
     }
 
-    const client = new bunGlobal.Bun.SQL(databaseUrl);
+    const client = new bunGlobal.Bun.SQL({ url: databaseUrl, max: 1 });
     return {
       query: async (sql, params = []) => {
         const rows = await client.unsafe(sql, params);
@@ -42,7 +42,10 @@ async function loadPostgresJs(databaseUrl: string): Promise<PostgresClient | nul
   try {
     const module = await import("postgres");
     const createSql = module.default;
-    const sql = createSql(databaseUrl);
+    const sql = createSql(databaseUrl, {
+      max: 1,
+      onnotice: () => undefined,
+    });
     return {
       query: async (statement, params = []) => {
         const rows = await sql.unsafe(statement, params as never[]);