primitive-admin 1.0.40 → 1.0.41

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: {
@@ -770,6 +826,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
@@ -792,6 +850,8 @@ 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"));
@@ -876,6 +936,8 @@ 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"));
@@ -918,6 +980,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) {
@@ -1068,6 +1170,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,
@@ -1082,6 +1186,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);
@@ -1425,6 +1531,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 +2184,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
@@ -2171,8 +2417,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 +2438,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 +2459,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 +2529,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)) {