rivet-design 0.23.1 → 0.25.0

package/dist/services/profiles/DesignProfiles.js

@@ -34,11 +34,14 @@ const ProfileImports_1 = require("./ProfileImports");
 const ProfilePlanning_1 = require("./ProfilePlanning");
 const cosmos_1 = require("../../types/cosmos");
 const reference_onboarding_1 = require("../../types/reference-onboarding");
+const ProfileVariants_1 = require("./ProfileVariants");
+const ProjectLibrary_1 = require("../ProjectLibrary");
 const ProfileImportSchedule_1 = require("./ProfileImportSchedule");
 const ProviderRateLimit_1 = require("../../utils/ProviderRateLimit");
 const design_profile_3 = require("../../types/design-profile");
 const errorMessage_1 = require("../../utils/errorMessage");
 const APPROVAL_TIMEOUT_MS = 45_000;
+const SAVED_REFERENCE_IMAGE_LIMIT = 20;
 const librarySources = (records) => records.sources().map(({ id, title, provider, isIncluded }) => ({
     id,
     title,
@@ -52,6 +55,256 @@ class DesignProfiles {
     constructor(options) {
         this.options = options;
     }
+    async readDesignContext(input) {
+        return this.withReadOnlyRecords(async (records) => {
+            if (!records) {
+                if (input.importPlanId)
+                    throw new Error('Unknown reference import plan');
+                if (input.instructionIds?.length || input.referenceSelection)
+                    throw new Error('The selected saved design context is unavailable');
+                return { profileId: null, instructions: [], references: [] };
+            }
+            const selected = input.instructionIds
+                ? [...new Set(input.instructionIds)].map((id) => records.getGuidance(id))
+                : records
+                    .listGuidance()
+                    .filter((document) => input.includeDisabled || document.isEnabled);
+            const instructions = selected.map((document) => {
+                const { sourceDigest, verifier } = records.getGuidanceVerifier(document.id);
+                return {
+                    ...document,
+                    sourceDigest,
+                    ...(input.includeChecks && verifier
+                        ? {
+                            verifier: {
+                                markdown: verifier.markdown,
+                                sourceDigest: verifier.sourceDigest,
+                                isStale: sourceDigest !== verifier.sourceDigest,
+                                ...(verifier.package
+                                    ? {
+                                        package: {
+                                            runtime: verifier.package.runtime,
+                                            entrypoint: verifier.package.entrypoint,
+                                            fileNames: verifier.package.files.map((file) => file.name),
+                                        },
+                                    }
+                                    : {}),
+                            },
+                        }
+                        : {}),
+                };
+            });
+            const selection = input.referenceSelection;
+            const references = selection
+                ? await this.readReferenceContexts(records, {
+                    ...selection,
+                    isDetailed: true,
+                })
+                : { references: [] };
+            if (!references)
+                throw new Error('The selected saved references are unavailable');
+            const importPlan = input.importPlanId
+                ? this.importPlanReceipt(records, input.importPlanId)
+                : undefined;
+            return {
+                profileId: records.profile().id,
+                instructions,
+                references: references.references,
+                ...(importPlan ? { importPlan } : {}),
+            };
+        });
+    }
+    importPlanReceipt(records, id) {
+        const plan = records.plans.plan(id);
+        const jobs = new Map(records.jobs().map((job) => [job.id, job]));
+        return {
+            ...(0, reference_onboarding_1.referencePlanSummary)(plan),
+            coverageBasis: 'retained_job_references',
+            jobs: plan.jobIds.map((jobId) => {
+                const job = jobs.get(jobId);
+                if (!job)
+                    throw new Error(`Reference import job ${jobId} is unavailable`);
+                return {
+                    ...job,
+                    coverage: records.importCoverage(jobId),
+                    failures: records.failures(jobId),
+                };
+            }),
+        };
+    }
+    async searchSavedReferences(input) {
+        return this.withReadOnlyRecords((records) => {
+            if (!records)
+                return {
+                    profileId: null,
+                    query: input.query,
+                    searchMode: 'saved_text',
+                    coverage: { saved: 0, analyzed: 0, indexed: 0 },
+                    results: [],
+                };
+            const terms = [
+                ...new Set(input.query.toLocaleLowerCase().match(/[\p{L}\p{N}]+/gu) ?? []),
+            ];
+            const allReferences = records.libraryReferences();
+            const matches = allReferences
+                .flatMap((reference) => {
+                if (input.sourceId && !reference.sourceIds.includes(input.sourceId))
+                    return [];
+                const title = reference.title.toLocaleLowerCase();
+                const text = [
+                    reference.text,
+                    reference.note ?? '',
+                    reference.observation?.description ?? '',
+                ]
+                    .join(' ')
+                    .toLocaleLowerCase();
+                if (!terms.length ||
+                    !terms.every((term) => title.includes(term) || text.includes(term)))
+                    return [];
+                return [
+                    {
+                        reference,
+                        score: terms.filter((term) => title.includes(term)).length,
+                    },
+                ];
+            })
+                .sort((left, right) => right.score - left.score ||
+                left.reference.id.localeCompare(right.reference.id))
+                .map(({ reference }) => reference);
+            return {
+                ...(0, profileSearch_1.profileSearchResult)({
+                    profileId: records.profile().id,
+                    query: input.query,
+                    matches,
+                    allReferences,
+                    sources: librarySources(records),
+                    coverage: records.coverage(),
+                    limit: input.limit,
+                }),
+                searchMode: 'saved_text',
+            };
+        });
+    }
+    async saveReference(input) {
+        return this.withReferenceRecords(async (records, accountId) => {
+            const media = new ProfileMedia_1.ProfileMedia(records.directory);
+            const remoteId = (0, crypto_1.randomUUID)();
+            const referenceInput = await this.suppliedReferenceInput(input, media, remoteId);
+            this.guidanceAccount(accountId);
+            const result = records.saveLocalReferences({
+                source: {
+                    provider: referenceInput[0].provider,
+                    remoteId,
+                    title: input.title,
+                },
+                references: referenceInput,
+            });
+            return {
+                profileId: records.profile().id,
+                ...result,
+                analysis: 'not_requested',
+            };
+        });
+    }
+    async suppliedReferenceInput(input, media, remoteId) {
+        const { source, title } = input;
+        switch (source.kind) {
+            case 'text':
+                if (!source.text.trim())
+                    throw new Error('A saved text reference must contain text');
+                return [
+                    { provider: 'text', remoteId, title, text: source.text, media: [] },
+                ];
+            case 'images': {
+                if (!source.files.length ||
+                    source.files.length > SAVED_REFERENCE_IMAGE_LIMIT)
+                    throw new Error(`Supply between 1 and ${SAVED_REFERENCE_IMAGE_LIMIT} image files`);
+                const images = [];
+                let bytes = 0;
+                for (const file of source.files) {
+                    const stat = await promises_1.default.lstat(file);
+                    if (!path_1.default.isAbsolute(file) ||
+                        !stat.isFile() ||
+                        stat.size > ProfileMedia_1.PROFILE_IMAGE_BYTES)
+                        throw new Error('Supply bounded regular image files with absolute paths');
+                    bytes += stat.size;
+                    if (bytes > design_profile_3.PROFILE_UPLOAD_BYTES)
+                        throw new Error('Supplied images exceed the reference upload budget');
+                    images.push(await media.put(await promises_1.default.readFile(file)));
+                }
+                return images.map((image, index) => ({
+                    provider: 'image',
+                    remoteId: image.hash,
+                    title: images.length === 1 ? title : `${title} ${index + 1}`,
+                    text: '',
+                    media: [image],
+                }));
+            }
+            case 'saved_direction': {
+                if (!source.imageFile)
+                    throw new Error('Saving a direction requires an existing screenshot file');
+                const variantInput = {
+                    projectId: source.projectId,
+                    sessionId: source.sessionId,
+                    variantId: source.variantId,
+                    imageFile: source.imageFile,
+                    note: source.note,
+                    runtime: 'codex',
+                };
+                const load = async () => {
+                    const signal = new AbortController().signal;
+                    if (this.options.variants)
+                        return this.options.variants.load(variantInput, signal);
+                    const library = await ProjectLibrary_1.ProjectLibrary.open(this.options.root);
+                    const variants = new ProfileVariants_1.ProfileVariants({ library });
+                    try {
+                        return await variants.load(variantInput, signal);
+                    }
+                    finally {
+                        await variants.close();
+                        library.close();
+                    }
+                };
+                const saved = await load();
+                const image = await media.put(saved.image);
+                return [
+                    {
+                        ...saved.reference,
+                        title,
+                        media: [{ ...image, representation: 'variant' }],
+                    },
+                ];
+            }
+        }
+    }
+    async removeReference(input) {
+        return this.withReferenceRecords((records) => {
+            if (records.profile().id !== input.profileId)
+                throw new Error('The selected reference belongs to another profile');
+            records.removeReference(input.referenceId);
+            return {
+                profileId: input.profileId,
+                referenceId: input.referenceId,
+                isRemoved: true,
+            };
+        });
+    }
+    async withReadOnlyRecords(operation) {
+        const accountId = this.guidanceAccount();
+        const records = ProfileRecords_1.ProfileRecords.openReadOnly({
+            root: this.options.root,
+            accountId,
+        });
+        try {
+            this.guidanceAccount(accountId);
+            const result = await operation(records);
+            this.guidanceAccount(accountId);
+            return result;
+        }
+        finally {
+            records?.close();
+        }
+    }
     async listGuidance(expectedAccountId) {
         return this.withGuidanceRecords((records) => records.listGuidance(), expectedAccountId);
     }
@@ -226,7 +479,7 @@ class DesignProfiles {
             throw error;
         }
     }
-    async discoverReferences({ signal = new AbortController().signal, ...input }) {
+    async discoverReferences({ isAuthorizationAllowed = true, signal = new AbortController().signal, ...input }) {
         try {
             const discovery = await this.withReferenceRecords((records, accountId) => this.planning(records, accountId).discover({ ...input, signal }));
             const provider = (0, reference_connectors_1.referenceProvider)(discovery.profile);
@@ -239,7 +492,8 @@ class DesignProfiles {
         catch (error) {
             if (!(error instanceof reference_pages_1.ReferenceConnectionError) ||
                 error.reason !== 'not_connected' ||
-                !('provider' in input))
+                !('provider' in input) ||
+                !isAuthorizationAllowed)
                 throw error;
             const connection = await (this.options.integrations ?? new IntegrationsClient_1.IntegrationsClient()).connect(input.provider);
             if (connection.status !== 'ok')
@@ -684,98 +938,99 @@ class DesignProfiles {
         });
     }
     async referenceContexts(input) {
-        return this.withReferenceRecords(async (records) => {
-            if (records.profile().id !== input.profileId)
-                return null;
-            const identities = [...new Set(input.keys)].map((key) => {
-                const [prefix, revision] = key.split('@');
-                return { key, prefix, revision: Number(revision) };
-            });
-            const select = () => {
-                const candidates = records.libraryReferences(identities.map((identity) => identity.prefix));
-                const selected = [];
-                const seen = new Set();
-                for (const identity of identities) {
-                    const matches = candidates.filter((reference) => reference.id.startsWith(identity.prefix));
-                    if (matches.length > 1)
-                        throw new contextReceipts_1.ProfileContextConflict('Reference key is ambiguous. Copy the selection again from Design library.');
-                    const reference = matches[0];
-                    if (!reference)
-                        return null;
-                    if (reference.revision !== identity.revision)
-                        throw new contextReceipts_1.ProfileContextConflict('A saved reference has changed. Copy the selection again from Design library.');
-                    if (seen.has(reference.id))
-                        continue;
-                    seen.add(reference.id);
-                    selected.push({ key: identity.key, reference });
+        return this.withReferenceRecords((records) => this.readReferenceContexts(records, input));
+    }
+    async readReferenceContexts(records, input) {
+        if (records.profile().id !== input.profileId)
+            return null;
+        const identities = [...new Set(input.keys)].map((key) => {
+            const [prefix, revision] = key.split('@');
+            return { key, prefix, revision: Number(revision) };
+        });
+        const select = () => {
+            const candidates = records.libraryReferences(identities.map((identity) => identity.prefix));
+            const selected = [];
+            const seen = new Set();
+            for (const identity of identities) {
+                const matches = candidates.filter((reference) => reference.id.startsWith(identity.prefix));
+                if (matches.length > 1)
+                    throw new contextReceipts_1.ProfileContextConflict('Reference key is ambiguous. Copy the selection again from Design library.');
+                const reference = matches[0];
+                if (!reference)
+                    return null;
+                if (reference.revision !== identity.revision)
+                    throw new contextReceipts_1.ProfileContextConflict('A saved reference has changed. Copy the selection again from Design library.');
+                if (seen.has(reference.id))
+                    continue;
+                seen.add(reference.id);
+                selected.push({ key: identity.key, reference });
+            }
+            return selected;
+        };
+        const selected = select();
+        if (!selected)
+            return null;
+        const summarize = ({ key, reference }) => ({
+            key,
+            title: reference.title,
+            imageCount: reference.media.length,
+            hasAnalysis: reference.observation !== null,
+        });
+        if (!input.isDetailed)
+            return { references: selected.map(summarize) };
+        const media = new ProfileMedia_1.ProfileMedia(records.directory);
+        const paths = new Map();
+        for (const { reference } of selected) {
+            for (const image of reference.media) {
+                if (paths.has(image.hash))
+                    continue;
+                try {
+                    paths.set(image.hash, await media.resolve(image));
                 }
-                return selected;
-            };
-            const selected = select();
-            if (!selected)
-                return null;
-            const summarize = ({ key, reference }) => ({
-                key,
-                title: reference.title,
-                imageCount: reference.media.length,
-                hasAnalysis: reference.observation !== null,
-            });
-            if (!input.isDetailed)
-                return { references: selected.map(summarize) };
-            const media = new ProfileMedia_1.ProfileMedia(records.directory);
-            const paths = new Map();
-            for (const { reference } of selected) {
-                for (const image of reference.media) {
-                    if (paths.has(image.hash))
-                        continue;
-                    try {
-                        paths.set(image.hash, await media.resolve(image));
-                    }
-                    catch (error) {
-                        if (typeof error !== 'object' ||
-                            error === null ||
-                            !('code' in error) ||
-                            error.code !== 'ENOENT')
-                            throw error;
-                        paths.set(image.hash, null);
-                    }
+                catch (error) {
+                    if (typeof error !== 'object' ||
+                        error === null ||
+                        !('code' in error) ||
+                        error.code !== 'ENOENT')
+                        throw error;
+                    paths.set(image.hash, null);
                 }
             }
-            const current = select();
-            if (!current)
-                return null;
-            const sources = records.sources();
-            return {
-                references: current.map((entry) => {
-                    const { reference } = entry;
-                    const contextImages = reference.media.flatMap((image) => {
-                        const location = paths.get(image.hash);
-                        return location ? [location] : [];
-                    });
-                    return {
-                        ...summarize(entry),
-                        text: reference.text,
-                        ...(reference.note ? { note: reference.note } : {}),
-                        analysis: reference.observation
-                            ? {
-                                description: reference.observation.description,
-                                evidence: reference.observation.evidence,
-                            }
-                            : null,
-                        sources: sources
-                            .filter((source) => reference.sourceIds.includes(source.id))
-                            .map(({ id, title, provider, isIncluded }) => ({
-                            id,
-                            title,
-                            provider,
-                            isIncluded,
-                        })),
-                        contextImages,
-                        missingMediaCount: reference.media.length - contextImages.length,
-                    };
-                }),
-            };
-        });
+        }
+        const current = select();
+        if (!current)
+            return null;
+        const sources = records.sources();
+        return {
+            references: current.map((entry) => {
+                const { reference } = entry;
+                const contextImages = reference.media.flatMap((image) => {
+                    const location = paths.get(image.hash);
+                    return location ? [location] : [];
+                });
+                return {
+                    ...summarize(entry),
+                    text: reference.text,
+                    ...(reference.note ? { note: reference.note } : {}),
+                    analysis: reference.observation
+                        ? {
+                            description: reference.observation.description,
+                            evidence: reference.observation.evidence,
+                        }
+                        : null,
+                    sources: sources
+                        .filter((source) => reference.sourceIds.includes(source.id))
+                        .map(({ id, title, provider, isIncluded }) => ({
+                        id,
+                        title,
+                        provider,
+                        isIncluded,
+                    })),
+                    contextImages,
+                    missingMediaCount: reference.media.length - contextImages.length,
+                };
+            }),
+        };
     }
     async referenceMedia({ profileId, referenceId, hash, }) {
         return this.withReferenceRecords(async (records) => {

package/dist/services/profiles/MemoryRuntime.js

@@ -9,6 +9,7 @@ const path_1 = __importDefault(require("path"));
 const crypto_1 = require("crypto");
 const child_process_1 = require("child_process");
 const net_1 = require("net");
+const subprocessEnvironment_1 = require("../../utils/subprocessEnvironment");
 const events_1 = require("events");
 const promises_2 = require("timers/promises");
 const memoryComponents_1 = require("./memoryComponents");
@@ -87,11 +88,8 @@ class MemoryRuntime {
         const providerUrl = await this.provider.start();
         this.token = (0, crypto_1.randomBytes)(32).toString('hex');
         this.base = `http://127.0.0.1:${address.port}`;
-        const env = {};
-        for (const key of ['PATH', 'HOME', 'TMPDIR', 'LANG'])
-            if (process.env[key])
-                env[key] = process.env[key];
-        Object.assign(env, {
+        const env = {
+            ...(0, subprocessEnvironment_1.subprocessEnvironment)('profileMemory'),
             SUPERMEMORY_DATA_DIR: data,
             SUPERMEMORY_PORT: String(address.port),
             SUPERMEMORY_DISABLE_TELEMETRY: '1',
@@ -105,7 +103,7 @@ class MemoryRuntime {
             RIVET_MEMORY_ACCESS_TOKEN: this.token,
             ANTHROPIC_API_KEY: this.provider.token,
             ANTHROPIC_BASE_URL: providerUrl,
-        });
+        };
         const preload = path_1.default.resolve(__dirname, '../../../dist/services/profiles/engineAccess.js');
         await promises_1.default.access(preload);
         signal.throwIfAborted();

package/dist/services/profiles/ProfileAgent.js

@@ -9,7 +9,7 @@ const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const workerRuntime_1 = require("../../agent-variants/workerRuntime");
 const callerRunnerPaths_1 = require("../../cli/callerRunnerPaths");
-const hostAgentEnv_1 = require("../../utils/hostAgentEnv");
+const subprocessEnvironment_1 = require("../../utils/subprocessEnvironment");
 const modelContract_1 = require("./modelContract");
 const TASK_TIMEOUT_MS = 120_000;
 const OUTPUT_BYTES = 8 * 1024 * 1024;
@@ -48,6 +48,7 @@ class ProfileAgent {
                 prompt,
             });
             const stdout = await this.execute({
+                runtime: task.runtime,
                 binary: adapter.binary,
                 args,
                 directory,
@@ -136,12 +137,12 @@ class ProfileAgent {
             args.push(files.prompt);
         return args;
     }
-    execute({ binary, args, directory, prompt, signal, }) {
+    execute({ runtime, binary, args, directory, prompt, signal, }) {
         return new Promise((resolve, reject) => {
             signal.throwIfAborted();
             const child = (0, child_process_1.spawn)(binary, args, {
                 cwd: directory,
-                env: (0, hostAgentEnv_1.sanitizeHostAgentEnv)(),
+                env: (0, subprocessEnvironment_1.subprocessEnvironment)(runtime),
                 stdio: ['pipe', 'pipe', 'pipe'],
                 detached: process.platform !== 'win32',
             });

package/dist/services/profiles/ProfileImports.d.ts

@@ -16,7 +16,7 @@ export declare class ProfileImports {
     }): {
         source: {
             id: string;
-            provider: "variant" | "text" | "arena" | "pinterest" | "image" | "x" | "cosmos" | "pdf";
+            provider: "variant" | "text" | "pinterest" | "arena" | "cosmos" | "x" | "image" | "pdf";
             remoteId: string;
             resolvedRemoteId: string | null;
             title: string;
@@ -30,7 +30,7 @@ export declare class ProfileImports {
             id: string;
             sourceId: string;
             runtime: "claude" | "codex" | "cursor";
-            state: "pending" | "failed" | "complete" | "superseded" | "paused";
+            state: "pending" | "failed" | "superseded" | "complete" | "paused";
             cursor: string | null;
             enumerated: number;
             total: number | null;

package/dist/services/profiles/ProfilePlanning.d.ts

@@ -20,9 +20,9 @@ export declare class ProfilePlanning {
         id: string;
         total: number;
         collections: {
+            description: string | null;
             url: string | null;
             title: string;
-            description: string | null;
             id: string;
             children: string[];
             total: number | null;
@@ -51,9 +51,9 @@ export declare class ProfilePlanning {
         discoveryId: string;
         sources: {
             references: {
-                provider: "arena" | "pinterest" | "x" | "cosmos";
                 title: string;
                 text: string;
+                provider: "pinterest" | "arena" | "cosmos" | "x";
                 remoteId: string;
                 media: {
                     hash: string;
@@ -62,22 +62,22 @@ export declare class ProfilePlanning {
                     representation: "variant" | "image" | "video-cover" | "page";
                     page?: number | undefined;
                 }[];
-                url?: string | undefined;
                 variant?: {
                     projectId: string;
                     sessionId: string;
                     variantId: string;
                     treeSha?: string | undefined;
                 } | undefined;
+                url?: string | undefined;
                 note?: string | undefined;
                 remoteImages?: string[] | undefined;
                 remoteImageRepresentations?: ("image" | "video-cover")[] | undefined;
                 unsupportedReason?: string | undefined;
             }[];
             collection: {
+                description: string | null;
                 url: string | null;
                 title: string;
-                description: string | null;
                 id: string;
                 children: string[];
                 total: number | null;

package/dist/services/profiles/ProfilePreparation.js

@@ -108,6 +108,7 @@ class ProfilePreparation {
         return packet;
     }
     async select(input, packet, directory, signal) {
+        await this.index.flush(input.runtime, signal);
         if (!this.records.candidates(this.records
             .references()
             .map(({ id, revision }) => ({ referenceId: id, revision }))).length)

package/dist/services/profiles/ProfileVariants.d.ts

@@ -3,7 +3,7 @@ import type { StaticLibraryPreviews } from '../StaticLibraryPreviews';
 import { type ProfileVariantInput, type ProfileReferenceInput } from '../../types/design-profile';
 interface VariantServices {
     library: ProjectLibrary;
-    previews: StaticLibraryPreviews;
+    previews?: StaticLibraryPreviews;
 }
 export interface PinnedVariant {
     projectId: string;

package/dist/services/profiles/ProfileVariants.js

@@ -85,7 +85,7 @@ class ProfileVariants {
             image = await promises_1.default.readFile(value.imageFile);
         }
         else {
-            if (!found.detail.hasStaticPreview)
+            if (!found.detail.hasStaticPreview || !previews)
                 throw new Error('This direction needs an explicit screenshot; supply imageFile from its rendered preview');
             const captured = await this.screenshots.capture(await previews.url(value));
             if (!captured.startsWith(JPEG_PREFIX))