@mevdragon/vidfarm-devcli 0.20.5 → 0.20.8

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

@@ -1,14 +0,0 @@
-export class ActiveJobLimitExceededError extends Error {
-    limit;
-    activeCount;
-    pendingStatuses;
-    retryAfterSeconds;
-    constructor(message, limit, activeCount, pendingStatuses, retryAfterSeconds) {
-        super(message);
-        this.limit = limit;
-        this.activeCount = activeCount;
-        this.pendingStatuses = pendingStatuses;
-        this.retryAfterSeconds = retryAfterSeconds;
-    }
-}
-//# sourceMappingURL=job-capacity.js.map

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

@@ -1,197 +0,0 @@
-import { StorageService } from "./storage.js";
-const JOB_LOG_PREFIX = "job-logs";
-const JOB_LOG_CHUNK_INTERVAL_MS = 60_000;
-const JOB_LOG_CHUNK_MAX_BYTES = 1024 * 1024;
-const JOB_LOG_FLUSH_INTERVAL_MS = 5_000;
-export class JobLogStore {
-    storage = new StorageService();
-    activeChunks = new Map();
-    flushTimer = setInterval(() => {
-        void this.flushExpiredChunks();
-    }, JOB_LOG_FLUSH_INTERVAL_MS);
-    constructor() {
-        this.flushTimer.unref();
-    }
-    addEvent(event) {
-        const normalized = {
-            ...event,
-            createdAt: event.createdAt ?? new Date().toISOString()
-        };
-        const minuteStartMs = floorToMinute(Date.parse(normalized.createdAt));
-        const activePrefix = this.activeChunkPrefix(normalized.jobId, minuteStartMs);
-        const current = this.findLatestChunk(activePrefix);
-        const eventBytes = serializedEventSize(normalized);
-        const chunk = current && current.sizeBytes + eventBytes <= JOB_LOG_CHUNK_MAX_BYTES
-            ? current
-            : this.createChunk(normalized.jobId, minuteStartMs, current ? current.sequence + 1 : 0);
-        chunk.events.push(normalized);
-        chunk.sizeBytes += eventBytes;
-        chunk.dirty = true;
-        if (chunk.sizeBytes >= JOB_LOG_CHUNK_MAX_BYTES) {
-            void this.persistChunk(chunk, true);
-        }
-    }
-    async listEvents(input) {
-        const persisted = await this.readPersistedEvents(input);
-        const buffered = this.readBufferedEvents(input);
-        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 listStorageKeys(input) {
-        return this.listRelevantKeys(input);
-    }
-    async shutdown() {
-        clearInterval(this.flushTimer);
-        await Promise.all([...this.activeChunks.values()].map((chunk) => this.persistChunk(chunk, true)));
-    }
-    async readPersistedEvents(input) {
-        const keys = await this.listRelevantKeys(input);
-        const events = await Promise.all(keys.map(async (key) => parseChunk(await this.storage.readText(key))));
-        return events
-            .flat()
-            .filter((event) => event.jobId === input.jobId)
-            .filter((event) => withinRange(event.createdAt, input.startTime, input.endTime));
-    }
-    readBufferedEvents(input) {
-        const buffered = [];
-        for (const chunk of this.activeChunks.values()) {
-            if (chunk.jobId !== input.jobId) {
-                continue;
-            }
-            for (const event of chunk.events.slice(chunk.lastPersistedEventCount)) {
-                if (withinRange(event.createdAt, input.startTime, input.endTime)) {
-                    buffered.push(event);
-                }
-            }
-        }
-        return buffered;
-    }
-    async listRelevantKeys(input) {
-        const minuteStarts = this.minuteStartsForQuery(input.startTime, input.endTime);
-        if (minuteStarts === null) {
-            return this.storage.listKeys(`${JOB_LOG_PREFIX}/job_id=${input.jobId}/`);
-        }
-        const nested = await Promise.all(minuteStarts.map((minuteStartMs) => (this.storage.listKeys(this.minutePrefix(input.jobId, minuteStartMs)))));
-        return nested.flat();
-    }
-    minuteStartsForQuery(startTime, endTime) {
-        if (!startTime && !endTime) {
-            return null;
-        }
-        const startMs = floorToMinute(Date.parse(startTime ?? endTime ?? new Date().toISOString()));
-        const endMs = floorToMinute(Date.parse(endTime ?? startTime ?? new Date().toISOString()));
-        const minMs = Math.min(startMs, endMs);
-        const maxMs = Math.max(startMs, endMs);
-        const minuteStarts = [];
-        for (let cursor = minMs; cursor <= maxMs; cursor += 60_000) {
-            minuteStarts.push(cursor);
-        }
-        return minuteStarts;
-    }
-    async flushExpiredChunks() {
-        const now = Date.now();
-        await Promise.all([...this.activeChunks.values()].map(async (chunk) => {
-            const intervalElapsed = now >= chunk.minuteStartMs + JOB_LOG_CHUNK_INTERVAL_MS;
-            if (intervalElapsed || chunk.sizeBytes >= JOB_LOG_CHUNK_MAX_BYTES) {
-                await this.persistChunk(chunk, true);
-                return;
-            }
-            if (chunk.dirty) {
-                await this.persistChunk(chunk, false);
-            }
-        }));
-    }
-    createChunk(jobId, minuteStartMs, sequence) {
-        const chunk = {
-            jobId,
-            minuteStartMs,
-            sequence,
-            events: [],
-            sizeBytes: 0,
-            lastPersistedEventCount: 0,
-            dirty: false
-        };
-        this.activeChunks.set(this.chunkKeyForMap(jobId, minuteStartMs, sequence), chunk);
-        return chunk;
-    }
-    findLatestChunk(activePrefix) {
-        const matching = [...this.activeChunks.entries()]
-            .filter(([key]) => key.startsWith(activePrefix))
-            .map(([, chunk]) => chunk)
-            .sort((a, b) => a.sequence - b.sequence);
-        return matching.at(-1) ?? null;
-    }
-    activeChunkPrefix(jobId, minuteStartMs) {
-        return `${jobId}:${minuteStartMs}:`;
-    }
-    chunkKeyForMap(jobId, minuteStartMs, sequence) {
-        return `${this.activeChunkPrefix(jobId, minuteStartMs)}${sequence}`;
-    }
-    async persistChunk(chunk, finalize) {
-        if (!chunk.events.length) {
-            if (finalize) {
-                this.activeChunks.delete(this.chunkKeyForMap(chunk.jobId, chunk.minuteStartMs, chunk.sequence));
-            }
-            return;
-        }
-        const key = this.objectKeyForChunk(chunk);
-        const body = `${chunk.events.map((event) => JSON.stringify(event)).join("\n")}\n`;
-        await this.storage.putText(key, body, "application/x-ndjson; charset=utf-8");
-        chunk.lastPersistedEventCount = chunk.events.length;
-        chunk.dirty = false;
-        if (finalize) {
-            this.activeChunks.delete(this.chunkKeyForMap(chunk.jobId, chunk.minuteStartMs, chunk.sequence));
-        }
-    }
-    objectKeyForChunk(chunk) {
-        const startTs = Math.floor(chunk.events[0] ? Date.parse(chunk.events[0].createdAt) / 1000 : chunk.minuteStartMs / 1000);
-        const endTs = Math.floor(chunk.events.at(-1) ? Date.parse(chunk.events.at(-1).createdAt) / 1000 : chunk.minuteStartMs / 1000);
-        return `${this.minutePrefix(chunk.jobId, chunk.minuteStartMs)}chunk-${startTs}-${endTs}-${String(chunk.sequence).padStart(4, "0")}.ndjson`;
-    }
-    minutePrefix(jobId, minuteStartMs) {
-        return `${JOB_LOG_PREFIX}/job_id=${jobId}/minute=${Math.floor(minuteStartMs / 1000)}/`;
-    }
-}
-export const jobLogStore = new JobLogStore();
-function serializedEventSize(event) {
-    return Buffer.byteLength(`${JSON.stringify(event)}\n`, "utf8");
-}
-function floorToMinute(timestampMs) {
-    return Math.floor(timestampMs / 60_000) * 60_000;
-}
-function parseChunk(content) {
-    if (!content) {
-        return [];
-    }
-    return content
-        .split("\n")
-        .map((line) => line.trim())
-        .filter(Boolean)
-        .map((line) => JSON.parse(line));
-}
-function dedupeAndSort(events) {
-    const deduped = new Map();
-    for (const event of events) {
-        deduped.set(event.id, event);
-    }
-    return [...deduped.values()].sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt));
-}
-function withinRange(createdAt, startTime, endTime) {
-    const value = Date.parse(createdAt);
-    if (startTime && value < Date.parse(startTime)) {
-        return false;
-    }
-    if (endTime && value > Date.parse(endTime)) {
-        return false;
-    }
-    return true;
-}
-//# sourceMappingURL=job-logs.js.map

package/dist/src/services/jobs.js

@@ -1,136 +0,0 @@
-import * as Sentry from "@sentry/node";
-import { addSeconds, nowIso } from "../lib/time.js";
-export { ActiveJobLimitExceededError } from "./job-capacity.js";
-import { ServerlessJobsService } from "./serverless-jobs.js";
-export class JobsService {
-    serverless = new ServerlessJobsService();
-    async createRootJob(input) {
-        return this.serverless.createRootJob(input);
-    }
-    getRootQueueCapacityStatus(customer) {
-        return this.serverless.getRootQueueCapacityStatus(customer);
-    }
-    sweepStaleActiveJobs(input = {}) {
-        return this.serverless.sweepStaleActiveJobs(input);
-    }
-    async enqueueChildJob(input) {
-        return this.serverless.createChildJob(input);
-    }
-    getJob(jobId) {
-        void jobId;
-        throw new Error(`Synchronous job lookup is unavailable in the DynamoDB runtime. Use getJobAsync(${jobId}).`);
-    }
-    async getJobAsync(jobId) {
-        return this.serverless.getJob(jobId);
-    }
-    listJobs(input) {
-        void input;
-        throw new Error("Synchronous job listing is unavailable in the DynamoDB runtime. Use listJobsAsync().");
-    }
-    async listJobsAsync(input) {
-        return this.serverless.listJobs(input);
-    }
-    renameTracer(input) {
-        void input;
-        throw new Error("Renaming job tracers is not implemented in the serverless DynamoDB runtime.");
-    }
-    async listChildJobs(parentJobId) {
-        return this.serverless.listChildJobs(parentJobId);
-    }
-    async insertArtifact(record) {
-        await this.serverless.insertArtifact(record);
-    }
-    async listArtifactsForJob(input) {
-        return this.serverless.listArtifactsForJob(input);
-    }
-    async listLogs(input) {
-        return this.serverless.listLogs(input);
-    }
-    async addLogEvent(event) {
-        return this.serverless.addLogEvent(event);
-    }
-    async listLogStorageKeys(input) {
-        void input;
-        return this.serverless.listLogStorageKeys();
-    }
-    async updateJobStatus(input) {
-        await this.serverless.updateJobStatus(input);
-    }
-    cancelJob(jobId) {
-        return this.serverless.cancelJob(jobId);
-    }
-    async cancelJobAsync(jobId) {
-        await this.serverless.cancelJob(jobId);
-    }
-    markRunning(jobId) {
-        return this.serverless.updateJobStatus({ id: jobId, status: "running" });
-    }
-    failExpiredActiveJobs(input) {
-        void input;
-        throw new Error("Expiring active jobs is handled by the serverless workflow runtime.");
-    }
-    claimRunnableJob(jobId) {
-        void jobId;
-        throw new Error("Runnable job claiming is unavailable in the serverless workflow runtime.");
-    }
-    succeedJob(jobId, result, progress = 1) {
-        return this.serverless.updateJobStatus({
-            id: jobId,
-            status: "succeeded",
-            progress,
-            result,
-            error: null,
-            completedAt: nowIso()
-        });
-    }
-    failJob(jobId, error, options) {
-        void options;
-        return this.serverless.updateJobStatus({
-            id: jobId,
-            status: "failed",
-            error,
-            completedAt: nowIso()
-        });
-    }
-    requeueJob(job, delaySeconds = 30, error, options) {
-        void options;
-        return this.serverless.updateJobStatus({
-            id: job.id,
-            status: job.attemptCount >= job.maxAttempts ? "failed" : "queued",
-            error: job.attemptCount >= job.maxAttempts ? error : null,
-            runAfter: addSeconds(new Date(), delaySeconds),
-            completedAt: job.attemptCount >= job.maxAttempts ? nowIso() : null
-        });
-    }
-    captureJobFailure(job, error, options) {
-        const message = typeof error.message === "string" ? error.message : "Job failed";
-        const type = typeof error.type === "string" ? error.type : "job_failed";
-        const baseContext = {
-            job_id: job.id,
-            customer_id: job.customerId,
-            template_id: job.templateId,
-            operation_name: job.operationName,
-            workflow_name: job.workflowName,
-            tracer: job.tracer,
-            attempt_count: job.attemptCount,
-            max_attempts: job.maxAttempts,
-            provider_hint: typeof job.payload?._providerHint === "string" ? job.payload._providerHint : null,
-            error
-        };
-        Sentry.withScope((scope) => {
-            scope.setLevel("error");
-            scope.setTag("surface", "worker");
-            scope.setTag("job.failure_type", type);
-            scope.setTag("job.id", job.id);
-            scope.setTag("job.template_id", job.templateId);
-            scope.setTag("job.operation_name", job.operationName);
-            scope.setContext("job", baseContext);
-            if (options?.cause instanceof Error) {
-                Sentry.captureException(options.cause);
-                return;
-            }
-            Sentry.captureMessage(message, "error");
-        });
-    }
-}
-//# sourceMappingURL=jobs.js.map