@mevdragon/vidfarm-devcli 0.20.6 → 0.20.8

package/dist/src/services/serverless-template-configs.js

@@ -1,75 +0,0 @@
-import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
-import { DynamoDBDocumentClient, GetCommand, PutCommand } from "@aws-sdk/lib-dynamodb";
-import { config } from "../config.js";
-import { devLog } from "../lib/dev-log.js";
-import { nowIso } from "../lib/time.js";
-import { createLocalDynamoClient } from "./local-dynamo.js";
-// `vidfarm serve` (RECORDS_DRIVER=local) swaps in the disk-backed shim so
-// template configs live on disk; deployed environments keep the real client.
-const dynamodb = config.RECORDS_DRIVER === "local"
-    ? createLocalDynamoClient()
-    : DynamoDBDocumentClient.from(new DynamoDBClient({}), {
-        marshallOptions: {
-            removeUndefinedValues: true
-        }
-    });
-export class ServerlessTemplateConfigService {
-    async getTemplateConfig(customerId, templateId) {
-        const response = await dynamodb.send(new GetCommand({
-            TableName: requireMainTableName(),
-            Key: templateConfigKey(customerId, templateId)
-        }));
-        const item = response.Item;
-        const configJson = item && isRecord(item.config_json) ? item.config_json : {};
-        devLog("template_config.get", {
-            customer_id: customerId,
-            template_id: templateId,
-            found: Boolean(item),
-            key_count: Object.keys(configJson).length
-        });
-        return configJson;
-    }
-    async upsertTemplateConfig(input) {
-        const timestamp = nowIso();
-        await dynamodb.send(new PutCommand({
-            TableName: requireMainTableName(),
-            Item: {
-                ...templateConfigKey(input.customerId, input.templateId),
-                entity_type: "TemplateConfig",
-                gsi1pk: `CUSTOMER#${input.customerId}#TEMPLATE_CONFIGS`,
-                gsi1sk: `TEMPLATE#${input.templateId}`,
-                config_id: input.id,
-                customer_id: input.customerId,
-                template_id: input.templateId,
-                config_json: input.config,
-                created_at: timestamp,
-                updated_at: timestamp
-            }
-        }));
-        devLog("template_config.upserted", {
-            config_id: input.id,
-            customer_id: input.customerId,
-            template_id: input.templateId,
-            key_count: Object.keys(input.config).length
-        });
-    }
-}
-function requireMainTableName() {
-    if (config.RECORDS_DRIVER === "local") {
-        return config.VIDFARM_SERVERLESS_MAIN_TABLE_NAME || "vidfarm-local-main";
-    }
-    if (!config.VIDFARM_SERVERLESS_MAIN_TABLE_NAME) {
-        throw new Error("Serverless template config store requires VIDFARM_SERVERLESS_MAIN_TABLE_NAME.");
-    }
-    return config.VIDFARM_SERVERLESS_MAIN_TABLE_NAME;
-}
-function templateConfigKey(customerId, templateId) {
-    return {
-        pk: `CUSTOMER#${customerId}#TEMPLATE#${templateId}`,
-        sk: "CONFIG"
-    };
-}
-function isRecord(value) {
-    return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-//# sourceMappingURL=serverless-template-configs.js.map

package/dist/src/services/storage.js

@@ -1,461 +0,0 @@
-import { copyFileSync, createReadStream, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, PutObjectCommand, PutObjectTaggingCommand, S3Client } from "@aws-sdk/client-s3";
-import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
-import { config } from "../config.js";
-function isS3NotFoundError(error) {
-    if (!error || typeof error !== "object")
-        return false;
-    const record = error;
-    const name = typeof record.name === "string" ? record.name : "";
-    const code = typeof record.Code === "string" ? record.Code : "";
-    const metadata = record.$metadata;
-    const httpStatusCode = typeof metadata?.httpStatusCode === "number" ? metadata.httpStatusCode : undefined;
-    return name === "NoSuchKey" || code === "NoSuchKey" || name === "NotFound" || httpStatusCode === 404;
-}
-// Media objects live at stable, content-addressed-ish keys and are the
-// heavy bytes browsers re-fetch on every /discover visit today (S3 objects
-// currently ship no Cache-Control). Give media a 1-day fresh window with a
-// week-long stale-while-revalidate tail so it caches hard but still self-heals
-// if a key is ever overwritten in place. NON-media (json records, composition
-// html, text) stays uncached — those are mutable and must never go stale.
-function cacheControlForContentType(contentType) {
-    const ct = (contentType || "").toLowerCase();
-    if (ct.startsWith("video/") || ct.startsWith("image/") || ct.startsWith("audio/")) {
-        return "public, max-age=86400, stale-while-revalidate=604800";
-    }
-    return undefined;
-}
-export class StorageService {
-    localRoot = path.join(config.VIDFARM_DATA_DIR, "storage");
-    s3 = config.STORAGE_DRIVER === "s3"
-        ? new S3Client({
-            region: config.AWS_REGION,
-            endpoint: config.AWS_S3_ENDPOINT || undefined
-        })
-        : null;
-    constructor() {
-        mkdirSync(this.localRoot, { recursive: true });
-    }
-    userAttachmentKey(customerId, attachmentId, fileName, folderPath) {
-        return joinStorageKey("users", customerId, "files", folderPath || "", attachmentId, fileName);
-    }
-    legacyUserAttachmentKey(customerId, attachmentId, fileName) {
-        return joinStorageKey("users", customerId, attachmentId, fileName);
-    }
-    // Add Template → upload a video file: staging area for uploaded inspiration
-    // sources. Lives under users/ so the bucket's public-read policy covers it —
-    // the video_ingest job and the editor fetch it by plain URL.
-    inspirationUploadKey(customerId, uploadId, fileName) {
-        return joinStorageKey("users", customerId, "inspiration-uploads", uploadId, fileName);
-    }
-    userTemporaryFileKey(customerId, fileId, fileName, folderPath) {
-        return joinStorageKey("users", customerId, "temporary", folderPath || "", fileId, fileName);
-    }
-    developerAttachmentKey(customerId, attachmentId, fileName) {
-        return joinStorageKey("developer", customerId, "attachments", attachmentId, fileName);
-    }
-    developerScopedKey(customerId, ...parts) {
-        return joinStorageKey("developer", customerId, ...parts);
-    }
-    templateJobPrefix(templateId, customerId, jobId) {
-        return joinStorageKey("templates", templateId, "users", customerId, "jobs", jobId);
-    }
-    templateJobKey(templateId, customerId, jobId, key) {
-        return joinStorageKey(this.templateJobPrefix(templateId, customerId, jobId), key);
-    }
-    primitiveJobPrefix(primitiveId, customerId, jobId) {
-        return joinStorageKey("primitives", primitiveId, "users", customerId, "jobs", jobId);
-    }
-    primitiveJobKey(primitiveId, customerId, jobId, key) {
-        return joinStorageKey(this.primitiveJobPrefix(primitiveId, customerId, jobId), key);
-    }
-    templateAboutKey(templateId, assetPath) {
-        return joinStorageKey("templates", templateId, "about", assetPath);
-    }
-    compositionForkRoot(forkId) {
-        return joinStorageKey("compositions", "forks", forkId);
-    }
-    compositionForkWorkingPrefix(forkId) {
-        return joinStorageKey(this.compositionForkRoot(forkId), "working");
-    }
-    compositionForkWorkingKey(forkId, filename) {
-        return joinStorageKey(this.compositionForkWorkingPrefix(forkId), filename);
-    }
-    compositionForkVersionPrefix(forkId, version) {
-        return joinStorageKey(this.compositionForkRoot(forkId), "versions", String(version));
-    }
-    compositionForkVersionKey(forkId, version, filename) {
-        return joinStorageKey(this.compositionForkVersionPrefix(forkId, version), filename);
-    }
-    submittedVideoPrefix(videoId) {
-        return joinStorageKey("videos", videoId);
-    }
-    submittedVideoKey(videoId, filename) {
-        return joinStorageKey(this.submittedVideoPrefix(videoId), filename);
-    }
-    async putJson(key, value) {
-        const body = JSON.stringify(value, null, 2);
-        return this.putBuffer(key, Buffer.from(body, "utf8"), "application/json");
-    }
-    async putText(key, value, contentType = "text/plain; charset=utf-8") {
-        return this.putBuffer(key, Buffer.from(value, "utf8"), contentType);
-    }
-    // Uploads to S3 (or the local dev filesystem) and returns the key plus a
-    // public URL when the key is in a public-policy prefix. The old
-    // `publicRead` argument was a lie — bucket-level policy decides what's
-    // public, not per-call flags — so it's been removed.
-    async putBuffer(key, value, contentType = "application/octet-stream") {
-        if (this.s3 && config.AWS_S3_BUCKET) {
-            await this.s3.send(new PutObjectCommand({
-                Bucket: config.AWS_S3_BUCKET,
-                Key: key,
-                Body: value,
-                ContentType: contentType,
-                CacheControl: cacheControlForContentType(contentType)
-            }));
-            return { key, url: this.getPublicUrl(key) };
-        }
-        const filePath = this.resolveLocalPath(key);
-        mkdirSync(path.dirname(filePath), { recursive: true });
-        writeFileSync(filePath, value);
-        return { key, url: this.getPublicUrl(key) };
-    }
-    /**
-     * Tag an existing S3 object. Used to mark temp-folder uploads with
-     * `vidfarm-temp=1` AFTER the client's presigned PUT lands (server-side, so
-     * no client header contract), which the bucket's tag-scoped lifecycle rule
-     * expires after 30 days. No-op on the local filesystem driver.
-     */
-    /**
-     * Store a file that already lives on disk WITHOUT reading it fully into memory.
-     * Streams the bytes to S3 (ContentLength from the file's size, so no multipart
-     * dependency) or copies on the local driver. Use for large media (whole-video
-     * raw imports, render outputs) where `putBuffer(readFileSync(...))` would pin
-     * the entire file in a Buffer and risk OOM on memory-bounded Lambdas.
-     */
-    async putFile(key, localPath, contentType = "application/octet-stream") {
-        if (this.s3 && config.AWS_S3_BUCKET) {
-            await this.s3.send(new PutObjectCommand({
-                Bucket: config.AWS_S3_BUCKET,
-                Key: key,
-                Body: createReadStream(localPath),
-                ContentLength: statSync(localPath).size,
-                ContentType: contentType,
-                CacheControl: cacheControlForContentType(contentType)
-            }));
-            return { key, url: this.getPublicUrl(key) };
-        }
-        const filePath = this.resolveLocalPath(key);
-        mkdirSync(path.dirname(filePath), { recursive: true });
-        copyFileSync(localPath, filePath);
-        return { key, url: this.getPublicUrl(key) };
-    }
-    async putObjectTags(key, tags) {
-        if (!this.s3 || !config.AWS_S3_BUCKET)
-            return;
-        await this.s3.send(new PutObjectTaggingCommand({
-            Bucket: config.AWS_S3_BUCKET,
-            Key: key,
-            Tagging: { TagSet: Object.entries(tags).map(([Key, Value]) => ({ Key, Value })) }
-        }));
-    }
-    // Returns a directly-fetchable URL for a storage key when the key is
-    // stored under a prefix the bucket resource policy grants public read to.
-    // Callers get a real S3 URL that browsers/CDNs/GhostCut/etc. can hit
-    // without any Lambda proxy hop. Returns null for keys under private
-    // prefixes — callers who need to serve those must do access-checked
-    // reads through their own endpoint.
-    getPublicUrl(key) {
-        let normalizedKey;
-        try {
-            normalizedKey = normalizeStorageKey(key);
-        }
-        catch {
-            return null;
-        }
-        if (this.s3 && config.AWS_S3_BUCKET) {
-            if (!isPublicStorageKey(normalizedKey)) {
-                return null;
-            }
-            const encodedKey = normalizedKey.split("/").map((segment) => encodeURIComponent(segment)).join("/");
-            if (config.AWS_S3_ENDPOINT) {
-                return `${config.AWS_S3_ENDPOINT.replace(/\/$/, "")}/${config.AWS_S3_BUCKET}/${encodedKey}`;
-            }
-            return `https://${config.AWS_S3_BUCKET}.s3.${config.AWS_REGION}.amazonaws.com/${encodedKey}`;
-        }
-        return `${config.PUBLIC_BASE_URL}/storage/${encodeURIComponent(normalizedKey)}`;
-    }
-    readLocalJson(key) {
-        return JSON.parse(readFileSync(this.resolveLocalPath(key), "utf8"));
-    }
-    readLocalObject(key) {
-        const filePath = this.resolveLocalPath(key);
-        const body = readFileSync(filePath);
-        return {
-            body,
-            contentType: inferContentType(filePath)
-        };
-    }
-    async getReadUrl(key) {
-        return this.createReadUrl(key);
-    }
-    // Absolute on-disk path for a key — local driver only (null on S3), for
-    // callers that hand the file to a local process (ffmpeg) without copying.
-    getLocalPath(key) {
-        if (this.s3 && config.AWS_S3_BUCKET)
-            return null;
-        try {
-            return this.resolveLocalPath(key);
-        }
-        catch {
-            return null;
-        }
-    }
-    async createWriteUrl(key, input) {
-        if (!this.s3 || !config.AWS_S3_BUCKET) {
-            throw new Error("Presigned uploads require S3 storage.");
-        }
-        const expiresIn = input.expiresIn ?? 3600;
-        const command = new PutObjectCommand({
-            Bucket: config.AWS_S3_BUCKET,
-            Key: key,
-            ContentType: input.contentType
-        });
-        return {
-            url: await getSignedUrl(this.s3, command, { expiresIn }),
-            method: "PUT",
-            headers: {
-                "content-type": input.contentType
-            },
-            expiresIn
-        };
-    }
-    async readText(key) {
-        if (this.s3 && config.AWS_S3_BUCKET) {
-            try {
-                const response = await this.s3.send(new GetObjectCommand({
-                    Bucket: config.AWS_S3_BUCKET,
-                    Key: key
-                }));
-                if (!response.Body) {
-                    return null;
-                }
-                return response.Body.transformToString();
-            }
-            catch (error) {
-                if (isS3NotFoundError(error))
-                    return null;
-                throw error;
-            }
-        }
-        try {
-            return readFileSync(this.resolveLocalPath(key), "utf8");
-        }
-        catch (error) {
-            if (error?.code === "ENOENT")
-                return null;
-            throw error;
-        }
-    }
-    async readBuffer(key) {
-        if (this.s3 && config.AWS_S3_BUCKET) {
-            try {
-                const response = await this.s3.send(new GetObjectCommand({
-                    Bucket: config.AWS_S3_BUCKET,
-                    Key: key
-                }));
-                if (!response.Body) {
-                    return null;
-                }
-                return Buffer.from(await response.Body.transformToByteArray());
-            }
-            catch (error) {
-                if (isS3NotFoundError(error))
-                    return null;
-                throw error;
-            }
-        }
-        try {
-            return readFileSync(this.resolveLocalPath(key));
-        }
-        catch (error) {
-            if (error?.code === "ENOENT")
-                return null;
-            throw error;
-        }
-    }
-    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 objectExists(key) {
-        if (this.s3 && config.AWS_S3_BUCKET) {
-            try {
-                await this.s3.send(new HeadObjectCommand({
-                    Bucket: config.AWS_S3_BUCKET,
-                    Key: key
-                }));
-                return true;
-            }
-            catch {
-                return false;
-            }
-        }
-        try {
-            readFileSync(this.resolveLocalPath(key));
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async deleteObject(key) {
-        if (this.s3 && config.AWS_S3_BUCKET) {
-            await this.s3.send(new DeleteObjectCommand({
-                Bucket: config.AWS_S3_BUCKET,
-                Key: key
-            }));
-            return;
-        }
-        rmSync(this.resolveLocalPath(key), { force: true });
-    }
-    resolveLocalPath(key) {
-        const normalizedKey = normalizeStorageKey(key);
-        const root = path.resolve(this.localRoot);
-        const filePath = path.resolve(root, normalizedKey);
-        if (filePath !== root && !filePath.startsWith(`${root}${path.sep}`)) {
-            throw new Error("Invalid storage key.");
-        }
-        return filePath;
-    }
-    async createReadUrl(key) {
-        if (this.s3 && config.AWS_S3_BUCKET) {
-            const command = new GetObjectCommand({
-                Bucket: config.AWS_S3_BUCKET,
-                Key: key
-            });
-            return getSignedUrl(this.s3, command, { expiresIn: 86400 });
-        }
-        return this.getPublicUrl(key);
-    }
-}
-export function joinStorageKey(...parts) {
-    return parts
-        .flatMap((part) => part.split("/"))
-        .map((part) => part.trim())
-        .filter(Boolean)
-        .join("/");
-}
-// Shared process-wide StorageService instance. StorageService binds its driver
-// (s3 vs local fs) + data dir from `config` at construction, so importing this
-// singleton must happen AFTER any env that flips RECORDS_DRIVER/STORAGE_DRIVER/
-// VIDFARM_DATA_DIR has been set (the in-process devcli local path arranges that
-// via withLocalBackend before it imports any service). app.ts, the extracted
-// directory/clip-scan services, and the devcli all share this one instance.
-export const storage = new StorageService();
-function normalizeStorageKey(key) {
-    const normalized = key.replace(/^\/+/, "");
-    if (!normalized ||
-        normalized.includes("\\") ||
-        path.isAbsolute(normalized) ||
-        normalized.split("/").some((segment) => !segment || segment === "." || segment === "..")) {
-        throw new Error("Invalid storage key.");
-    }
-    return normalized;
-}
-// MUST match the bucket resource policy in the CDK stacks. Adding a prefix
-// here without also granting it public read in the S3 bucket policy will
-// produce 403s for anonymous readers. Kept alphabetized for grepability.
-function isPublicStorageKey(key) {
-    return [
-        "assets/channels/",
-        "compositions/forks/",
-        "developer/",
-        "primitives/",
-        "templates/",
-        "user/",
-        "users/"
-    ].some((prefix) => key.startsWith(prefix));
-}
-function inferContentType(filePath) {
-    switch (path.extname(filePath).toLowerCase()) {
-        case ".json":
-            return "application/json";
-        case ".png":
-            return "image/png";
-        case ".gif":
-            return "image/gif";
-        case ".jpg":
-        case ".jpeg":
-            return "image/jpeg";
-        case ".webp":
-            return "image/webp";
-        case ".svg":
-            return "image/svg+xml";
-        case ".mp4":
-            return "video/mp4";
-        case ".webm":
-            return "video/webm";
-        case ".mov":
-            return "video/quicktime";
-        case ".mp3":
-            return "audio/mpeg";
-        case ".wav":
-            return "audio/wav";
-        case ".m4a":
-            return "audio/mp4";
-        case ".ogg":
-            return "audio/ogg";
-        case ".pdf":
-            return "application/pdf";
-        case ".md":
-            return "text/markdown; charset=utf-8";
-        case ".txt":
-            return "text/plain; charset=utf-8";
-        default:
-            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;
-        }
-    }
-}
-//# sourceMappingURL=storage.js.map