@mevdragon/vidfarm-devcli 0.2.8 → 0.2.9

package/dist/src/services/chat-threads.js

@@ -0,0 +1,88 @@
+import { createId } from "../lib/ids.js";
+import { nowIso } from "../lib/time.js";
+import { database } from "../db.js";
+import { StorageService } from "./storage.js";
+const storage = new StorageService();
+function normalizeTracerList(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function buildThreadStoragePrefix(customerId, templateId, threadId) {
+    return storage.developerScopedKey(customerId, "chat-threads", templateId, threadId);
+}
+function buildThreadChunkKey(prefix, createdAt) {
+    const sortableTime = createdAt.replace(/[^0-9]/g, "");
+    return `${prefix}/chunks/${sortableTime}-${createId("chunk")}.json`;
+}
+async function readChunkMessages(key) {
+    const raw = await storage.readText(key);
+    if (!raw) {
+        return [];
+    }
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed.messages) ? parsed.messages : [];
+}
+export const chatThreads = {
+    async listThreads(input) {
+        const threads = database.listChatThreadMetas(input);
+        const withMessages = await Promise.all(threads.map(async (thread) => ({
+            ...thread,
+            messages: await this.loadThreadMessages(thread)
+        })));
+        return withMessages;
+    },
+    async getThread(input) {
+        const thread = database.getChatThreadMeta(input.customerId, input.threadId);
+        if (!thread) {
+            return null;
+        }
+        return {
+            ...thread,
+            messages: await this.loadThreadMessages(thread)
+        };
+    },
+    async appendExchange(input) {
+        const createdAt = nowIso();
+        const storagePrefix = buildThreadStoragePrefix(input.customerId, input.templateId, input.threadId);
+        const chunk = {
+            version: 1,
+            threadId: input.threadId,
+            customerId: input.customerId,
+            templateId: input.templateId,
+            createdAt,
+            messages: input.messages
+        };
+        await storage.putJson(buildThreadChunkKey(storagePrefix, createdAt), chunk);
+        const updated = database.appendChatThreadMessages({
+            threadId: input.threadId,
+            customerId: input.customerId,
+            title: input.title || "New chat",
+            templateId: input.templateId,
+            storagePrefix,
+            tracers: normalizeTracerList(input.tracers),
+            messageCountDelta: input.messages.length,
+            lastMessageAt: createdAt
+        });
+        return updated ? this.getThread({ customerId: input.customerId, threadId: updated.id }) : null;
+    },
+    async updateThread(input) {
+        const updated = database.updateChatThreadState({
+            ...input,
+            tracers: input.tracers ? normalizeTracerList(input.tracers) : undefined
+        });
+        return updated ? this.getThread({ customerId: input.customerId, threadId: updated.id }) : null;
+    },
+    async deleteThread(input) {
+        const existing = database.deleteChatThread(input.customerId, input.threadId);
+        if (!existing) {
+            return null;
+        }
+        const keys = await storage.listKeys(`${existing.storagePrefix}/`);
+        await Promise.all(keys.map((key) => storage.deleteObject(key)));
+        return existing;
+    },
+    async loadThreadMessages(thread) {
+        const keys = (await storage.listKeys(`${thread.storagePrefix}/chunks/`)).sort();
+        const messageGroups = await Promise.all(keys.map((key) => readChunkMessages(key)));
+        return messageGroups.flat();
+    }
+};

package/dist/src/services/job-logs.js

@@ -1,8 +1,8 @@
 import { StorageService } from "./storage.js";
 const JOB_LOG_PREFIX = "job-logs";
-const JOB_LOG_CHUNK_INTERVAL_MS = 60000;
+const JOB_LOG_CHUNK_INTERVAL_MS = 60_000;
 const JOB_LOG_CHUNK_MAX_BYTES = 1024 * 1024;
-const JOB_LOG_FLUSH_INTERVAL_MS = 5000;
+const JOB_LOG_FLUSH_INTERVAL_MS = 5_000;
 export class JobLogStore {
     storage = new StorageService();
     activeChunks = new Map();
@@ -32,11 +32,18 @@ export class JobLogStore {
         }
     }
     async listEvents(input) {
-        const limit = Math.max(1, Math.min(input.limit ?? 100, 500));
         const persisted = await this.readPersistedEvents(input);
         const buffered = this.readBufferedEvents(input);
-        const merged = dedupeAndSort([...persisted, ...buffered]);
-        return merged.slice(-limit);
+        const merged = dedupeAndSort([...persisted, ...buffered]).reverse();
+        const filtered = input.cursor
+            ? merged.filter((event) => (Date.parse(event.createdAt) < Date.parse(input.cursor.createdAt)
+                || (event.createdAt === input.cursor.createdAt && event.id < input.cursor.id)))
+            : merged;
+        if (input.limit === undefined) {
+            return filtered;
+        }
+        const limit = Math.max(1, Math.min(input.limit, 501));
+        return filtered.slice(0, limit);
     }
     async shutdown() {
         clearInterval(this.flushTimer);
@@ -81,7 +88,7 @@ export class JobLogStore {
         const minMs = Math.min(startMs, endMs);
         const maxMs = Math.max(startMs, endMs);
         const minuteStarts = [];
-        for (let cursor = minMs; cursor <= maxMs; cursor += 60000) {
+        for (let cursor = minMs; cursor <= maxMs; cursor += 60_000) {
             minuteStarts.push(cursor);
         }
         return minuteStarts;
@@ -155,7 +162,7 @@ function serializedEventSize(event) {
     return Buffer.byteLength(`${JSON.stringify(event)}\n`, "utf8");
 }
 function floorToMinute(timestampMs) {
-    return Math.floor(timestampMs / 60000) * 60000;
+    return Math.floor(timestampMs / 60_000) * 60_000;
 }
 function parseChunk(content) {
     if (!content) {

package/dist/src/services/jobs.js

@@ -4,6 +4,13 @@ import { createId } from "../lib/ids.js";
 import { addSeconds, nowIso } from "../lib/time.js";
 import { jobLogStore } from "./job-logs.js";
 const PENDING_JOB_STATUSES = ["queued", "running", "waiting_for_child", "waiting_for_human"];
+function normalizeWebhookUrl(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+}
 export class JobsService {
     assertQueueCapacity(customerId) {
         if (config.MAX_PENDING_JOBS_GLOBAL <= 0 && config.MAX_PENDING_JOBS_PER_CUSTOMER <= 0) {
@@ -36,7 +43,7 @@ export class JobsService {
                 _providerHint: input.providerHint ?? null
             },
             progress: 0,
-            webhookUrl: input.webhookUrl ?? input.customer.defaultWebhookUrl ?? null,
+            webhookUrl: normalizeWebhookUrl(input.webhookUrl) ?? normalizeWebhookUrl(input.customer.defaultWebhookUrl),
             parentJobId: null,
             priority: 100,
             attemptCount: 0,
@@ -73,6 +80,9 @@ export class JobsService {
     listJobs(input) {
         return database.listJobsForCustomer(input);
     }
+    renameTracer(input) {
+        return database.renameJobsTracer(input);
+    }
     async listLogs(input) {
         return jobLogStore.listEvents(input);
     }
@@ -93,6 +103,7 @@ export class JobsService {
             status: "succeeded",
             progress,
             result,
+            error: null,
             completedAt: nowIso()
         });
     }
@@ -109,7 +120,7 @@ export class JobsService {
         database.updateJobStatus({
             id: job.id,
             status: nextStatus,
-            error,
+            error: nextStatus === "failed" ? error : null,
             runAfter: addSeconds(new Date(), delaySeconds),
             completedAt: nextStatus === "failed" ? nowIso() : null
         });