rivet-design 0.18.1 → 0.18.3

package/dist/storage/library/schema/projectRuntime.d.ts

@@ -0,0 +1,72 @@
+export declare const projectRuntime: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "project_runtime";
+    schema: undefined;
+    columns: {
+        singleton: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project_runtime";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        pid: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project_runtime";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        token: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project_runtime";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        phase: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project_runtime";
+            dataType: "string enum";
+            data: "active" | "starting" | "retiring";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["active", "starting", "retiring"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: "sqlite";
+}>;
+//# sourceMappingURL=projectRuntime.d.ts.map

package/dist/storage/library/schema/projectRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectRuntime.d.ts","sourceRoot":"","sources":["../../../../src/storage/library/schema/projectRuntime.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgB1B,CAAC"}

package/dist/storage/library/schema/projectRuntime.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectRuntime = void 0;
+const drizzle_orm_1 = require("drizzle-orm");
+const sqlite_core_1 = require("drizzle-orm/sqlite-core");
+exports.projectRuntime = (0, sqlite_core_1.sqliteTable)('project_runtime', {
+    singleton: (0, sqlite_core_1.integer)().primaryKey(),
+    pid: (0, sqlite_core_1.integer)().notNull(),
+    token: (0, sqlite_core_1.text)().notNull(),
+    phase: (0, sqlite_core_1.text)({ enum: ['active', 'starting', 'retiring'] }).notNull(),
+}, (table) => [
+    (0, sqlite_core_1.check)('project_runtime_singleton', (0, drizzle_orm_1.sql) `${table.singleton} = 1`),
+    (0, sqlite_core_1.check)('project_runtime_pid', (0, drizzle_orm_1.sql) `${table.pid} > 0`),
+    (0, sqlite_core_1.check)('project_runtime_phase', (0, drizzle_orm_1.sql) `${table.phase} IN ('active', 'starting', 'retiring')`),
+]);
+//# sourceMappingURL=projectRuntime.js.map

package/dist/storage/library/schema/projectRuntime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectRuntime.js","sourceRoot":"","sources":["../../../../src/storage/library/schema/projectRuntime.ts"],"names":[],"mappings":";;;AAAA,6CAAkC;AAClC,yDAA4E;AAE/D,QAAA,cAAc,GAAG,IAAA,yBAAW,EACvC,iBAAiB,EACjB;IACE,SAAS,EAAE,IAAA,qBAAO,GAAE,CAAC,UAAU,EAAE;IACjC,GAAG,EAAE,IAAA,qBAAO,GAAE,CAAC,OAAO,EAAE;IACxB,KAAK,EAAE,IAAA,kBAAI,GAAE,CAAC,OAAO,EAAE;IACvB,KAAK,EAAE,IAAA,kBAAI,EAAC,EAAE,IAAI,EAAE,CAAC,QAAQ,EAAE,UAAU,EAAE,UAAU,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE;CACpE,EACD,CAAC,KAAK,EAAE,EAAE,CAAC;IACT,IAAA,mBAAK,EAAC,2BAA2B,EAAE,IAAA,iBAAG,EAAA,GAAG,KAAK,CAAC,SAAS,MAAM,CAAC;IAC/D,IAAA,mBAAK,EAAC,qBAAqB,EAAE,IAAA,iBAAG,EAAA,GAAG,KAAK,CAAC,GAAG,MAAM,CAAC;IACnD,IAAA,mBAAK,EACH,uBAAuB,EACvB,IAAA,iBAAG,EAAA,GAAG,KAAK,CAAC,KAAK,wCAAwC,CAC1D;CACF,CACF,CAAC"}

package/dist/storage/profiles/ProfilePlans.d.ts

@@ -0,0 +1,320 @@
+import { type ReferenceProvider } from '../../types/reference-connectors';
+import { z } from 'zod';
+import { type openDurableDatabase } from '../library/database';
+import { ReferenceDiscoveryInputSchema, ReferencePlanInputSchema, type ReferenceImportPlan, type ReferenceOnboardingAction } from '../../types/reference-onboarding';
+type Database = Awaited<ReturnType<typeof openDurableDatabase>>;
+export declare class ProfilePlans {
+    private readonly db;
+    constructor(db: Database);
+    saveDiscovery(input: z.input<typeof ReferenceDiscoveryInputSchema>): {
+        id: string;
+        total: number;
+        collections: {
+            id: string;
+            url: string | null;
+            title: string;
+            description: string | null;
+            children: string[];
+            total: number | null;
+            parentId: string | null;
+        }[];
+        profile: {
+            id: string;
+            url: string;
+            title: string;
+            username: string;
+        };
+        createdAt: string;
+    };
+    discovery(id: string): {
+        id: string;
+        total: number;
+        collections: {
+            id: string;
+            url: string | null;
+            title: string;
+            description: string | null;
+            children: string[];
+            total: number | null;
+            parentId: string | null;
+        }[];
+        profile: {
+            id: string;
+            url: string;
+            title: string;
+            username: string;
+        };
+        createdAt: string;
+    };
+    discoveries(): {
+        id: string;
+        total: number;
+        collections: {
+            id: string;
+            url: string | null;
+            title: string;
+            description: string | null;
+            children: string[];
+            total: number | null;
+            parentId: string | null;
+        }[];
+        profile: {
+            id: string;
+            url: string;
+            title: string;
+            username: string;
+        };
+        createdAt: string;
+    }[];
+    savePlan(input: z.input<typeof ReferencePlanInputSchema>): {
+        id: string;
+        runtime: "claude" | "codex" | "cursor";
+        revision: string;
+        profile: {
+            id: string;
+            url: string;
+            title: string;
+            username: string;
+        };
+        createdAt: string;
+        discoveryId: string;
+        sources: {
+            references: {
+                text: string;
+                provider: "arena" | "pinterest" | "x" | "cosmos";
+                title: string;
+                remoteId: string;
+                media: {
+                    hash: string;
+                    mimeType: "image/png" | "image/jpeg" | "image/webp" | "image/gif";
+                    bytes: number;
+                    representation: "image" | "variant" | "video-cover" | "page";
+                    page?: number | undefined;
+                }[];
+                url?: string | undefined;
+                variant?: {
+                    sessionId: string;
+                    projectId: string;
+                    variantId: string;
+                    treeSha?: string | undefined;
+                } | undefined;
+                note?: string | undefined;
+                remoteImages?: string[] | undefined;
+                remoteImageRepresentations?: ("image" | "video-cover")[] | undefined;
+                unsupportedReason?: string | undefined;
+            }[];
+            collection: {
+                id: string;
+                url: string | null;
+                title: string;
+                description: string | null;
+                children: string[];
+                total: number | null;
+                parentId: string | null;
+            };
+            collectionIds: string[];
+        }[];
+        reusableCount: number;
+        expiresAt: string;
+        approvedAt: string | null;
+        jobIds: string[];
+    };
+    plan(id: string): {
+        id: string;
+        runtime: "claude" | "codex" | "cursor";
+        revision: string;
+        profile: {
+            id: string;
+            url: string;
+            title: string;
+            username: string;
+        };
+        createdAt: string;
+        discoveryId: string;
+        sources: {
+            references: {
+                text: string;
+                provider: "arena" | "pinterest" | "x" | "cosmos";
+                title: string;
+                remoteId: string;
+                media: {
+                    hash: string;
+                    mimeType: "image/png" | "image/jpeg" | "image/webp" | "image/gif";
+                    bytes: number;
+                    representation: "image" | "variant" | "video-cover" | "page";
+                    page?: number | undefined;
+                }[];
+                url?: string | undefined;
+                variant?: {
+                    sessionId: string;
+                    projectId: string;
+                    variantId: string;
+                    treeSha?: string | undefined;
+                } | undefined;
+                note?: string | undefined;
+                remoteImages?: string[] | undefined;
+                remoteImageRepresentations?: ("image" | "video-cover")[] | undefined;
+                unsupportedReason?: string | undefined;
+            }[];
+            collection: {
+                id: string;
+                url: string | null;
+                title: string;
+                description: string | null;
+                children: string[];
+                total: number | null;
+                parentId: string | null;
+            };
+            collectionIds: string[];
+        }[];
+        reusableCount: number;
+        expiresAt: string;
+        approvedAt: string | null;
+        jobIds: string[];
+    };
+    plans(): {
+        id: string;
+        runtime: "claude" | "codex" | "cursor";
+        revision: string;
+        profile: {
+            id: string;
+            url: string;
+            title: string;
+            username: string;
+        };
+        createdAt: string;
+        discoveryId: string;
+        sources: {
+            references: {
+                text: string;
+                provider: "arena" | "pinterest" | "x" | "cosmos";
+                title: string;
+                remoteId: string;
+                media: {
+                    hash: string;
+                    mimeType: "image/png" | "image/jpeg" | "image/webp" | "image/gif";
+                    bytes: number;
+                    representation: "image" | "variant" | "video-cover" | "page";
+                    page?: number | undefined;
+                }[];
+                url?: string | undefined;
+                variant?: {
+                    sessionId: string;
+                    projectId: string;
+                    variantId: string;
+                    treeSha?: string | undefined;
+                } | undefined;
+                note?: string | undefined;
+                remoteImages?: string[] | undefined;
+                remoteImageRepresentations?: ("image" | "video-cover")[] | undefined;
+                unsupportedReason?: string | undefined;
+            }[];
+            collection: {
+                id: string;
+                url: string | null;
+                title: string;
+                description: string | null;
+                children: string[];
+                total: number | null;
+                parentId: string | null;
+            };
+            collectionIds: string[];
+        }[];
+        reusableCount: number;
+        expiresAt: string;
+        approvedAt: string | null;
+        jobIds: string[];
+    }[];
+    approve({ id, revision, isApproved, createJobs, }: {
+        id: string;
+        revision: string;
+        isApproved: boolean;
+        createJobs: (plan: ReferenceImportPlan) => Array<{
+            id: string;
+            sourceId: string;
+            collectionId: string;
+        }>;
+    }): {
+        id: string;
+        runtime: "claude" | "codex" | "cursor";
+        revision: string;
+        profile: {
+            id: string;
+            url: string;
+            title: string;
+            username: string;
+        };
+        createdAt: string;
+        discoveryId: string;
+        sources: {
+            references: {
+                text: string;
+                provider: "arena" | "pinterest" | "x" | "cosmos";
+                title: string;
+                remoteId: string;
+                media: {
+                    hash: string;
+                    mimeType: "image/png" | "image/jpeg" | "image/webp" | "image/gif";
+                    bytes: number;
+                    representation: "image" | "variant" | "video-cover" | "page";
+                    page?: number | undefined;
+                }[];
+                url?: string | undefined;
+                variant?: {
+                    sessionId: string;
+                    projectId: string;
+                    variantId: string;
+                    treeSha?: string | undefined;
+                } | undefined;
+                note?: string | undefined;
+                remoteImages?: string[] | undefined;
+                remoteImageRepresentations?: ("image" | "video-cover")[] | undefined;
+                unsupportedReason?: string | undefined;
+            }[];
+            collection: {
+                id: string;
+                url: string | null;
+                title: string;
+                description: string | null;
+                children: string[];
+                total: number | null;
+                parentId: string | null;
+            };
+            collectionIds: string[];
+        }[];
+        reusableCount: number;
+        expiresAt: string;
+        approvedAt: string | null;
+        jobIds: string[];
+    };
+    sourcePlan(sourceId: string): {
+        sourceId: string;
+        discoveryId: string;
+        collectionId: string;
+    } | null;
+    sourceByUrl(url: string): {
+        sourceId: string;
+    } | null;
+    isPlannedSource(sourceId: string): boolean;
+    onboarding(provider?: ReferenceProvider): {
+        provider: "arena" | "pinterest" | "x" | "cosmos";
+        state: "pending" | "complete" | "later" | "dismissed";
+        offeredAt: string | null;
+        remindAt: string | null;
+    };
+    updateOnboarding(action: ReferenceOnboardingAction, provider?: ReferenceProvider): {
+        provider: "arena" | "pinterest" | "x" | "cosmos";
+        state: "pending" | "complete" | "later" | "dismissed";
+        offeredAt: string | null;
+        remindAt: string | null;
+    };
+    notice(provider?: ReferenceProvider): {
+        provider: "arena" | "pinterest" | "x" | "cosmos";
+        message: string;
+        command: string;
+        laterCommand: string;
+        dismissCommand: string;
+    } | null;
+}
+export {};
+//# sourceMappingURL=ProfilePlans.d.ts.map

package/dist/storage/profiles/ProfilePlans.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProfilePlans.d.ts","sourceRoot":"","sources":["../../../src/storage/profiles/ProfilePlans.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAe,KAAK,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAS5E,OAAO,EAKL,6BAA6B,EAE7B,wBAAwB,EAExB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC/B,MAAM,kCAAkC,CAAC;AAE1C,KAAK,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC;AAEhE,qBAAa,YAAY;IACX,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,QAAQ;IAczC,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC;;;;;;;;;;;;;;;;;;;;IAmBlE,SAAS,CAAC,EAAE,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;IAUpB,WAAW;;;;;;;;;;;;;;;;;;;;IAQX,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsDxD,IAAI,CAAC,EAAE,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUf,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQL,OAAO,CAAC,EACN,EAAE,EACF,QAAQ,EACR,UAAU,EACV,UAAU,GACX,EAAE;QACD,EAAE,EAAE,MAAM,CAAC;QACX,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,OAAO,CAAC;QACpB,UAAU,EAAE,CACV,IAAI,EAAE,mBAAmB,KACtB,KAAK,CAAC;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,YAAY,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAuDD,UAAU,CAAC,QAAQ,EAAE,MAAM;;;;;IAU3B,WAAW,CAAC,GAAG,EAAE,MAAM;;;IAWvB,eAAe,CAAC,QAAQ,EAAE,MAAM;IAIhC,UAAU,CAAC,QAAQ,GAAE,iBAA4B;;;;;;IAejD,gBAAgB,CACd,MAAM,EAAE,yBAAyB,EACjC,QAAQ,GAAE,iBAA4B;;;;;;IA6BxC,MAAM,CAAC,QAAQ,GAAE,iBAA4B;;;;;;;CA0C9C"}

package/dist/storage/profiles/ProfilePlans.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfilePlans = void 0;
+const reference_connectors_1 = require("../../types/reference-connectors");
+const crypto_1 = require("crypto");
+const drizzle_orm_1 = require("drizzle-orm");
+const database_1 = require("../library/database");
+const planSchema_1 = require("./planSchema");
+const schema_1 = require("./schema");
+const reference_onboarding_1 = require("../../types/reference-onboarding");
+class ProfilePlans {
+    db;
+    constructor(db) {
+        this.db = db;
+        const preference = db.select().from(planSchema_1.referenceOnboarding).get();
+        if (preference)
+            db.insert(planSchema_1.connectorOnboarding)
+                .values({
+                provider: 'cosmos',
+                state: preference.state,
+                offeredAt: preference.offeredAt,
+                remindAt: preference.remindAt,
+            })
+                .onConflictDoNothing()
+                .run();
+    }
+    saveDiscovery(input) {
+        const parsed = reference_onboarding_1.ReferenceDiscoveryInputSchema.parse(input);
+        if (parsed.total !== parsed.collections.length ||
+            new Set(parsed.collections.map((item) => item.id)).size !== parsed.total)
+            throw new Error('Incomplete profile collection discovery');
+        const discovery = reference_onboarding_1.ReferenceDiscoverySchema.parse({
+            ...parsed,
+            id: (0, crypto_1.randomUUID)(),
+            createdAt: new Date().toISOString(),
+        });
+        this.db
+            .insert(planSchema_1.referenceDiscoveries)
+            .values({ id: discovery.id, body: discovery })
+            .run();
+        return discovery;
+    }
+    discovery(id) {
+        const record = this.db
+            .select()
+            .from(planSchema_1.referenceDiscoveries)
+            .where((0, drizzle_orm_1.eq)(planSchema_1.referenceDiscoveries.id, id))
+            .get();
+        if (!record)
+            throw new Error('Unknown reference discovery');
+        return reference_onboarding_1.ReferenceDiscoverySchema.parse(record.body);
+    }
+    discoveries() {
+        return this.db
+            .select()
+            .from(planSchema_1.referenceDiscoveries)
+            .all()
+            .map((record) => reference_onboarding_1.ReferenceDiscoverySchema.parse(record.body));
+    }
+    savePlan(input) {
+        const parsed = reference_onboarding_1.ReferencePlanInputSchema.parse(input);
+        const discovery = this.discovery(parsed.discoveryId);
+        const available = new Set(discovery.collections.map((collection) => collection.id));
+        if (parsed.sources.some((source) => !available.has(source.collection.id)) ||
+            new Set(parsed.sources.map((source) => source.collection.id)).size !==
+                parsed.sources.length)
+            throw new Error('Choose each collection from this discovery only once');
+        if (parsed.sources.some((source) => source.references.some((reference) => reference.provider !== (0, reference_connectors_1.referenceProvider)(discovery.profile))))
+            throw new Error('Reference provider does not match the discovered account');
+        const unique = new Set(parsed.sources.flatMap((source) => source.references.map((reference) => reference.remoteId)));
+        if (unique.size > reference_onboarding_1.REFERENCE_PLAN_LIMIT ||
+            parsed.reusableCount > unique.size)
+            throw new Error('Reference plan exceeds its coverage limit; select fewer collections');
+        const body = JSON.stringify(parsed);
+        if (Buffer.byteLength(body) > reference_onboarding_1.REFERENCE_PLAN_BYTES)
+            throw new Error('Reference plan is too large; select fewer collections');
+        const plan = reference_onboarding_1.ReferencePlanSchema.parse({
+            ...parsed,
+            id: (0, crypto_1.randomUUID)(),
+            profile: discovery.profile,
+            revision: (0, crypto_1.createHash)('sha256').update(body).digest('hex'),
+            createdAt: new Date().toISOString(),
+            expiresAt: new Date(Date.now() + reference_onboarding_1.REFERENCE_PLAN_LIFETIME_MS).toISOString(),
+            approvedAt: null,
+            jobIds: [],
+        });
+        this.db.insert(planSchema_1.referencePlans).values({ id: plan.id, body: plan }).run();
+        return plan;
+    }
+    plan(id) {
+        const record = this.db
+            .select()
+            .from(planSchema_1.referencePlans)
+            .where((0, drizzle_orm_1.eq)(planSchema_1.referencePlans.id, id))
+            .get();
+        if (!record)
+            throw new Error('Unknown reference import plan');
+        return reference_onboarding_1.ReferencePlanSchema.parse(record.body);
+    }
+    plans() {
+        return this.db
+            .select()
+            .from(planSchema_1.referencePlans)
+            .all()
+            .map((record) => reference_onboarding_1.ReferencePlanSchema.parse(record.body));
+    }
+    approve({ id, revision, isApproved, createJobs, }) {
+        if (!isApproved)
+            throw new Error('Explicit user approval is required');
+        return (0, database_1.transaction)(this.db, () => {
+            const plan = this.plan(id);
+            if (plan.revision !== revision)
+                throw new Error('Import plan revision does not match the reviewed plan');
+            if (plan.approvedAt)
+                return plan;
+            if (Date.now() >= Date.parse(plan.expiresAt))
+                throw new Error('Import plan expired; prepare and review another plan');
+            const jobs = createJobs(plan);
+            for (const job of jobs)
+                this.db
+                    .insert(planSchema_1.plannedSources)
+                    .values({
+                    sourceId: job.sourceId,
+                    collectionId: job.collectionId,
+                    discoveryId: plan.discoveryId,
+                })
+                    .onConflictDoUpdate({
+                    target: planSchema_1.plannedSources.sourceId,
+                    set: {
+                        discoveryId: plan.discoveryId,
+                        collectionId: job.collectionId,
+                    },
+                })
+                    .run();
+            const approved = {
+                ...plan,
+                approvedAt: new Date().toISOString(),
+                jobIds: jobs.map((job) => job.id),
+            };
+            this.db
+                .update(planSchema_1.referencePlans)
+                .set({ body: approved })
+                .where((0, drizzle_orm_1.eq)(planSchema_1.referencePlans.id, id))
+                .run();
+            this.db
+                .insert(planSchema_1.connectorOnboarding)
+                .values({
+                provider: (0, reference_connectors_1.referenceProvider)(plan.profile),
+                state: 'complete',
+                offeredAt: null,
+                remindAt: null,
+            })
+                .onConflictDoUpdate({
+                target: planSchema_1.connectorOnboarding.provider,
+                set: { state: 'complete', remindAt: null },
+            })
+                .run();
+            return approved;
+        });
+    }
+    sourcePlan(sourceId) {
+        return (this.db
+            .select()
+            .from(planSchema_1.plannedSources)
+            .where((0, drizzle_orm_1.eq)(planSchema_1.plannedSources.sourceId, sourceId))
+            .get() ?? null);
+    }
+    sourceByUrl(url) {
+        return (this.db
+            .select({ sourceId: planSchema_1.plannedSources.sourceId })
+            .from(planSchema_1.plannedSources)
+            .innerJoin(schema_1.sources, (0, drizzle_orm_1.eq)(schema_1.sources.id, planSchema_1.plannedSources.sourceId))
+            .where((0, drizzle_orm_1.eq)(schema_1.sources.url, url))
+            .get() ?? null);
+    }
+    isPlannedSource(sourceId) {
+        return this.sourcePlan(sourceId) !== null;
+    }
+    onboarding(provider = 'cosmos') {
+        return (this.db
+            .select()
+            .from(planSchema_1.connectorOnboarding)
+            .where((0, drizzle_orm_1.eq)(planSchema_1.connectorOnboarding.provider, provider))
+            .get() ?? {
+            provider,
+            state: 'pending',
+            offeredAt: null,
+            remindAt: null,
+        });
+    }
+    updateOnboarding(action, provider = 'cosmos') {
+        const state = action === 'dismiss' ? 'dismissed' : action;
+        this.db
+            .insert(planSchema_1.connectorOnboarding)
+            .values({
+            provider,
+            state: state === 'reset' ? 'pending' : state,
+            offeredAt: null,
+            remindAt: action === 'later'
+                ? new Date(Date.now() + reference_onboarding_1.REFERENCE_REMINDER_DELAY_MS).toISOString()
+                : null,
+        })
+            .onConflictDoUpdate({
+            target: planSchema_1.connectorOnboarding.provider,
+            set: {
+                state: state === 'reset' ? 'pending' : state,
+                offeredAt: null,
+                remindAt: action === 'later'
+                    ? new Date(Date.now() + reference_onboarding_1.REFERENCE_REMINDER_DELAY_MS).toISOString()
+                    : null,
+            },
+        })
+            .run();
+        return this.onboarding(provider);
+    }
+    notice(provider = 'cosmos') {
+        return (0, database_1.transaction)(this.db, () => {
+            const state = this.onboarding(provider);
+            if (state.state === 'complete' ||
+                state.state === 'dismissed' ||
+                state.offeredAt ||
+                (state.remindAt && Date.now() < Date.parse(state.remindAt)))
+                return null;
+            this.db
+                .insert(planSchema_1.connectorOnboarding)
+                .values({
+                provider,
+                state: 'pending',
+                offeredAt: new Date().toISOString(),
+                remindAt: null,
+            })
+                .onConflictDoUpdate({
+                target: planSchema_1.connectorOnboarding.provider,
+                set: {
+                    state: 'pending',
+                    offeredAt: new Date().toISOString(),
+                    remindAt: null,
+                },
+            })
+                .run();
+            return {
+                provider,
+                message: provider === 'cosmos'
+                    ? 'Offer to connect a public Cosmos profile. Ask for its URL, discover collections, and present an import plan. Analysis consumes the selected agent usage allowance. Wait for explicit approval before importing.'
+                    : `Offer to connect ${provider} so Rivet can draw on saved inspiration across projects. Discover collections, complete OAuth if requested, then repeat discovery. Show the import plan and agent usage disclosure, and wait for explicit user approval.`,
+                command: provider === 'cosmos'
+                    ? 'rivet profile discover <public-profile-url>'
+                    : `rivet profile discover ${provider}`,
+                laterCommand: `rivet profile onboarding later --provider ${provider}`,
+                dismissCommand: `rivet profile onboarding dismiss --provider ${provider}`,
+            };
+        });
+    }
+}
+exports.ProfilePlans = ProfilePlans;
+//# sourceMappingURL=ProfilePlans.js.map