@mevdragon/vidfarm-devcli 0.2.1 → 0.2.3

package/dist/src/context.js

@@ -1,16 +1,23 @@
 import { config } from "./config.js";
 import { database } from "./db.js";
 import { createId } from "./lib/ids.js";
+import { jobLogStore } from "./services/job-logs.js";
 export function createTemplateJobContext(input) {
     const templateConfig = database.getTemplateConfig(input.customer.id, input.template.id);
     const prefix = input.storage.templateJobPrefix(input.template.id, input.customer.id, input.job.id);
+    const buildArtifactUrl = (storageKey, fallbackUrl) => {
+        if (config.STORAGE_DRIVER !== "s3") {
+            return fallbackUrl;
+        }
+        return `${config.PUBLIC_BASE_URL}/template-media?key=${encodeURIComponent(storageKey)}`;
+    };
     return {
         env: config.isProduction ? "production" : "development",
         customer: input.customer,
         templateConfig,
         logger: {
             debug(message, metadata = {}) {
-                database.addJobEvent({
+                jobLogStore.addEvent({
                     id: createId("evt"),
                     jobId: input.job.id,
                     level: "debug",
@@ -21,7 +28,7 @@ export function createTemplateJobContext(input) {
                 });
             },
             info(message, metadata = {}) {
-                database.addJobEvent({
+                jobLogStore.addEvent({
                     id: createId("evt"),
                     jobId: input.job.id,
                     level: "info",
@@ -32,7 +39,7 @@ export function createTemplateJobContext(input) {
                 });
             },
             warn(message, metadata = {}) {
-                database.addJobEvent({
+                jobLogStore.addEvent({
                     id: createId("evt"),
                     jobId: input.job.id,
                     level: "warn",
@@ -43,7 +50,7 @@ export function createTemplateJobContext(input) {
                 });
             },
             error(message, metadata = {}) {
-                database.addJobEvent({
+                jobLogStore.addEvent({
                     id: createId("evt"),
                     jobId: input.job.id,
                     level: "error",
@@ -54,7 +61,7 @@ export function createTemplateJobContext(input) {
                 });
             },
             progress(progress, message, metadata = {}) {
-                database.addJobEvent({
+                jobLogStore.addEvent({
                     id: createId("evt"),
                     jobId: input.job.id,
                     level: "info",
@@ -88,7 +95,8 @@ export function createTemplateJobContext(input) {
         storage: {
             async putJson(key, value) {
                 const stored = await input.storage.putJson(`${prefix}/${key}`, value);
-                insertArtifact("json", stored.key, stored.url, {});
+                const artifactUrl = buildArtifactUrl(stored.key, stored.url);
+                insertArtifact("json", stored.key, artifactUrl, {});
                 await input.billing.record({
                     customerId: input.customer.id,
                     jobId: input.job.id,
@@ -98,11 +106,15 @@ export function createTemplateJobContext(input) {
                     chargeUsd: 0.01,
                     metadata: { key: stored.key }
                 });
-                return stored;
+                return {
+                    ...stored,
+                    url: artifactUrl
+                };
             },
             async putText(key, value, contentType = "text/plain; charset=utf-8") {
                 const stored = await input.storage.putText(`${prefix}/${key}`, value, contentType);
-                insertArtifact("text", stored.key, stored.url, { contentType });
+                const artifactUrl = buildArtifactUrl(stored.key, stored.url);
+                insertArtifact("text", stored.key, artifactUrl, { contentType });
                 await input.billing.record({
                     customerId: input.customer.id,
                     jobId: input.job.id,
@@ -112,11 +124,15 @@ export function createTemplateJobContext(input) {
                     chargeUsd: 0.01,
                     metadata: { key: stored.key }
                 });
-                return stored;
+                return {
+                    ...stored,
+                    url: artifactUrl
+                };
             },
             async putBuffer(key, value, options = {}) {
                 const stored = await input.storage.putBuffer(`${prefix}/${key}`, value, options.contentType);
-                insertArtifact(options.kind ?? "binary", stored.key, stored.url, {
+                const artifactUrl = buildArtifactUrl(stored.key, stored.url);
+                insertArtifact(options.kind ?? "binary", stored.key, artifactUrl, {
                     ...(options.metadata ?? {}),
                     contentType: options.contentType ?? null
                 });
@@ -129,7 +145,10 @@ export function createTemplateJobContext(input) {
                     chargeUsd: 0.01,
                     metadata: { key: stored.key }
                 });
-                return stored;
+                return {
+                    ...stored,
+                    url: artifactUrl
+                };
             },
             getPublicUrl(key) {
                 return input.storage.getPublicUrl(`${prefix}/${key}`);

package/dist/src/db.js

@@ -116,19 +116,6 @@ create table if not exists jobs (
 
 create index if not exists idx_jobs_runnable on jobs(status, run_after, priority, created_at);
 
-create table if not exists job_events (
-  id text primary key,
-  job_id text not null references jobs(id) on delete cascade,
-  level text not null,
-  message text not null,
-  metadata_json text not null,
-  progress real,
-  artifact_key text,
-  created_at text not null
-);
-
-create index if not exists idx_job_events_job_time on job_events(job_id, created_at);
-
 create table if not exists artifacts (
   id text primary key,
   job_id text not null references jobs(id) on delete cascade,
@@ -248,6 +235,8 @@ db.exec(`
   where slug_id is null or trim(slug_id) = '';
 `);
 db.exec(`create unique index if not exists idx_template_sources_slug_id on template_sources(slug_id);`);
+db.exec(`drop index if exists idx_job_events_job_time;`);
+db.exec(`drop table if exists job_events;`);
 function mapJob(row) {
     return {
         id: String(row.id),
@@ -634,50 +623,6 @@ export const database = {
     `).all(...values);
         return rows.map(mapJob);
     },
-    addJobEvent(event) {
-        db.prepare(`
-      insert into job_events (id, job_id, level, message, metadata_json, progress, artifact_key, created_at)
-      values (@id, @job_id, @level, @message, @metadata_json, @progress, @artifact_key, @created_at)
-    `).run({
-            id: event.id,
-            job_id: event.jobId,
-            level: event.level,
-            message: event.message,
-            metadata_json: stringifyJson(event.metadata),
-            progress: event.progress,
-            artifact_key: event.artifactKey,
-            created_at: nowIso()
-        });
-    },
-    getJobEvents(input) {
-        const filters = ["job_id = ?"];
-        const values = [input.jobId];
-        if (input.startTime) {
-            filters.push("created_at >= ?");
-            values.push(input.startTime);
-        }
-        if (input.endTime) {
-            filters.push("created_at <= ?");
-            values.push(input.endTime);
-        }
-        values.push(Math.max(1, Math.min(input.limit ?? 100, 500)));
-        const rows = db.prepare(`
-      select * from job_events
-      where ${filters.join(" and ")}
-      order by created_at asc
-      limit ?
-    `).all(...values);
-        return rows.map((row) => ({
-            id: String(row.id),
-            jobId: String(row.job_id),
-            level: row.level,
-            message: String(row.message),
-            metadata: parseJson(row.metadata_json, {}),
-            progress: row.progress === null ? null : Number(row.progress),
-            artifactKey: row.artifact_key ? String(row.artifact_key) : null,
-            createdAt: String(row.created_at)
-        }));
-    },
     insertArtifact(record) {
         db.prepare(`
       insert into artifacts (id, job_id, customer_id, template_id, kind, storage_key, public_url, metadata_json, created_at)

package/dist/src/dev-app.js

@@ -590,7 +590,6 @@ export function renderDevApp(input) {
         }
         return {
           "content-type": "application/json",
-          "vidfarm-user-id": state.session.customer.id,
           "vidfarm-api-key": state.session.apiKey
         };
       }

package/dist/src/index.js

@@ -3,8 +3,10 @@ void (async () => {
     const runtime = await startRuntime();
     for (const signal of ["SIGINT", "SIGTERM"]) {
         process.on(signal, () => {
-            runtime.shutdown();
-            process.exit(0);
+            void (async () => {
+                await runtime.shutdown();
+                process.exit(0);
+            })();
         });
     }
 })().catch((error) => {

package/dist/src/lib/template-paths.js

@@ -0,0 +1,21 @@
+import path from "node:path";
+export const TEMPLATE_FOLDER_PREFIX = "vidfarm_template_";
+export function assertTemplateFolderNameHasPrefix(folderName) {
+    if (!folderName.startsWith(TEMPLATE_FOLDER_PREFIX)) {
+        throw new Error(`Template folder name must start with ${TEMPLATE_FOLDER_PREFIX}. Received: ${folderName}`);
+    }
+}
+export function deriveTemplateRootDirFromModulePath(templateModulePath) {
+    const normalizedModulePath = templateModulePath.replace(/\\/g, "/");
+    const templateSourceDir = path.posix.dirname(normalizedModulePath);
+    const templateRootDir = path.posix.dirname(templateSourceDir);
+    if (templateRootDir === "." || templateRootDir === "") {
+        throw new Error("template_module_path must point to a template inside a folder such as templates/vidfarm_template_example/src/template.ts.");
+    }
+    const folderName = path.posix.basename(templateRootDir);
+    assertTemplateFolderNameHasPrefix(folderName);
+    return templateRootDir;
+}
+export function defaultSkillPathForTemplateModule(templateModulePath) {
+    return path.posix.join(deriveTemplateRootDirFromModulePath(templateModulePath), "SKILL.md");
+}

package/dist/src/runtime.js

@@ -2,6 +2,7 @@ import { serve } from "@hono/node-server";
 import app from "./app.js";
 import { config } from "./config.js";
 import { templateRegistry } from "./registry.js";
+import { jobLogStore } from "./services/job-logs.js";
 import { Worker } from "./worker.js";
 export async function startRuntime() {
     await templateRegistry.ensureInitialized();
@@ -13,8 +14,9 @@ export async function startRuntime() {
     }, (info) => {
         console.log(`[vidfarm] listening on http://localhost:${info.port}`);
     });
-    const shutdown = () => {
+    const shutdown = async () => {
         worker.stop();
+        await jobLogStore.shutdown();
         server.close();
     };
     return { server, worker, shutdown };

package/dist/src/services/auth.js

@@ -69,12 +69,12 @@ export class AuthService {
         });
         return { customer, apiKey: rawApiKey };
     }
-    authenticate(userId, apiKey) {
-        if (!userId || !apiKey) {
-            throw new Error("Missing vidfarm-user-id or vidfarm-api-key header.");
+    authenticate(apiKey) {
+        if (!apiKey) {
+            throw new Error("Missing vidfarm-api-key header.");
         }
         const row = database.findApiKeyByHash(hashSecret(apiKey + config.API_KEY_SALT));
-        if (!row || String(row.customer_id) !== userId) {
+        if (!row) {
             throw new Error("Invalid API credentials.");
         }
         if (!Boolean(row.is_paid_plan)) {

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

@@ -0,0 +1,186 @@
+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 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);
+    }
+    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;
+}

package/dist/src/services/jobs.js

@@ -2,6 +2,7 @@ import { config } from "../config.js";
 import { database } from "../db.js";
 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"];
 export class JobsService {
     assertQueueCapacity(customerId) {
@@ -72,8 +73,8 @@ export class JobsService {
     listJobs(input) {
         return database.listJobsForCustomer(input);
     }
-    listLogs(input) {
-        return database.getJobEvents(input);
+    async listLogs(input) {
+        return jobLogStore.listEvents(input);
     }
     cancelJob(jobId) {
         database.updateJobStatus({

package/dist/src/services/providers.js

@@ -172,6 +172,7 @@ export class ProviderService {
                     prompt: input.prompt,
                     promptAttachments: input.promptAttachments,
                     size: input.size,
+                    aspectRatio: input.aspectRatio,
                     apiKey: lease.secret
                 });
             database.recordProviderKeyUsage({
@@ -268,6 +269,12 @@ export class ProviderService {
         if (input.promptAttachments?.length) {
             throw new Error("OpenAI image generation attachments are not implemented in this provider path. Use Gemini for reference attachments.");
         }
+        const prompt = input.aspectRatio === "9:16"
+            ? [
+                input.prompt,
+                "Return a native 9:16 vertical composition with no letterboxing, no inset landscape window, and no empty top or bottom padding."
+            ].join("\n")
+            : input.prompt;
         const response = await fetch("https://api.openai.com/v1/images/generations", {
             method: "POST",
             headers: {
@@ -276,9 +283,8 @@ export class ProviderService {
             },
             body: JSON.stringify({
                 model: input.model,
-                prompt: input.prompt,
-                size: input.size ?? "1024x1536",
-                response_format: "b64_json"
+                prompt,
+                size: input.size ?? "1024x1536"
             })
         });
         if (response.status === 401) {
@@ -288,7 +294,8 @@ export class ProviderService {
             throw new ProviderRateLimitError("openai rate limited");
         }
         if (!response.ok) {
-            throw new Error(`openai image generation returned ${response.status}`);
+            const details = await response.text();
+            throw new Error(`openai image generation returned ${response.status}${details ? `: ${details}` : ""}`);
         }
         const data = await response.json();
         const encoded = data.data?.[0]?.b64_json;
@@ -317,7 +324,7 @@ export class ProviderService {
             body: JSON.stringify({
                 contents: [{ parts: await buildGeminiPromptParts(input.prompt, input.promptAttachments ?? []) }],
                 generationConfig: {
-                    responseModalities: ["TEXT", "IMAGE"],
+                    responseModalities: ["Image"],
                     ...(Object.keys(imageConfig).length
                         ? {
                             imageConfig
@@ -333,7 +340,8 @@ export class ProviderService {
             throw new ProviderRateLimitError("gemini rate limited");
         }
         if (!response.ok) {
-            throw new Error(`gemini image generation returned ${response.status}`);
+            const details = await response.text();
+            throw new Error(`gemini image generation returned ${response.status}${details ? `: ${details}` : ""}`);
         }
         const data = await response.json();
         const part = data.candidates?.[0]?.content?.parts?.find((item) => item.inlineData?.data);

package/dist/src/services/storage.js

@@ -1,6 +1,6 @@
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import path from "node:path";
-import { DeleteObjectCommand, GetObjectCommand, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { DeleteObjectCommand, GetObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
 import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
 import { config } from "../config.js";
 export class StorageService {
@@ -20,6 +20,9 @@ export class StorageService {
     developerAttachmentKey(customerId, attachmentId, fileName) {
         return joinStorageKey("developer", customerId, "attachments", attachmentId, fileName);
     }
+    developerPreviewMediaKey(customerId, ...parts) {
+        return joinStorageKey("developer", customerId, "preview_media", ...parts);
+    }
     templateJobPrefix(templateId, customerId, jobId) {
         return joinStorageKey("templates", templateId, "users", customerId, "jobs", jobId);
     }
@@ -77,6 +80,67 @@ export class StorageService {
     async getReadUrl(key) {
         return this.createReadUrl(key);
     }
+    async createWriteUrl(key, input) {
+        if (!this.s3 || !config.AWS_S3_BUCKET) {
+            throw new Error("Presigned uploads require S3 storage.");
+        }
+        const publicRead = input.publicRead ?? config.s3PublicRead;
+        const expiresIn = input.expiresIn ?? 3600;
+        const command = new PutObjectCommand({
+            Bucket: config.AWS_S3_BUCKET,
+            Key: key,
+            ContentType: input.contentType,
+            ACL: publicRead ? "public-read" : undefined
+        });
+        return {
+            url: await getSignedUrl(this.s3, command, { expiresIn }),
+            method: "PUT",
+            headers: {
+                "content-type": input.contentType,
+                ...(publicRead ? { "x-amz-acl": "public-read" } : {})
+            },
+            expiresIn
+        };
+    }
+    async readText(key) {
+        if (this.s3 && config.AWS_S3_BUCKET) {
+            const response = await this.s3.send(new GetObjectCommand({
+                Bucket: config.AWS_S3_BUCKET,
+                Key: key
+            }));
+            if (!response.Body) {
+                return null;
+            }
+            return response.Body.transformToString();
+        }
+        return readFileSync(path.join(this.localRoot, key), "utf8");
+    }
+    async listKeys(prefix) {
+        if (this.s3 && config.AWS_S3_BUCKET) {
+            const keys = [];
+            let continuationToken;
+            do {
+                const response = await this.s3.send(new ListObjectsV2Command({
+                    Bucket: config.AWS_S3_BUCKET,
+                    Prefix: prefix,
+                    ContinuationToken: continuationToken
+                }));
+                for (const object of response.Contents ?? []) {
+                    if (object.Key) {
+                        keys.push(object.Key);
+                    }
+                }
+                continuationToken = response.IsTruncated ? response.NextContinuationToken : undefined;
+            } while (continuationToken);
+            return keys;
+        }
+        const root = path.join(this.localRoot, prefix);
+        const keys = [];
+        walkLocalTree(root, (filePath) => {
+            keys.push(path.relative(this.localRoot, filePath).split(path.sep).join("/"));
+        });
+        return keys;
+    }
     async deleteObject(key) {
         if (this.s3 && config.AWS_S3_BUCKET) {
             await this.s3.send(new DeleteObjectCommand({
@@ -147,3 +211,22 @@ function inferContentType(filePath) {
             return "application/octet-stream";
     }
 }
+function walkLocalTree(root, onFile) {
+    try {
+        const entries = readdirSync(root, { withFileTypes: true });
+        for (const entry of entries) {
+            const childPath = path.join(root, entry.name);
+            if (entry.isDirectory()) {
+                walkLocalTree(childPath, onFile);
+            }
+            else if (entry.isFile()) {
+                onFile(childPath);
+            }
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+}