@defrex/autobuild 0.8.0

package/packages/core/src/store/local/blobs.ts

@@ -0,0 +1,38 @@
+/**
+ * Content-addressed blobs as a plain directory (SPEC §7.1, §7.2.1): files
+ * sharded `root/<hash[0:2]>/<hash>`. Put is idempotent — the hash *is* the
+ * identity, so an existing file is already the requested content.
+ */
+import { randomUUID } from 'node:crypto'
+import { mkdir, rename } from 'node:fs/promises'
+import { join } from 'node:path'
+import type { BlobStore } from '../types'
+
+export class DirBlobStore implements BlobStore {
+  constructor(readonly root: string) {}
+
+  private pathFor(hash: string): string {
+    return join(this.root, hash.slice(0, 2), hash)
+  }
+
+  async put(hash: string, bytes: Uint8Array): Promise<void> {
+    const path = this.pathFor(hash)
+    if (await Bun.file(path).exists()) return
+    await mkdir(join(this.root, hash.slice(0, 2)), { recursive: true })
+    // Write-then-rename so a crashed write never leaves a truncated blob
+    // wearing a valid content address. The temp name is unique per call
+    // (pid + uuid): concurrent puts of the same hash — separate processes
+    // sharing one local store (§7.1) — must never share a temp path, or one
+    // writer's O_TRUNC reopen could truncate the bytes another is about to
+    // rename into the final content address.
+    const partial = `${path}.${process.pid}.${randomUUID()}.partial`
+    await Bun.write(partial, bytes)
+    await rename(partial, path)
+  }
+
+  async get(hash: string): Promise<Uint8Array | null> {
+    const file = Bun.file(this.pathFor(hash))
+    if (!(await file.exists())) return null
+    return new Uint8Array(await file.arrayBuffer())
+  }
+}

package/packages/core/src/store/local/schema.ts

@@ -0,0 +1,180 @@
+/**
+ * Drizzle schema for the local SQLite BuildStore (SPEC §7.1): simple,
+ * normalized, boring. Lease + heartbeat are mutable liveness columns on
+ * `builds`, never events (§15.2.6). Events and artifacts store JSON in text
+ * columns; bulk content lives behind the BlobStore — the database stores
+ * refs (sha256 blobRef), never blobs.
+ *
+ * `store.ts` bootstraps these tables with inline DDL at open; that DDL must
+ * be kept in lockstep with this schema (this file is the drizzle-kit source
+ * of truth).
+ */
+import { integer, primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import type { Actor } from '../../events/envelope'
+import type { TicketRef } from '../../ontology'
+import type { StreamPart } from '../streams/types'
+
+export const builds = sqliteTable('builds', {
+  slug: text('slug').primaryKey(),
+  repo: text('repo').notNull(),
+  repoOrigin: text('repo_origin'),
+  ticket: text('ticket', { mode: 'json' }).$type<TicketRef>(),
+  branch: text('branch'),
+  createdAt: text('created_at').notNull(),
+  updatedAt: text('updated_at').notNull(),
+  leaseHolder: text('lease_holder'),
+  leaseExpiresAt: text('lease_expires_at'),
+  leaseTtlMs: integer('lease_ttl_ms'),
+  heartbeatAt: text('heartbeat_at'),
+})
+
+export const events = sqliteTable(
+  'events',
+  {
+    build: text('build').notNull(),
+    /** Per-build, monotonic from 1, assigned in-transaction on append (§15.1). */
+    seq: integer('seq').notNull(),
+    ts: text('ts').notNull(),
+    actor: text('actor', { mode: 'json' }).notNull().$type<Actor>(),
+    type: text('type').notNull(),
+    payload: text('payload', { mode: 'json' }).notNull(),
+  },
+  (t) => [primaryKey({ columns: [t.build, t.seq] })],
+)
+
+export const repoStreams = sqliteTable('repo_streams', {
+  repo: text('repo').primaryKey(),
+  createdAt: text('created_at').notNull(),
+  updatedAt: text('updated_at').notNull(),
+  leaseHolder: text('lease_holder'),
+  leaseExpiresAt: text('lease_expires_at'),
+  leaseTtlMs: integer('lease_ttl_ms'),
+  heartbeatAt: text('heartbeat_at'),
+})
+
+export const repoEvents = sqliteTable(
+  'repo_events',
+  {
+    repo: text('repo').notNull(),
+    seq: integer('seq').notNull(),
+    ts: text('ts').notNull(),
+    actor: text('actor', { mode: 'json' }).notNull().$type<Actor>(),
+    type: text('type').notNull(),
+    payload: text('payload', { mode: 'json' }).notNull(),
+  },
+  (t) => [primaryKey({ columns: [t.repo, t.seq] })],
+)
+
+export const repoArtifacts = sqliteTable(
+  'repo_artifacts',
+  {
+    repo: text('repo').notNull(),
+    kind: text('kind').notNull(),
+    revision: integer('revision').notNull(),
+    blobRef: text('blob_ref').notNull(),
+    metadata: text('metadata', { mode: 'json' }).notNull().$type<Record<string, unknown>>(),
+    createdAt: text('created_at').notNull(),
+  },
+  (t) => [primaryKey({ columns: [t.repo, t.kind, t.revision] })],
+)
+
+/** Operator sessions (SPEC §7.1.1): hosted-only durable orchestrator
+ * conversation state. Adapters implement the contract uniformly; nothing
+ * local creates one. */
+export const sessions = sqliteTable('sessions', {
+  id: text('id').primaryKey(),
+  repo: text('repo').notNull(),
+  operator: text('operator').notNull(),
+  title: text('title'),
+  /** Store-assigned monotonic creation sequence (assigned in-transaction at
+   * `createSession`, never reused — sessions are never deleted). The
+   * `listSessions` same-timestamp tiebreak; not part of `SessionRecord`. */
+  creationSeq: integer('creation_seq').notNull(),
+  createdAt: text('created_at').notNull(),
+  updatedAt: text('updated_at').notNull(),
+})
+
+export const sessionEvents = sqliteTable(
+  'session_events',
+  {
+    session: text('session')
+      .notNull()
+      .references(() => sessions.id, { onDelete: 'cascade' }),
+    /** Per-session, monotonic from 1, assigned in-transaction on append. */
+    seq: integer('seq').notNull(),
+    ts: text('ts').notNull(),
+    actor: text('actor', { mode: 'json' }).notNull().$type<Actor>(),
+    type: text('type').notNull(),
+    payload: text('payload', { mode: 'json' }).notNull(),
+  },
+  (t) => [primaryKey({ columns: [t.session, t.seq] })],
+)
+
+export const sessionArtifacts = sqliteTable(
+  'session_artifacts',
+  {
+    session: text('session')
+      .notNull()
+      .references(() => sessions.id, { onDelete: 'cascade' }),
+    kind: text('kind').notNull(),
+    revision: integer('revision').notNull(),
+    blobRef: text('blob_ref').notNull(),
+    metadata: text('metadata', { mode: 'json' }).notNull().$type<Record<string, unknown>>(),
+    createdAt: text('created_at').notNull(),
+  },
+  (t) => [primaryKey({ columns: [t.session, t.kind, t.revision] })],
+)
+
+export const artifacts = sqliteTable(
+  'artifacts',
+  {
+    build: text('build').notNull(),
+    kind: text('kind').notNull(),
+    /** 0-based per (build, kind) — the first deposit of a kind is rev 0 (§6.3). */
+    revision: integer('revision').notNull(),
+    /** sha256 content address into the BlobStore (§7.1). */
+    blobRef: text('blob_ref').notNull(),
+    metadata: text('metadata', { mode: 'json' }).notNull().$type<Record<string, unknown>>(),
+    createdAt: text('created_at').notNull(),
+  },
+  (t) => [primaryKey({ columns: [t.build, t.kind, t.revision] })],
+)
+
+/** Streams (SPEC §7.6): the third primitive. Scope is fixed at create; the
+ * CHECKs guarantee exactly one of build/repo/session is set, matching the
+ * scope kind. */
+export const streams = sqliteTable('streams', {
+  id: text('id').primaryKey(),
+  scopeKind: text('scope_kind').notNull(),
+  build: text('build'),
+  repo: text('repo'),
+  session: text('session'),
+  label: text('label').notNull(),
+  format: text('format').notNull(),
+  status: text('status').notNull(),
+  outcome: text('outcome'),
+  artifactKind: text('artifact_kind'),
+  artifactRevision: integer('artifact_revision'),
+  artifactBlobRef: text('artifact_blob_ref'),
+  createdAt: text('created_at').notNull(),
+  closedAt: text('closed_at'),
+  /** Store-assigned monotonic creation sequence (assigned in-transaction at
+   * `createStream`, never reused — streams are never deleted; retention
+   * prunes `stream_chunks` only). The `listStreams` same-timestamp tiebreak;
+   * not part of `StreamRecord`. */
+  creationSeq: integer('creation_seq').notNull(),
+})
+
+export const streamChunks = sqliteTable(
+  'stream_chunks',
+  {
+    stream: text('stream')
+      .notNull()
+      .references(() => streams.id, { onDelete: 'cascade' }),
+    /** Per-stream, monotonic from 1, assigned in-transaction on append. */
+    seq: integer('seq').notNull(),
+    ts: text('ts').notNull(),
+    parts: text('parts', { mode: 'json' }).notNull().$type<StreamPart[]>(),
+  },
+  (t) => [primaryKey({ columns: [t.stream, t.seq] })],
+)