primitive-admin 1.0.40 → 1.0.42

package/dist/src/commands/sync.js

@@ -124,6 +124,62 @@ function serializeWebhook(webhook) {
     });
     return TOML.stringify(data);
 }
+function serializeCronTrigger(trigger) {
+    const data = {
+        cronTrigger: {
+            key: trigger.triggerKey,
+            displayName: trigger.displayName,
+            description: trigger.description || undefined,
+            cron: trigger.cron,
+            timezone: trigger.timezone || "UTC",
+            workflowKey: trigger.workflowKey,
+            overlapPolicy: trigger.overlapPolicy || "skip",
+            state: trigger.state,
+        },
+    };
+    if (trigger.rootInput) {
+        try {
+            data.rootInput = JSON.parse(trigger.rootInput);
+        }
+        catch {
+            data.rootInput = { raw: trigger.rootInput };
+        }
+    }
+    if (trigger.inputMapping) {
+        try {
+            data.inputMapping = JSON.parse(trigger.inputMapping);
+        }
+        catch {
+            data.inputMapping = { raw: trigger.inputMapping };
+        }
+    }
+    // Remove undefined values
+    Object.keys(data.cronTrigger).forEach(k => {
+        if (data.cronTrigger[k] === undefined)
+            delete data.cronTrigger[k];
+    });
+    return TOML.stringify(data);
+}
+function serializeBlobBucket(bucket) {
+    const data = {
+        bucket: {
+            key: bucket.bucketKey,
+            name: bucket.name,
+            description: bucket.description || undefined,
+            ttlTier: bucket.ttlTier,
+            accessPolicy: bucket.accessPolicy,
+        },
+    };
+    if (bucket.ruleSetId) {
+        data.bucket.ruleSetId = bucket.ruleSetId;
+    }
+    // Remove undefined values
+    Object.keys(data.bucket).forEach(k => {
+        if (data.bucket[k] === undefined)
+            delete data.bucket[k];
+    });
+    return TOML.stringify(data);
+}
 function serializePrompt(prompt) {
     const data = {
         prompt: {
@@ -256,6 +312,16 @@ function serializeGroupTypeConfig(config, ruleSetIdToName) {
     };
     return TOML.stringify(data);
 }
+function serializeCollectionTypeConfig(config, ruleSetIdToName) {
+    const ruleSetName = config.ruleSetId ? (ruleSetIdToName.get(config.ruleSetId) || "") : "";
+    const data = {
+        collectionTypeConfig: {
+            collectionType: config.collectionType,
+            ruleSetName: ruleSetName,
+        },
+    };
+    return TOML.stringify(data);
+}
 export function parseDatabaseTypeToml(tomlData) {
     const typeSection = tomlData.type || {};
     const typeConfig = {
@@ -308,6 +374,20 @@ export function parseGroupTypeConfigToml(tomlData) {
     }
     return result;
 }
+export function parseCollectionTypeConfigToml(tomlData) {
+    const section = tomlData.collectionTypeConfig || {};
+    const result = {
+        collectionType: section.collectionType,
+    };
+    // Support both new key-based reference and legacy ID-based reference
+    if (section.ruleSetName && section.ruleSetName !== "") {
+        result._ruleSetName = section.ruleSetName;
+    }
+    else if (section.ruleSetId && section.ruleSetId !== "") {
+        result.ruleSetId = section.ruleSetId;
+    }
+    return result;
+}
 // Parsing helpers
 function parseTomlFile(filePath) {
     const content = readFileSync(filePath, "utf-8");
@@ -770,6 +850,8 @@ Directory Structure:
     app.toml                        # App settings
     integrations/*.toml             # Integration configs
     webhooks/*.toml                 # Webhook configs
+    cron-triggers/*.toml             # Cron trigger configs
+    blob-buckets/*.toml             # Blob bucket configs
     prompts/*.toml                  # Prompt configs
     prompts/{key}.tests/*.toml      # Prompt test cases
     workflows/*.toml                # Workflow definitions
@@ -777,6 +859,7 @@ Directory Structure:
     database-types/*.toml           # Database type configs + operations
     rule-sets/*.toml                # Access rule sets
     group-type-configs/*.toml       # Group type configs
+    collection-type-configs/*.toml  # Collection type configs
     email-templates/*.toml          # Email template overrides
 `);
     // Init
@@ -792,11 +875,14 @@ Directory Structure:
         ensureDir(configDir);
         ensureDir(join(configDir, "integrations"));
         ensureDir(join(configDir, "webhooks"));
+        ensureDir(join(configDir, "cron-triggers"));
+        ensureDir(join(configDir, "blob-buckets"));
         ensureDir(join(configDir, "prompts"));
         ensureDir(join(configDir, "workflows"));
         ensureDir(join(configDir, "database-types"));
         ensureDir(join(configDir, "rule-sets"));
         ensureDir(join(configDir, "group-type-configs"));
+        ensureDir(join(configDir, "collection-type-configs"));
         ensureDir(join(configDir, "email-templates"));
         const state = {
             appId: resolvedAppId,
@@ -862,10 +948,11 @@ Directory Structure:
                 return;
             }
             // Fetch database config resources
-            const [databaseTypeConfigsResult, ruleSetsResult, groupTypeConfigsResult] = await Promise.all([
+            const [databaseTypeConfigsResult, ruleSetsResult, groupTypeConfigsResult, collectionTypeConfigsResult,] = await Promise.all([
                 client.listDatabaseTypeConfigs(resolvedAppId).catch(() => []),
                 client.listRuleSets(resolvedAppId).catch(() => []),
                 client.listGroupTypeConfigs(resolvedAppId).catch(() => []),
+                client.listCollectionTypeConfigs(resolvedAppId).catch(() => []),
             ]);
             // Fetch operations for each database type
             const databaseTypesWithOps = await Promise.all((Array.isArray(databaseTypeConfigsResult) ? databaseTypeConfigsResult : []).map(async (typeConfig) => {
@@ -876,11 +963,14 @@ Directory Structure:
             ensureDir(configDir);
             ensureDir(join(configDir, "integrations"));
             ensureDir(join(configDir, "webhooks"));
+            ensureDir(join(configDir, "cron-triggers"));
+            ensureDir(join(configDir, "blob-buckets"));
             ensureDir(join(configDir, "prompts"));
             ensureDir(join(configDir, "workflows"));
             ensureDir(join(configDir, "database-types"));
             ensureDir(join(configDir, "rule-sets"));
             ensureDir(join(configDir, "group-type-configs"));
+            ensureDir(join(configDir, "collection-type-configs"));
             ensureDir(join(configDir, "email-templates"));
             // Write app settings
             if (settings) {
@@ -918,6 +1008,46 @@ Directory Structure:
                 };
             }
             info(`  Pulled ${webhooks.length} webhook(s)`);
+            // Pull cron triggers
+            let cronTriggerItems = [];
+            try {
+                const cronResult = await client.listCronTriggers(resolvedAppId);
+                cronTriggerItems = cronResult.items || [];
+            }
+            catch {
+                // Cron triggers may not be available on older servers
+            }
+            const cronTriggersDir = join(configDir, "cron-triggers");
+            mkdirSync(cronTriggersDir, { recursive: true });
+            const cronTriggerEntities = {};
+            for (const trigger of cronTriggerItems) {
+                const filename = `${trigger.triggerKey}.toml`;
+                const filePath = join(cronTriggersDir, filename);
+                writeFileSync(filePath, serializeCronTrigger(trigger));
+                cronTriggerEntities[trigger.triggerKey] = {
+                    id: trigger.triggerId,
+                    modifiedAt: trigger.modifiedAt || new Date().toISOString(),
+                    contentHash: computeFileHash(filePath),
+                };
+            }
+            info(`  Pulled ${cronTriggerItems.length} cron trigger(s)`);
+            // Pull blob buckets
+            const blobBucketsResult = await client.listBlobBuckets(resolvedAppId).catch(() => ({ items: [] }));
+            const blobBucketItems = blobBucketsResult.items || [];
+            const blobBucketsDir = join(configDir, "blob-buckets");
+            mkdirSync(blobBucketsDir, { recursive: true });
+            const blobBucketEntities = {};
+            for (const bucket of blobBucketItems) {
+                const filename = `${bucket.bucketKey}.toml`;
+                const filePath = join(blobBucketsDir, filename);
+                writeFileSync(filePath, serializeBlobBucket(bucket));
+                blobBucketEntities[bucket.bucketKey] = {
+                    id: bucket.bucketId,
+                    modifiedAt: bucket.modifiedAt || new Date().toISOString(),
+                    contentHash: computeFileHash(filePath),
+                };
+            }
+            info(`  Pulled ${blobBucketItems.length} blob bucket(s)`);
             // Write prompts
             const promptEntities = {};
             for (const prompt of prompts) {
@@ -1059,6 +1189,21 @@ Directory Structure:
                 };
                 info(`  Wrote group-type-configs/${filename}`);
             }
+            // Write collection type configs
+            const collectionTypeConfigEntities = {};
+            const collectionTypeConfigs = Array.isArray(collectionTypeConfigsResult)
+                ? collectionTypeConfigsResult
+                : [];
+            for (const config of collectionTypeConfigs) {
+                const filename = `${config.collectionType}.toml`;
+                const filePath = join(configDir, "collection-type-configs", filename);
+                writeFileSync(filePath, serializeCollectionTypeConfig(config, ruleSetIdToName));
+                collectionTypeConfigEntities[config.collectionType] = {
+                    modifiedAt: config.modifiedAt || new Date().toISOString(),
+                    contentHash: computeFileHash(filePath),
+                };
+                info(`  Wrote collection-type-configs/${filename}`);
+            }
             // Save sync state
             const state = {
                 appId: resolvedAppId,
@@ -1068,6 +1213,8 @@ Directory Structure:
                     app: settings ? { modifiedAt: new Date().toISOString(), contentHash: computeFileHash(join(configDir, "app.toml")) } : undefined,
                     integrations: integrationEntities,
                     webhooks: webhookEntities,
+                    cronTriggers: Object.keys(cronTriggerEntities).length > 0 ? cronTriggerEntities : undefined,
+                    blobBuckets: Object.keys(blobBucketEntities).length > 0 ? blobBucketEntities : undefined,
                     prompts: promptEntities,
                     workflows: workflowEntities,
                     emailTemplates: Object.keys(emailTemplateEntities).length > 0 ? emailTemplateEntities : undefined,
@@ -1075,6 +1222,9 @@ Directory Structure:
                     databaseTypes: Object.keys(databaseTypeEntities).length > 0 ? databaseTypeEntities : undefined,
                     ruleSets: Object.keys(ruleSetEntities).length > 0 ? ruleSetEntities : undefined,
                     groupTypeConfigs: Object.keys(groupTypeConfigEntities).length > 0 ? groupTypeConfigEntities : undefined,
+                    collectionTypeConfigs: Object.keys(collectionTypeConfigEntities).length > 0
+                        ? collectionTypeConfigEntities
+                        : undefined,
                 },
             };
             saveSyncState(configDir, state);
@@ -1082,6 +1232,8 @@ Directory Structure:
             success(`Pulled configuration to ${configDir}`);
             keyValue("Integrations", integrations.length);
             keyValue("Webhooks", webhooks.length);
+            keyValue("Cron Triggers", cronTriggerItems.length);
+            keyValue("Blob Buckets", blobBucketItems.length);
             keyValue("Prompts", prompts.length);
             keyValue("Workflows", workflows.length);
             keyValue("Email Templates", emailTemplates.length);
@@ -1089,6 +1241,7 @@ Directory Structure:
             keyValue("Database Types", databaseTypesWithOps.length);
             keyValue("Rule Sets", ruleSets.length);
             keyValue("Group Type Configs", groupTypeConfigs.length);
+            keyValue("Collection Type Configs", collectionTypeConfigs.length);
         }
         catch (err) {
             error(err.message);
@@ -1425,6 +1578,152 @@ Directory Structure:
                     }
                 }
             }
+            // Process cron triggers
+            const cronTriggersDir = join(configDir, "cron-triggers");
+            if (existsSync(cronTriggersDir)) {
+                const files = readdirSync(cronTriggersDir).filter((f) => f.endsWith(".toml"));
+                for (const file of files) {
+                    const filePath = join(cronTriggersDir, file);
+                    const tomlData = parseTomlFile(filePath);
+                    const cronTrigger = tomlData.cronTrigger || {};
+                    const key = cronTrigger.key || basename(file, ".toml");
+                    const existingId = syncState?.entities?.cronTriggers?.[key]?.id;
+                    if (!options.force && existingId &&
+                        !shouldPushFile(filePath, syncState?.entities?.cronTriggers?.[key]?.contentHash)) {
+                        skippedCount++;
+                        continue;
+                    }
+                    const payload = {
+                        triggerKey: key,
+                        displayName: cronTrigger.displayName || key,
+                        description: cronTrigger.description,
+                        cron: cronTrigger.cron,
+                        timezone: cronTrigger.timezone,
+                        workflowKey: cronTrigger.workflowKey,
+                        overlapPolicy: cronTrigger.overlapPolicy,
+                        state: cronTrigger.state,
+                    };
+                    // Handle JSON fields
+                    if (tomlData.rootInput) {
+                        payload.rootInput = JSON.stringify(tomlData.rootInput);
+                    }
+                    if (tomlData.inputMapping) {
+                        payload.inputMapping = JSON.stringify(tomlData.inputMapping);
+                    }
+                    if (existingId) {
+                        changes.push({ type: "cron-trigger", action: "update", key });
+                        if (!options.dryRun) {
+                            try {
+                                const updated = await client.updateCronTrigger(resolvedAppId, existingId, payload);
+                                info(`  Updated cron trigger: ${key}`);
+                                if (syncState?.entities?.cronTriggers?.[key] && updated?.modifiedAt) {
+                                    syncState.entities.cronTriggers[key].modifiedAt = updated.modifiedAt;
+                                    syncState.entities.cronTriggers[key].contentHash = computeFileHash(filePath);
+                                }
+                            }
+                            catch (err) {
+                                throw err;
+                            }
+                        }
+                    }
+                    else {
+                        changes.push({ type: "cron-trigger", action: "create", key });
+                        if (!options.dryRun) {
+                            const created = await client.createCronTrigger(resolvedAppId, payload);
+                            info(`  Created cron trigger: ${key}`);
+                            if (syncState && created?.triggerId && created?.modifiedAt) {
+                                if (!syncState.entities.cronTriggers) {
+                                    syncState.entities.cronTriggers = {};
+                                }
+                                syncState.entities.cronTriggers[key] = {
+                                    id: created.triggerId,
+                                    modifiedAt: created.modifiedAt,
+                                    contentHash: computeFileHash(filePath),
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+            // Process blob buckets
+            const blobBucketsPushDir = join(configDir, "blob-buckets");
+            if (existsSync(blobBucketsPushDir)) {
+                const files = readdirSync(blobBucketsPushDir).filter((f) => f.endsWith(".toml"));
+                for (const file of files) {
+                    const filePath = join(blobBucketsPushDir, file);
+                    const tomlData = parseTomlFile(filePath);
+                    const bucket = tomlData.bucket || {};
+                    const key = bucket.key || basename(file, ".toml");
+                    const existingId = syncState?.entities?.blobBuckets?.[key]?.id;
+                    if (!options.force && existingId &&
+                        !shouldPushFile(filePath, syncState?.entities?.blobBuckets?.[key]?.contentHash)) {
+                        skippedCount++;
+                        continue;
+                    }
+                    if (existingId) {
+                        // Blob buckets don't have an update API - skip if already exists
+                        info(`  Blob bucket already exists, skipping: ${key}`);
+                        if (syncState?.entities?.blobBuckets?.[key]) {
+                            syncState.entities.blobBuckets[key].contentHash = computeFileHash(filePath);
+                        }
+                    }
+                    else {
+                        const payload = {
+                            bucketKey: key,
+                            name: bucket.name || key,
+                            ttlTier: bucket.ttlTier,
+                            accessPolicy: bucket.accessPolicy,
+                        };
+                        if (bucket.description)
+                            payload.description = bucket.description;
+                        if (bucket.ruleSetId)
+                            payload.ruleSetId = bucket.ruleSetId;
+                        changes.push({ type: "blob-bucket", action: "create", key });
+                        if (!options.dryRun) {
+                            try {
+                                const created = await client.createBlobBucket(resolvedAppId, payload);
+                                info(`  Created blob bucket: ${key}`);
+                                if (syncState) {
+                                    if (!syncState.entities.blobBuckets) {
+                                        syncState.entities.blobBuckets = {};
+                                    }
+                                    syncState.entities.blobBuckets[key] = {
+                                        id: created.bucketId,
+                                        modifiedAt: created.modifiedAt || new Date().toISOString(),
+                                        contentHash: computeFileHash(filePath),
+                                    };
+                                }
+                            }
+                            catch (err) {
+                                const msg = String(err?.message || err);
+                                if (msg.includes("already exists") || err.statusCode === 409) {
+                                    info(`  Blob bucket already exists on server: ${key}`);
+                                    // Fetch the existing bucket to get its ID
+                                    try {
+                                        const existing = await client.getBlobBucket(resolvedAppId, key);
+                                        if (syncState && existing?.bucketId) {
+                                            if (!syncState.entities.blobBuckets) {
+                                                syncState.entities.blobBuckets = {};
+                                            }
+                                            syncState.entities.blobBuckets[key] = {
+                                                id: existing.bucketId,
+                                                modifiedAt: existing.modifiedAt || new Date().toISOString(),
+                                                contentHash: computeFileHash(filePath),
+                                            };
+                                        }
+                                    }
+                                    catch {
+                                        // Ignore fetch errors
+                                    }
+                                }
+                                else {
+                                    throw err;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
             // Process prompts
             const promptsDir = join(configDir, "prompts");
             if (existsSync(promptsDir)) {
@@ -1932,12 +2231,6 @@ Directory Structure:
                             }
                         }
                     }
-                    // Refresh the cached content hash so an unchanged file isn't re-pushed
-                    // next run. This matters when only operations changed (the type-level
-                    // PATCH was skipped) or when nothing type-level needed updating at all.
-                    if (!options.dryRun && syncState?.entities?.databaseTypes?.[dbType]) {
-                        syncState.entities.databaseTypes[dbType].contentHash = computeFileHash(filePath);
-                    }
                 }
             }
             // Process group type configs
@@ -2013,6 +2306,77 @@ Directory Structure:
                     }
                 }
             }
+            // Process collection type configs
+            const collectionTypeConfigsDir = join(configDir, "collection-type-configs");
+            if (existsSync(collectionTypeConfigsDir)) {
+                const files = readdirSync(collectionTypeConfigsDir).filter((f) => f.endsWith(".toml"));
+                for (const file of files) {
+                    const filePath = join(collectionTypeConfigsDir, file);
+                    const tomlData = parseTomlFile(filePath);
+                    const configData = parseCollectionTypeConfigToml(tomlData);
+                    const collectionType = configData.collectionType || basename(file, ".toml");
+                    // Resolve ruleSetName → ruleSetId if using key-based reference
+                    resolveRuleSetReference(configData, ruleSetNameToId, `collection type ${collectionType}`);
+                    const existingEntry = syncState?.entities?.collectionTypeConfigs?.[collectionType];
+                    // Skip if file hasn't changed since last sync
+                    if (!options.force && existingEntry && !shouldPushFile(filePath, existingEntry.contentHash)) {
+                        skippedCount++;
+                        continue;
+                    }
+                    if (existingEntry) {
+                        // Update existing collection type config
+                        changes.push({ type: "collection-type-config", action: "update", key: collectionType });
+                        if (!options.dryRun) {
+                            const expectedModifiedAt = options.force
+                                ? undefined
+                                : existingEntry.modifiedAt;
+                            try {
+                                const updated = await client.updateCollectionTypeConfig(resolvedAppId, collectionType, {
+                                    ruleSetId: configData.ruleSetId ?? null,
+                                }, expectedModifiedAt);
+                                info(`  Updated collection type config: ${collectionType}`);
+                                if (syncState?.entities?.collectionTypeConfigs?.[collectionType] && updated?.modifiedAt) {
+                                    syncState.entities.collectionTypeConfigs[collectionType].modifiedAt = updated.modifiedAt;
+                                    syncState.entities.collectionTypeConfigs[collectionType].contentHash = computeFileHash(filePath);
+                                }
+                            }
+                            catch (err) {
+                                if (err instanceof ConflictError) {
+                                    conflicts.push({
+                                        type: "collection-type-config",
+                                        key: collectionType,
+                                        serverModifiedAt: err.serverModifiedAt,
+                                        localModifiedAt: expectedModifiedAt || "unknown",
+                                    });
+                                }
+                                else {
+                                    throw err;
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        // Create new collection type config
+                        changes.push({ type: "collection-type-config", action: "create", key: collectionType });
+                        if (!options.dryRun) {
+                            const created = await client.createCollectionTypeConfig(resolvedAppId, {
+                                collectionType,
+                                ruleSetId: configData.ruleSetId || undefined,
+                            });
+                            info(`  Created collection type config: ${collectionType}`);
+                            if (syncState) {
+                                if (!syncState.entities.collectionTypeConfigs) {
+                                    syncState.entities.collectionTypeConfigs = {};
+                                }
+                                syncState.entities.collectionTypeConfigs[collectionType] = {
+                                    modifiedAt: created?.modifiedAt || new Date().toISOString(),
+                                    contentHash: computeFileHash(filePath),
+                                };
+                            }
+                        }
+                    }
+                }
+            }
             // Process email templates
             const emailTemplatesDir = join(configDir, "email-templates");
             if (existsSync(emailTemplatesDir)) {
@@ -2171,8 +2535,19 @@ Directory Structure:
                 client.listEmailTemplates(resolvedAppId).catch(() => ({ templates: [] })),
             ]);
             const webhookItems = await fetchAll((p) => client.listWebhooks(resolvedAppId, p));
+            let cronTriggerItemsDiff = [];
+            try {
+                const cronResult = await client.listCronTriggers(resolvedAppId);
+                cronTriggerItemsDiff = cronResult.items || [];
+            }
+            catch {
+                // Cron triggers may not be available on older servers
+            }
+            const blobBucketsDiffResult = await client.listBlobBuckets(resolvedAppId).catch(() => ({ items: [] }));
             const remoteIntegrations = new Set(integrationItems.map((i) => i.integrationKey));
             const remoteWebhooks = new Set(webhookItems.map((w) => w.webhookKey));
+            const remoteCronTriggers = new Set(cronTriggerItemsDiff.map((t) => t.triggerKey));
+            const remoteBlobBuckets = new Set((blobBucketsDiffResult.items || []).map((b) => b.bucketKey));
             const remotePrompts = new Set(promptItems.map((p) => p.promptKey));
             const remoteWorkflows = new Set(workflowItems.map((w) => w.workflowKey));
             const remoteEmailTemplates = new Set((emailTemplatesResult.templates || [])
@@ -2181,6 +2556,8 @@ Directory Structure:
             // Get local files
             const localIntegrations = new Set();
             const localWebhooks = new Set();
+            const localCronTriggers = new Set();
+            const localBlobBuckets = new Set();
             const localPrompts = new Set();
             const localWorkflows = new Set();
             const localEmailTemplates = new Set();
@@ -2200,6 +2577,22 @@ Directory Structure:
                     localWebhooks.add(key);
                 }
             }
+            const cronTriggersDirPath = join(configDir, "cron-triggers");
+            if (existsSync(cronTriggersDirPath)) {
+                for (const file of readdirSync(cronTriggersDirPath).filter((f) => f.endsWith(".toml"))) {
+                    const tomlData = parseTomlFile(join(cronTriggersDirPath, file));
+                    const key = tomlData.cronTrigger?.key || basename(file, ".toml");
+                    localCronTriggers.add(key);
+                }
+            }
+            const blobBucketsDiffDir = join(configDir, "blob-buckets");
+            if (existsSync(blobBucketsDiffDir)) {
+                for (const file of readdirSync(blobBucketsDiffDir).filter((f) => f.endsWith(".toml"))) {
+                    const tomlData = parseTomlFile(join(blobBucketsDiffDir, file));
+                    const key = tomlData.bucket?.key || basename(file, ".toml");
+                    localBlobBuckets.add(key);
+                }
+            }
             const promptsDir = join(configDir, "prompts");
             if (existsSync(promptsDir)) {
                 for (const file of readdirSync(promptsDir).filter((f) => f.endsWith(".toml"))) {
@@ -2254,6 +2647,34 @@ Directory Structure:
                     differences.push({ type: "webhook", key, status: "remote only" });
                 }
             }
+            // Cron Triggers
+            for (const key of localCronTriggers) {
+                if (!remoteCronTriggers.has(key)) {
+                    differences.push({ type: "cron-trigger", key, status: "local only" });
+                }
+                else {
+                    differences.push({ type: "cron-trigger", key, status: "exists" });
+                }
+            }
+            for (const key of remoteCronTriggers) {
+                if (!localCronTriggers.has(key)) {
+                    differences.push({ type: "cron-trigger", key, status: "remote only" });
+                }
+            }
+            // Blob Buckets
+            for (const key of localBlobBuckets) {
+                if (!remoteBlobBuckets.has(key)) {
+                    differences.push({ type: "blob-bucket", key, status: "local only" });
+                }
+                else {
+                    differences.push({ type: "blob-bucket", key, status: "exists" });
+                }
+            }
+            for (const key of remoteBlobBuckets) {
+                if (!localBlobBuckets.has(key)) {
+                    differences.push({ type: "blob-bucket", key, status: "remote only" });
+                }
+            }
             // Prompts
             for (const key of localPrompts) {
                 if (!remotePrompts.has(key)) {