or3-provider-sqlite 0.0.9 → 0.0.11

package/dist/runtime/server/db/migrate.js

@@ -16,6 +16,9 @@ import * as m014 from "./migrations/014_connect_retention_activation.js";
 import * as m015 from "./migrations/015_rate_limits.js";
 import * as m016 from "./migrations/016_connect_runtime_binding.js";
 import * as m017 from "./migrations/017_background_jobs.js";
+import * as m018 from "./migrations/018_background_admission_cancels.js";
+import * as m019 from "./migrations/019_background_generation_history.js";
+import * as m020 from "./migrations/020_background_generation_receipts.js";
 const REQUIRED_SCHEMA_TABLES = [
   "users",
   "auth_accounts",
@@ -41,7 +44,9 @@ const REQUIRED_SCHEMA_TABLES = [
   "connect_device_authorizations",
   "connect_environments",
   "rate_limits",
-  "background_jobs"
+  "background_jobs",
+  "background_admission_cancels",
+  "background_generation_receipts"
 ];
 const migrations = {
   "001_init": m001,
@@ -60,7 +65,10 @@ const migrations = {
   "014_connect_retention_activation": m014,
   "015_rate_limits": m015,
   "016_connect_runtime_binding": m016,
-  "017_background_jobs": m017
+  "017_background_jobs": m017,
+  "018_background_admission_cancels": m018,
+  "019_background_generation_history": m019,
+  "020_background_generation_receipts": m020
 };
 class StaticMigrationProvider {
   async getMigrations() {

package/dist/runtime/server/db/migrations/018_background_admission_cancels.d.ts

@@ -0,0 +1,7 @@
+import { type Kysely } from 'kysely';
+/**
+ * Durable admission cancellations. Creation and cancellation both check this
+ * table so a Stop that arrives before the job row commits cannot launch work.
+ */
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;

package/dist/runtime/server/db/migrations/018_background_admission_cancels.js

@@ -0,0 +1,18 @@
+import { sql } from "kysely";
+export async function up(db) {
+  await sql`
+        CREATE TABLE IF NOT EXISTS background_admission_cancels (
+            user_id TEXT NOT NULL,
+            admission_id TEXT NOT NULL,
+            expires_at INTEGER NOT NULL,
+            PRIMARY KEY (user_id, admission_id)
+        )
+    `.execute(db);
+  await sql`
+        CREATE INDEX IF NOT EXISTS background_admission_cancels_expiry
+        ON background_admission_cancels(expires_at)
+    `.execute(db);
+}
+export async function down(db) {
+  await sql`DROP TABLE IF EXISTS background_admission_cancels`.execute(db);
+}

package/dist/runtime/server/db/migrations/019_background_generation_history.d.ts

@@ -0,0 +1,7 @@
+import { type Kysely } from 'kysely';
+/**
+ * Generation identity, durable history phase, and accumulated reasoning on
+ * background jobs. Reasoning is kept distinct from request reasoning config.
+ */
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;

package/dist/runtime/server/db/migrations/019_background_generation_history.js

@@ -0,0 +1,25 @@
+import { sql } from "kysely";
+export async function up(db) {
+  await sql`
+        ALTER TABLE background_jobs
+        ADD COLUMN reasoning TEXT NOT NULL DEFAULT ''
+    `.execute(db);
+  await sql`
+        ALTER TABLE background_jobs
+        ADD COLUMN generation_id TEXT
+    `.execute(db);
+  await sql`
+        ALTER TABLE background_jobs
+        ADD COLUMN history_phase TEXT
+    `.execute(db);
+  await sql`
+        ALTER TABLE background_jobs
+        ADD COLUMN sync_provider_id TEXT
+    `.execute(db);
+}
+export async function down(db) {
+  await sql`ALTER TABLE background_jobs DROP COLUMN sync_provider_id`.execute(db);
+  await sql`ALTER TABLE background_jobs DROP COLUMN history_phase`.execute(db);
+  await sql`ALTER TABLE background_jobs DROP COLUMN generation_id`.execute(db);
+  await sql`ALTER TABLE background_jobs DROP COLUMN reasoning`.execute(db);
+}

package/dist/runtime/server/db/migrations/020_background_generation_receipts.d.ts

@@ -0,0 +1,4 @@
+import { type Kysely } from 'kysely';
+/** Durable replay receipts for canonical background-history transactions. */
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;

package/dist/runtime/server/db/migrations/020_background_generation_receipts.js

@@ -0,0 +1,19 @@
+import { sql } from "kysely";
+export async function up(db) {
+  await sql`
+        CREATE TABLE background_generation_receipts (
+            id TEXT PRIMARY KEY,
+            workspace_id TEXT NOT NULL,
+            generation_id TEXT NOT NULL,
+            stage TEXT NOT NULL CHECK(stage IN ('admission', 'finalization')),
+            fingerprint TEXT NOT NULL,
+            outcome TEXT NOT NULL,
+            server_version INTEGER,
+            created_at INTEGER NOT NULL,
+            UNIQUE(workspace_id, generation_id, stage)
+        )
+    `.execute(db);
+}
+export async function down(db) {
+  await sql`DROP TABLE IF EXISTS background_generation_receipts`.execute(db);
+}

package/dist/runtime/server/db/schema.d.ts

@@ -197,6 +197,10 @@ export interface BackgroundJobsTable {
     kind: string | null;
     status: 'streaming' | 'complete' | 'error' | 'aborted';
     content: string;
+    reasoning: string;
+    generation_id: string | null;
+    history_phase: string | null;
+    sync_provider_id: string | null;
     chunks_received: number;
     started_at: number;
     last_activity_at: number;
@@ -210,6 +214,16 @@ export interface BackgroundJobsTable {
     lease_expires_at: number | null;
     attempts: number;
 }
+export interface BackgroundGenerationReceiptsTable {
+    id: string;
+    workspace_id: string;
+    generation_id: string;
+    stage: 'admission' | 'finalization';
+    fingerprint: string;
+    outcome: string;
+    server_version: number | null;
+    created_at: number;
+}
 export interface AdminUsersTable {
     user_id: string;
     created_at: number;
@@ -239,6 +253,7 @@ export interface Or3SqliteDb {
     connect_environments: ConnectEnvironmentsTable;
     rate_limits: RateLimitsTable;
     background_jobs: BackgroundJobsTable;
+    background_generation_receipts: BackgroundGenerationReceiptsTable;
     s_threads: SyncedEntityTable;
     s_messages: SyncedEntityTable;
     s_projects: SyncedEntityTable;

package/dist/runtime/server/plugin-connections/sqlite-connection-store.d.ts

@@ -0,0 +1,7 @@
+import type { PluginConnectionStore } from '~~/server/utils/plugins/connections/store/registry';
+import { type SqliteRawDatabase } from '../db/kysely.js';
+type SqliteDatabase = SqliteRawDatabase;
+export declare function createSqlitePluginConnectionStore(options?: {
+    database?: SqliteDatabase;
+}): PluginConnectionStore;
+export {};

package/dist/runtime/server/plugin-connections/sqlite-connection-store.js

@@ -0,0 +1,209 @@
+import {
+  getRawDb,
+  getSqliteDriver
+} from "../db/kysely.js";
+function parseStringArray(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((value) => typeof value === "string");
+  } catch {
+    return [];
+  }
+}
+function toConnection(row) {
+  return {
+    id: row.id,
+    ownerUserId: row.owner_user_id,
+    workspaceId: row.workspace_id,
+    pluginId: row.plugin_id,
+    providerId: row.provider_id,
+    ...row.slot_id === null ? {} : { slotId: row.slot_id },
+    label: row.label,
+    scopes: parseStringArray(row.scopes),
+    revision: row.revision,
+    secretCiphertext: row.secret_ciphertext,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function toEvidence(row) {
+  return {
+    connectionId: row.connection_id,
+    revision: row.revision,
+    operationId: row.operation_id,
+    ok: row.ok === 1,
+    ...row.code === null ? {} : { code: row.code },
+    checkedAt: row.checked_at,
+    ...row.detail === null ? {} : { detail: row.detail }
+  };
+}
+class SqlitePluginConnectionStore {
+  constructor(db) {
+    this.db = db;
+    this.#initialize();
+  }
+  #initialize() {
+    if (getSqliteDriver() !== "turso") {
+      this.db.pragma?.("journal_mode = WAL");
+      this.db.pragma?.("synchronous = NORMAL");
+      this.db.pragma?.("foreign_keys = ON");
+    }
+    this.db.exec?.(`
+            CREATE TABLE IF NOT EXISTS plugin_connections (
+                id TEXT PRIMARY KEY,
+                owner_user_id TEXT NOT NULL,
+                workspace_id TEXT NOT NULL,
+                plugin_id TEXT NOT NULL,
+                provider_id TEXT NOT NULL,
+                slot_id TEXT,
+                label TEXT NOT NULL DEFAULT '',
+                scopes TEXT NOT NULL DEFAULT '[]',
+                revision INTEGER NOT NULL DEFAULT 1,
+                secret_ciphertext TEXT NOT NULL,
+                created_at INTEGER NOT NULL,
+                updated_at INTEGER NOT NULL
+            );
+
+            CREATE TABLE IF NOT EXISTS plugin_connection_tests (
+                connection_id TEXT PRIMARY KEY,
+                revision INTEGER NOT NULL,
+                operation_id TEXT NOT NULL,
+                ok INTEGER NOT NULL,
+                code TEXT,
+                checked_at INTEGER NOT NULL,
+                detail TEXT,
+                FOREIGN KEY (connection_id) REFERENCES plugin_connections(id) ON DELETE CASCADE
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_plugin_connections_workspace_plugin
+                ON plugin_connections (workspace_id, plugin_id);
+            CREATE INDEX IF NOT EXISTS idx_plugin_connections_owner
+                ON plugin_connections (owner_user_id);
+        `);
+    try {
+      this.db.prepare(`ALTER TABLE plugin_connections ADD COLUMN slot_id TEXT`).run();
+    } catch {
+    }
+  }
+  /**
+   * Owner-scoped listing. Ownership is part of the SQL predicate so a workspace
+   * peer cannot discover another user's connections or their references.
+   */
+  async list(input) {
+    const rows = input.pluginId === void 0 ? this.db.prepare(
+      `SELECT * FROM plugin_connections WHERE owner_user_id = ? AND workspace_id = ? ORDER BY created_at ASC`
+    ).all(input.ownerUserId, input.workspaceId) : this.db.prepare(
+      `SELECT * FROM plugin_connections WHERE owner_user_id = ? AND workspace_id = ? AND plugin_id = ? ORDER BY created_at ASC`
+    ).all(input.ownerUserId, input.workspaceId, input.pluginId);
+    return rows.map(toConnection);
+  }
+  async get(id) {
+    const row = this.db.prepare(`SELECT * FROM plugin_connections WHERE id = ?`).get(id);
+    return row ? toConnection(row) : null;
+  }
+  /**
+   * Insert-only creation. `DO NOTHING` is deliberate: an upsert here could
+   * reassign an existing record's owner, workspace, plugin or provider when two
+   * processes happen to generate the same id.
+   */
+  async insert(connection) {
+    const result = this.db.prepare(
+      `INSERT INTO plugin_connections (
+                    id, owner_user_id, workspace_id, plugin_id, provider_id, slot_id,
+                    label, scopes, revision, secret_ciphertext, created_at, updated_at
+                 ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                 ON CONFLICT(id) DO NOTHING`
+    ).run(
+      connection.id,
+      connection.ownerUserId,
+      connection.workspaceId,
+      connection.pluginId,
+      connection.providerId,
+      connection.slotId ?? null,
+      connection.label,
+      JSON.stringify(connection.scopes),
+      connection.revision,
+      connection.secretCiphertext,
+      connection.createdAt,
+      connection.updatedAt
+    );
+    return result.changes > 0;
+  }
+  /**
+   * Compare-and-swap update. Identity columns are not in the SET list, so a
+   * retry cannot move the record; the revision predicate is the whole
+   * concurrency control.
+   */
+  async update(update) {
+    const result = this.db.prepare(
+      `UPDATE plugin_connections
+                    SET revision = ?,
+                        secret_ciphertext = ?,
+                        updated_at = ?,
+                        scopes = COALESCE(?, scopes),
+                        label = COALESCE(?, label)
+                  WHERE id = ? AND revision = ?`
+    ).run(
+      update.revision,
+      update.secretCiphertext,
+      update.updatedAt,
+      update.scopes === void 0 ? null : JSON.stringify(update.scopes),
+      update.label ?? null,
+      update.id,
+      update.expectedRevision
+    );
+    return result.changes > 0;
+  }
+  async delete(id) {
+    this.db.prepare(`DELETE FROM plugin_connections WHERE id = ?`).run(id);
+    this.db.prepare(`DELETE FROM plugin_connection_tests WHERE connection_id = ?`).run(id);
+  }
+  async getTestEvidence(connectionId) {
+    const row = this.db.prepare(`SELECT * FROM plugin_connection_tests WHERE connection_id = ?`).get(connectionId);
+    return row ? toEvidence(row) : null;
+  }
+  /**
+   * Stores evidence only when it belongs to the connection's current revision
+   * and is not older than what is already stored. A slow test that finishes
+   * after a credential rotation therefore cannot reinstate itself as current
+   * evidence, and an older completion cannot replace a newer result.
+   */
+  async setTestEvidence(evidence) {
+    const result = this.db.prepare(
+      `INSERT INTO plugin_connection_tests (
+                    connection_id, revision, operation_id, ok, code, checked_at, detail
+                 )
+                 SELECT ?, ?, ?, ?, ?, ?, ?
+                  WHERE EXISTS (
+                        SELECT 1 FROM plugin_connections
+                         WHERE id = ? AND revision = ?
+                  )
+                 ON CONFLICT(connection_id) DO UPDATE SET
+                    revision = excluded.revision,
+                    operation_id = excluded.operation_id,
+                    ok = excluded.ok,
+                    code = excluded.code,
+                    checked_at = excluded.checked_at,
+                    detail = excluded.detail
+                  WHERE excluded.revision > plugin_connection_tests.revision
+                     OR (excluded.revision = plugin_connection_tests.revision
+                         AND excluded.checked_at >= plugin_connection_tests.checked_at)`
+    ).run(
+      evidence.connectionId,
+      evidence.revision,
+      evidence.operationId,
+      evidence.ok ? 1 : 0,
+      evidence.code ?? null,
+      evidence.checkedAt,
+      evidence.detail ?? null,
+      evidence.connectionId,
+      evidence.revision
+    );
+    return result.changes > 0;
+  }
+}
+export function createSqlitePluginConnectionStore(options = {}) {
+  const db = options.database ?? getRawDb();
+  return new SqlitePluginConnectionStore(db);
+}

package/dist/runtime/server/plugins/register.js

@@ -5,6 +5,7 @@ import { registerAdminStoreProvider } from "~~/server/admin/stores/registry";
 import { registerSyncGatewayAdapter } from "~~/server/sync/gateway/registry";
 import { registerWebhookStore } from "~~/server/utils/webhooks/store/registry";
 import { registerConnectStore } from "~~/server/connect/store/registry";
+import { registerPluginConnectionStore } from "~~/server/utils/plugins/connections/store/registry";
 import { registerRateLimitProvider } from "~~/server/utils/rate-limit/registry";
 import { registerBackgroundJobProvider } from "~~/server/utils/background-jobs/registry";
 import { createSqliteAuthWorkspaceStore } from "../auth/sqlite-auth-workspace-store.js";
@@ -17,6 +18,7 @@ import {
 } from "../admin/stores/sqlite-store.js";
 import { sqliteSyncAdminAdapter } from "../admin/adapters/sync-sqlite.js";
 import { createSqliteConnectStore } from "../connect/sqlite-connect-store.js";
+import { createSqlitePluginConnectionStore } from "../plugin-connections/sqlite-connection-store.js";
 import { getSqliteDriver, initializeSqliteDb } from "../db/kysely.js";
 import { runMigrations } from "../db/migrate.js";
 import { sqliteRateLimitProvider } from "../rate-limit/sqlite-provider.js";
@@ -72,6 +74,17 @@ export default defineNitroPlugin(async (nitroApp) => {
       "[or3-sqlite] Webhook persistence is unavailable with Cloudflare D1."
     );
   }
+  if (driver !== "d1") {
+    registerPluginConnectionStore({
+      id: SQLITE_PROVIDER_ID,
+      order: 100,
+      create: createSqlitePluginConnectionStore
+    });
+  } else {
+    console.warn(
+      "[or3-sqlite] Plugin connection persistence is unavailable with Cloudflare D1."
+    );
+  }
   registerAdminStoreProvider({
     id: SQLITE_PROVIDER_ID,
     createWorkspaceAccessStore: createSqliteWorkspaceAccessStore,

package/dist/runtime/server/sync/history-gc-policy.d.ts

@@ -11,3 +11,11 @@ export declare const SYNC_HISTORY_GC_POLICY: Readonly<{
     reason: "SQLite history GC is guarded by the verified snapshot-v1 retention contract.";
 }>;
 export declare function canRunSyncHistoryGc(): boolean;
+export declare function computePullRetention(input: {
+    cursor: number;
+    oldestLogVersion: number | null;
+    highWatermark: number;
+}): {
+    oldestRetainedVersion: number;
+    requiresSnapshot: boolean;
+};

package/dist/runtime/server/sync/history-gc-policy.js

@@ -6,3 +6,10 @@ export const SYNC_HISTORY_GC_POLICY = Object.freeze({
 export function canRunSyncHistoryGc() {
   return SYNC_HISTORY_GC_POLICY.enabled && SYNC_HISTORY_GC_POLICY.snapshotBootstrapVerified;
 }
+export function computePullRetention(input) {
+  const oldestRetainedVersion = input.oldestLogVersion ?? Math.max(0, input.highWatermark) + 1;
+  return {
+    oldestRetainedVersion,
+    requiresSnapshot: oldestRetainedVersion > 0 && input.cursor < Math.max(0, oldestRetainedVersion - 1)
+  };
+}

package/dist/runtime/server/sync/sqlite-sync-gateway-adapter.d.ts

@@ -7,14 +7,26 @@
  */
 import type { H3Event } from 'h3';
 import type { CanonicalStorageQueryRequest, CanonicalStorageQueryResponse, SyncGatewayAdapter, SyncMaintenanceState, UploadIntentConsumptionRequest, UploadIntentReservationRequest } from '~~/server/sync/gateway/types';
+import type { AdmitChatGenerationResult, CanonicalGenerationSnapshot, CanonicalHistoryActor, ChatGenerationAdmissionEnvelope, FinalizeChatGenerationResult } from '~~/shared/chat/background-history';
 import type { PullRequest, PullResponse, PushBatch, PushResult, SnapshotRequest, SnapshotResponse } from '~~/shared/sync/types';
 export declare class SqliteSyncGatewayAdapter implements SyncGatewayAdapter {
     id: string;
-    readonly capabilities: {
+    get capabilities(): {
         readonly snapshotBootstrap: "snapshot-v1";
         readonly historyRetention: "snapshot-v1";
+        readonly backgroundGenerationHistory?: undefined;
+    } | {
+        readonly snapshotBootstrap: "snapshot-v1";
+        readonly historyRetention: "snapshot-v1";
+        readonly backgroundGenerationHistory: "v1";
     };
     private get db();
+    private assertCanonicalActor;
+    admitChatGeneration(actor: CanonicalHistoryActor, input: ChatGenerationAdmissionEnvelope): Promise<AdmitChatGenerationResult>;
+    finalizeChatGeneration(actor: CanonicalHistoryActor, input: {
+        admission: ChatGenerationAdmissionEnvelope;
+        snapshot: CanonicalGenerationSnapshot;
+    }): Promise<FinalizeChatGenerationResult>;
     reserveUploadIntent(event: H3Event, input: UploadIntentReservationRequest): Promise<void>;
     consumeUploadIntent(event: H3Event, input: UploadIntentConsumptionRequest): Promise<void>;
     cancelUploadIntent(event: H3Event, input: {