@sixb/sqlite 0.1.21 → 0.1.23

package/src/ai-usage-storage.ts

@@ -1,14 +1,23 @@
-import { assertAiUsageExecutionId, normalizeAiModelCallRecord } from "@sixb/core/internal/storage"
+import type { FileRef } from "@sixb/core/blob-storage/server"
+import {
+  assertAiUsageExecutionId,
+  assertSameCallExecution,
+  normalizeAiModelCallFilesRecord,
+  normalizeAiModelCallRecord,
+} from "@sixb/core/internal/storage"
 import { isModelReasoning, normalizeModelProviderIds } from "@sixb/core/models"
 import type { ReadonlyJsonObject } from "@sixb/core/storage"
 import {
+  type AiModelCallFilesRecord,
   type AiModelCallUsageInput,
   type AiModelCallUsageRecord,
   type AiUsageExecutionSummary,
   type AiUsageStorage,
   AiUsageStorageError,
   aggregateAiModelCallUsage,
+  type GetAiModelCallFilesInput,
   type GetLatestAiModelCallForExecutionInput,
+  type RecordAiModelCallFilesInput,
   type RecordAiModelCallInput,
   type RecordAiModelCallResult,
   type SummarizeAiUsageExecutionInput,
@@ -110,10 +119,54 @@ export class SqliteAiUsageStorage implements AiUsageStorage {
     return aggregateExecutionRows(input.executionIds, rows)
   }
 
+  async recordModelCallFiles(input: RecordAiModelCallFilesInput): Promise<AiModelCallFilesRecord> {
+    const record = normalizeAiModelCallFilesRecord(input)
+    return runImmediateTransaction(this.connection.db, () => {
+      const existing = this.findCallFiles(record.projectId, record.callId)
+      if (existing) return assertSameCallExecution(existing, record)
+      this.assertExecutionExists(record.projectId, record.executionId)
+      this.connection.db
+        .query(
+          `
+            INSERT INTO ai_model_call_files (project_id, call_id, execution_id, files, recorded_at)
+            VALUES (?, ?, ?, ?, ?)
+          `
+        )
+        .run(
+          record.projectId,
+          record.callId,
+          record.executionId,
+          JSON.stringify(record.files),
+          record.recordedAt.toISOString()
+        )
+      return record
+    })
+  }
+
+  async getModelCallFiles(input: GetAiModelCallFilesInput): Promise<AiModelCallFilesRecord | null> {
+    assertNonBlankProjectId(input.projectId)
+    return this.findCallFiles(input.projectId, input.callId)
+  }
+
   close(): void {
     closeSqliteStoreConnection(this.connection)
   }
 
+  private findCallFiles(projectId: string, callId: string): AiModelCallFilesRecord | null {
+    const row = this.connection.db
+      .query("SELECT * FROM ai_model_call_files WHERE project_id = ? AND call_id = ?")
+      .get(projectId, callId) as CallFilesRow | null
+    return row
+      ? {
+          projectId: row.project_id,
+          executionId: row.execution_id,
+          callId: row.call_id,
+          files: JSON.parse(row.files) as FileRef[],
+          recordedAt: new Date(row.recorded_at),
+        }
+      : null
+  }
+
   private insertRecord(record: AiModelCallUsageRecord): void {
     this.connection.db
       .query(
@@ -140,12 +193,16 @@ export class SqliteAiUsageStorage implements AiUsageStorage {
             text_output_tokens,
             reasoning_output_tokens,
             audio_duration_ms,
+            image_output_tokens,
+            audio_output_tokens,
+            output_images,
+            input_characters,
             reporting_status,
             raw_usage,
             occurred_at,
             recorded_at
           ) VALUES (
-            ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+            ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
           )
         `
       )
@@ -171,6 +228,10 @@ export class SqliteAiUsageStorage implements AiUsageStorage {
         record.usage.textOutputTokens ?? null,
         record.usage.reasoningOutputTokens ?? null,
         record.usage.audioDurationMs ?? null,
+        record.usage.imageOutputTokens ?? null,
+        record.usage.audioOutputTokens ?? null,
+        record.usage.outputImages ?? null,
+        record.usage.inputCharacters ?? null,
         record.usage.reportingStatus,
         record.rawUsage === undefined ? null : JSON.stringify(record.rawUsage),
         record.occurredAt.toISOString(),
@@ -285,6 +346,14 @@ export class SqliteAiUsageStorage implements AiUsageStorage {
   }
 }
 
+interface CallFilesRow {
+  readonly project_id: string
+  readonly call_id: string
+  readonly execution_id: string
+  readonly files: string
+  readonly recorded_at: string
+}
+
 interface AiUsageRow {
   readonly project_id: string
   readonly id: string
@@ -307,6 +376,10 @@ interface AiUsageRow {
   readonly text_output_tokens: number | null
   readonly reasoning_output_tokens: number | null
   readonly audio_duration_ms: number | null
+  readonly image_output_tokens: number | null
+  readonly audio_output_tokens: number | null
+  readonly output_images: number | null
+  readonly input_characters: number | null
   readonly reporting_status: AiModelCallUsageRecord["usage"]["reportingStatus"]
   readonly raw_usage: string | null
   readonly occurred_at: string
@@ -349,6 +422,10 @@ function usageFromRow(row: AiUsageRow): AiModelCallUsageInput {
       ? {}
       : { reasoningOutputTokens: row.reasoning_output_tokens }),
     ...(row.audio_duration_ms === null ? {} : { audioDurationMs: row.audio_duration_ms }),
+    ...(row.image_output_tokens === null ? {} : { imageOutputTokens: row.image_output_tokens }),
+    ...(row.audio_output_tokens === null ? {} : { audioOutputTokens: row.audio_output_tokens }),
+    ...(row.output_images === null ? {} : { outputImages: row.output_images }),
+    ...(row.input_characters === null ? {} : { inputCharacters: row.input_characters }),
   }
 }
 

package/src/artifact-storage.ts

@@ -1,16 +1,23 @@
 import type { Database, SQLQueryBindings } from "bun:sqlite"
 import {
+  artifactStateBytes,
   artifactStorageErrors,
+  checkArtifactStateWrite,
   parseArtifactFrameGrantRow,
   parseArtifactRow,
+  parseArtifactStateRow,
   parseArtifactVersionRow,
 } from "@sixb/core/internal/storage"
 import type {
   ArtifactFrameGrantRecord,
   ArtifactRecord,
+  ArtifactStateEntry,
+  ArtifactStateKeyInput,
+  ArtifactStateScope,
   ArtifactStorage,
   ArtifactVersionInput,
   ArtifactVersionRecord,
+  CopyArtifactInput,
   CreateArtifactInput,
   DeleteArtifactInput,
   DeleteArtifactVersionsByOriginInput,
@@ -25,6 +32,7 @@ import type {
   ListReferencingVersionsInput,
   PublishArtifactVersionInput,
   PublishedArtifactVersion,
+  SetArtifactStateInput,
 } from "@sixb/core/storage"
 import { runImmediateTransaction, type SqliteStoreConnection } from "./transactions"
 
@@ -45,6 +53,15 @@ const FRAME_GRANT_COLUMNS = `
   created_at AS createdAt, expires_at AS expiresAt
 `
 
+const STATE_COLUMNS = "key, value, size_bytes AS sizeBytes, updated_at AS updatedAt"
+
+/** One reader of one artifact: the bindings that follow `STATE_SCOPE`. */
+const STATE_SCOPE = "project_id = ? AND artifact_id = ? AND principal_type = ? AND principal_id = ?"
+
+function stateScope(input: ArtifactStateScope): SQLQueryBindings[] {
+  return [input.projectId, input.artifactId, input.principal.type, input.principal.id]
+}
+
 type Row = Record<string, unknown>
 
 export class SqliteArtifactStorage implements ArtifactStorage {
@@ -88,16 +105,33 @@ export class SqliteArtifactStorage implements ArtifactStorage {
     return runImmediateTransaction(this.db, () => {
       const current = this.db
         .query(
-          "SELECT kind, next_version AS nextVersion FROM artifacts WHERE project_id = ? AND id = ?"
+          `SELECT kind, next_version AS nextVersion, latest_version AS latestVersion
+           FROM artifacts WHERE project_id = ? AND id = ?`
         )
         .get(input.projectId, input.artifactId) as {
         readonly kind: ArtifactRecord["kind"]
         readonly nextVersion: number
+        readonly latestVersion: number
       } | null
       if (!current) throw artifactStorageErrors.notFound(input.artifactId)
       if (current.kind !== input.kind) {
         throw artifactStorageErrors.kindMismatch(input.artifactId, current.kind, input.kind)
       }
+      // Inside the write transaction: a publish from the same base after this one finds it moved.
+      if (input.baseVersion !== undefined && current.latestVersion !== input.baseVersion) {
+        const latest = parseArtifactVersionRow(
+          this.db
+            .query(
+              `SELECT ${VERSION_COLUMNS} FROM artifact_versions
+               WHERE project_id = ? AND artifact_id = ? AND version = ?`
+            )
+            .get(input.projectId, input.artifactId, current.latestVersion) as Row
+        )
+        throw artifactStorageErrors.moved(input.artifactId, input.baseVersion, {
+          version: latest.version,
+          author: latest.author,
+        })
+      }
       const version = this.insertVersion(
         input.projectId,
         input.artifactId,
@@ -137,14 +171,14 @@ export class SqliteArtifactStorage implements ArtifactStorage {
       where.push("a.owner_principal_type = ? AND a.owner_principal_id = ?")
       params.push(input.owner.type, input.owner.id)
     }
-    if (input.originThreadId !== undefined) {
+    if (input.threadId !== undefined) {
       where.push(
         `EXISTS (
-          SELECT 1 FROM artifact_versions v
-          WHERE v.project_id = a.project_id AND v.artifact_id = a.id AND v.origin_thread_id = ?
+          SELECT 1 FROM artifact_threads t
+          WHERE t.project_id = a.project_id AND t.artifact_id = a.id AND t.thread_id = ?
         )`
       )
-      params.push(input.originThreadId)
+      params.push(input.threadId)
     }
     if (input.kind !== undefined) {
       where.push("a.kind = ?")
@@ -221,6 +255,70 @@ export class SqliteArtifactStorage implements ArtifactStorage {
     return rows.map(parseArtifactVersionRow)
   }
 
+  async listThreadIds(input: GetArtifactInput): Promise<string[]> {
+    const rows = this.db
+      .query(
+        `SELECT thread_id AS threadId FROM artifact_threads
+         WHERE project_id = ? AND artifact_id = ? ORDER BY thread_id`
+      )
+      .all(input.projectId, input.id) as { readonly threadId: string }[]
+    return rows.map((row) => row.threadId)
+  }
+
+  async copy(input: CopyArtifactInput): Promise<ArtifactRecord> {
+    return runImmediateTransaction(this.db, () => {
+      const source = this.db
+        .query("SELECT id FROM artifacts WHERE project_id = ? AND id = ?")
+        .get(input.projectId, input.sourceId)
+      if (!source) throw artifactStorageErrors.notFound(input.sourceId)
+
+      const artifact = this.db
+        .query(
+          `INSERT INTO artifacts (
+            project_id, id, kind, title, owner_principal_type, owner_principal_id,
+            latest_version, next_version, created_at, updated_at
+          )
+          SELECT project_id, ?, kind, title, ?, ?, latest_version, next_version, created_at,
+                 updated_at
+          FROM artifacts WHERE project_id = ? AND id = ?
+          ON CONFLICT (project_id, id) DO NOTHING
+          RETURNING ${ARTIFACT_COLUMNS}`
+        )
+        .get(
+          input.id,
+          input.owner.type,
+          input.owner.id,
+          input.projectId,
+          input.sourceId
+        ) as Row | null
+      if (!artifact) throw artifactStorageErrors.exists(input.id)
+
+      this.db
+        .query(
+          `INSERT INTO artifact_versions (
+            project_id, artifact_id, version, title, entry, files, outline, refs,
+            author_principal_type, author_principal_id, created_at
+          )
+          SELECT project_id, ?, version, title, entry, files, outline, refs,
+                 author_principal_type, author_principal_id, created_at
+          FROM artifact_versions WHERE project_id = ? AND artifact_id = ?`
+        )
+        .run(input.id, input.projectId, input.sourceId)
+      this.db
+        .query(
+          `INSERT INTO artifact_threads (project_id, artifact_id, thread_id, shared_at, copied)
+           VALUES (?, ?, ?, ?, 1)`
+        )
+        .run(
+          input.projectId,
+          input.id,
+          input.threadId,
+          (input.copiedAt ?? new Date()).toISOString()
+        )
+      return parseArtifactRow(artifact)
+    })
+  }
+
   async createFrameGrant(record: ArtifactFrameGrantRecord): Promise<void> {
     runImmediateTransaction(this.db, () => {
       const exists = this.db
@@ -269,8 +367,65 @@ export class SqliteArtifactStorage implements ArtifactStorage {
       .run(input.projectId, input.expiredBefore.toISOString(), input.limit).changes
   }
 
+  async getState(input: ArtifactStateKeyInput): Promise<ArtifactStateEntry | null> {
+    const row = this.db
+      .query(`SELECT ${STATE_COLUMNS} FROM artifact_state WHERE ${STATE_SCOPE} AND key = ?`)
+      .get(...stateScope(input), input.key) as Row | null
+    return row ? parseArtifactStateRow(row) : null
+  }
+
+  async setState(input: SetArtifactStateInput): Promise<void> {
+    runImmediateTransaction(this.db, () => {
+      const artifact = this.db
+        .query("SELECT 1 FROM artifacts WHERE project_id = ? AND id = ?")
+        .get(input.projectId, input.artifactId)
+      if (!artifact) throw artifactStorageErrors.notFound(input.artifactId)
+      // In the write transaction: two writes at once cannot both fit under the limits.
+      const others = this.db
+        .query(
+          `SELECT count(*) AS keys, coalesce(sum(size_bytes), 0) AS bytes FROM artifact_state
+           WHERE ${STATE_SCOPE} AND key <> ?`
+        )
+        .get(...stateScope(input), input.key) as { readonly keys: number; readonly bytes: number }
+      const sizeBytes = artifactStateBytes(input.value)
+      checkArtifactStateWrite({ key: input.key, valueBytes: sizeBytes, others })
+      this.db
+        .query(
+          `INSERT INTO artifact_state (
+            project_id, artifact_id, principal_type, principal_id, key, value, size_bytes,
+            updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT (project_id, artifact_id, principal_type, principal_id, key) DO UPDATE SET
+            value = excluded.value, size_bytes = excluded.size_bytes,
+            updated_at = excluded.updated_at`
+        )
+        .run(...stateScope(input), input.key, input.value, sizeBytes, input.updatedAt.toISOString())
+    })
+  }
+
+  async deleteState(input: ArtifactStateKeyInput): Promise<boolean> {
+    return (
+      this.db
+        .query(`DELETE FROM artifact_state WHERE ${STATE_SCOPE} AND key = ?`)
+        .run(...stateScope(input), input.key).changes > 0
+    )
+  }
+
+  async listState(input: ArtifactStateScope): Promise<ArtifactStateEntry[]> {
+    const rows = this.db
+      .query(`SELECT ${STATE_COLUMNS} FROM artifact_state WHERE ${STATE_SCOPE} ORDER BY key`)
+      .all(...stateScope(input)) as Row[]
+    return rows.map(parseArtifactStateRow)
+  }
+
+  async clearState(input: ArtifactStateScope): Promise<number> {
+    return this.db
+      .query(`DELETE FROM artifact_state WHERE ${STATE_SCOPE}`)
+      .run(...stateScope(input)).changes
+  }
+
   async delete(input: DeleteArtifactInput): Promise<boolean> {
-    // Versions and frame grants go with the artifact through ON DELETE CASCADE.
+    // Versions, frame grants, and state go with the artifact through ON DELETE CASCADE.
     return (
       this.db
         .query("DELETE FROM artifacts WHERE project_id = ? AND id = ?")
@@ -287,12 +442,35 @@ export class SqliteArtifactStorage implements ArtifactStorage {
         )
         .all(input.projectId, input.runId) as { readonly artifactId: string }[]
       const deleted = this.db
-        .query("DELETE FROM artifact_versions WHERE project_id = ? AND origin_run_id = ?")
-        .run(input.projectId, input.runId).changes
+        .query(
+          `DELETE FROM artifact_versions WHERE project_id = ? AND origin_run_id = ?
+           RETURNING origin_thread_id AS threadId`
+        )
+        .all(input.projectId, input.runId) as { readonly threadId: string }[]
+      // A run publishes from one thread: its artifacts stay shared there only while a version
+      // from it remains, or when they were copied for it.
+      const threadId = deleted[0]?.threadId
       for (const { artifactId } of affected) {
+        this.db
+          .query(
+            `DELETE FROM artifact_threads
+             WHERE project_id = ? AND artifact_id = ? AND thread_id = ? AND copied = 0
+               AND NOT EXISTS (
+                 SELECT 1 FROM artifact_versions
+                 WHERE project_id = ? AND artifact_id = ? AND origin_thread_id = ?
+               )`
+          )
+          .run(
+            input.projectId,
+            artifactId,
+            threadId ?? null,
+            input.projectId,
+            artifactId,
+            threadId ?? null
+          )
         this.repointLatest(input.projectId, artifactId)
       }
-      return deleted
+      return deleted.length
     })
   }
 
@@ -351,6 +529,25 @@ export class SqliteArtifactStorage implements ArtifactStorage {
         input.origin?.runId ?? null,
         input.createdAt.toISOString()
       ) as Row
+    if (input.origin) {
+      this.linkThread(projectId, artifactId, input.origin.threadId, input.createdAt)
+    }
     return parseArtifactVersionRow(row)
   }
+
+  /** Shares an artifact in a thread, keeping when it was first shared there. */
+  private linkThread(
+    projectId: string,
+    artifactId: string,
+    threadId: string,
+    sharedAt: Date
+  ): void {
+    this.db
+      .query(
+        `INSERT INTO artifact_threads (project_id, artifact_id, thread_id, shared_at)
+         VALUES (?, ?, ?, ?)
+         ON CONFLICT (project_id, artifact_id, thread_id) DO NOTHING`
+      )
+      .run(projectId, artifactId, threadId, sharedAt.toISOString())
+  }
 }

package/src/auth-storage/auth-storage.ts

@@ -12,6 +12,7 @@ import type {
   InvitationRecord,
   SessionRecord,
   SuspendUserAndRevokeSessionsInput,
+  UpdateAuthUserResult,
   UserIdentityRecord,
   UserRecord,
 } from "@sixb/core/storage"
@@ -32,7 +33,7 @@ import { SqliteAuthUserIdentityStore } from "./identities"
 import { SqliteAuthInvitationStore } from "./invitations"
 import { SqliteAuthMagicLinkStore } from "./magic-links"
 import { SqliteAuthOidcAuthorizationAttemptStore } from "./oidc-attempts"
-import type { SqliteAuthMagicLinkRow, SqliteAuthOidcAttemptRow } from "./rows"
+import type { SqliteAuthMagicLinkRow, SqliteAuthOidcAttemptRow, SqliteAuthUserRow } from "./rows"
 import { rowToIdentityRecord, rowToUserRecord, serializeOptionalRecord } from "./rows"
 import { SqliteAuthServiceAccountGroupMembershipStore } from "./service-account-group-memberships"
 import { SqliteAuthServiceAccountStore } from "./service-accounts"
@@ -216,16 +217,17 @@ export class SqliteAuthStorage implements AuthStorage {
           consumedAt: completedAt,
         })
 
-        const user = existingUserRow
-          ? rowToUserRecord(existingUserRow)
-          : this.insertUser({
-              id: newUserId ?? assertNonEmpty(input.newUserId, "User id"),
-              projectId,
-              email: magicLink.email,
-              displayName: input.newUserDisplayName,
-              avatarUrl: input.newUserAvatarUrl,
-              createdAt: completedAt,
-            })
+        const previousUser = existingUserRow ? rowToUserRecord(existingUserRow) : null
+        const user =
+          previousUser ??
+          this.insertUser({
+            id: newUserId ?? assertNonEmpty(input.newUserId, "User id"),
+            projectId,
+            email: magicLink.email,
+            displayName: input.newUserDisplayName,
+            avatarUrl: input.newUserAvatarUrl,
+            createdAt: completedAt,
+          })
 
         const invitation = this.acceptInvitationAndApplyGroups({
           activeInvitation,
@@ -253,6 +255,7 @@ export class SqliteAuthStorage implements AuthStorage {
           session,
           invitation: invitation.invitation,
           groupMemberships,
+          previousUser,
         }
       }
     )
@@ -297,7 +300,7 @@ export class SqliteAuthStorage implements AuthStorage {
               email,
               now: completedAt,
             })
-        let userRow = identity
+        const userRow = identity
           ? getUserRowById(this.db, { projectId, id: identity.user_id })
           : getUserRowByEmail(this.db, { projectId, email })
         const shouldCreateUser = !identity && !userRow
@@ -348,8 +351,10 @@ export class SqliteAuthStorage implements AuthStorage {
 
         this.consumeOidcAttempt(input, completedAt, projectId)
 
+        const previousUser = userRow ? rowToUserRecord(userRow) : null
+        let user: UserRecord
         if (!userRow) {
-          const user = this.insertUser({
+          user = this.insertUser({
             id: newUserId ?? assertNonEmpty(input.newUserId, "User id"),
             projectId,
             email,
@@ -357,19 +362,10 @@ export class SqliteAuthStorage implements AuthStorage {
             avatarUrl: input.avatarUrl,
             createdAt: completedAt,
           })
-          userRow = {
-            project_id: user.projectId,
-            id: user.id,
-            email: user.email,
-            display_name: user.displayName ?? null,
-            avatar_url: user.avatarUrl ?? null,
-            status: user.status,
-            created_at: toIso(user.createdAt),
-            updated_at: toIso(user.updatedAt),
-          }
+        } else {
+          user = this.refreshProviderProfile(userRow, input, completedAt)
         }
 
-        const user = rowToUserRecord(userRow)
         const invitation = this.acceptInvitationAndApplyGroups({
           activeInvitation,
           completedAt,
@@ -412,6 +408,7 @@ export class SqliteAuthStorage implements AuthStorage {
           identity: nextIdentity,
           invitation: invitation.invitation,
           groupMemberships,
+          previousUser,
         }
       }
     )
@@ -425,7 +422,7 @@ export class SqliteAuthStorage implements AuthStorage {
 
   async suspendUserAndRevokeSessions(
     input: SuspendUserAndRevokeSessionsInput
-  ): Promise<UserRecord> {
+  ): Promise<UpdateAuthUserResult> {
     return runImmediateTransaction(this.db, () => {
       const existing = getUserRowById(this.db, {
         projectId: input.projectId,
@@ -456,11 +453,12 @@ export class SqliteAuthStorage implements AuthStorage {
         revokedAt: input.suspendedAt,
       })
 
-      return rowToUserRecord({
+      const user = rowToUserRecord({
         ...existing,
         status: "suspended",
         updated_at: toIso(input.suspendedAt),
       })
+      return { user, previousUser: rowToUserRecord(existing) }
     })
   }
 
@@ -526,6 +524,40 @@ export class SqliteAuthStorage implements AuthStorage {
     }
   }
 
+  // The identity provider owns the name and picture it sends: every sign-in overwrites them, and
+  // one it leaves out keeps the stored value.
+  private refreshProviderProfile(
+    row: SqliteAuthUserRow,
+    input: CompleteOidcSignInInput,
+    updatedAt: Date
+  ): UserRecord {
+    const displayName = input.displayName ?? row.display_name
+    const avatarUrl = input.avatarUrl ?? row.avatar_url
+    if (displayName === row.display_name && avatarUrl === row.avatar_url) {
+      return rowToUserRecord(row)
+    }
+
+    this.db
+      .query(
+        `
+        UPDATE auth_users
+        SET display_name = ?,
+            avatar_url = ?,
+            updated_at = ?
+        WHERE project_id = ?
+          AND id = ?
+      `
+      )
+      .run(displayName, avatarUrl, toIso(updatedAt), row.project_id, row.id)
+
+    return rowToUserRecord({
+      ...row,
+      display_name: displayName,
+      avatar_url: avatarUrl,
+      updated_at: toIso(updatedAt),
+    })
+  }
+
   private insertUser(input: {
     readonly id: string
     readonly projectId: string