speqs 0.5.1 → 0.7.0

package/dist/lib/upload.js

@@ -0,0 +1,178 @@
+/**
+ * File upload utilities for media modalities.
+ *
+ * Implements the same backend-mediated upload flow as the frontend:
+ *   1. POST /studies/{id}/content/upload  → signed URL + content_url
+ *   2. PUT  signed_upload_url             → upload raw bytes
+ *   3. PUT  /studies/{id}/content/upload/complete → mark done
+ *
+ * Detects local file paths vs URLs automatically and handles
+ * MIME type detection, file validation, and progress reporting.
+ */
+import { readFile } from "node:fs/promises";
+import { access, stat, constants } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { extname, basename, resolve as resolvePath } from "node:path";
+// ---------------------------------------------------------------------------
+// MIME type detection (inline map — zero dependencies)
+// ---------------------------------------------------------------------------
+const MIME_MAP = {
+    // Video
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".mov": "video/quicktime",
+    ".avi": "video/x-msvideo",
+    // Audio
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".ogg": "audio/ogg",
+    ".m4a": "audio/mp4",
+    ".flac": "audio/flac",
+    // Image
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".bmp": "image/bmp",
+    // Document
+    ".pdf": "application/pdf",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".ppt": "application/vnd.ms-powerpoint",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    // Text
+    ".txt": "text/plain",
+    ".html": "text/html",
+    ".htm": "text/html",
+    ".csv": "text/csv",
+    ".json": "application/json",
+    ".md": "text/markdown",
+};
+export function detectMimeType(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    return MIME_MAP[ext] || "application/octet-stream";
+}
+// ---------------------------------------------------------------------------
+// Path detection
+// ---------------------------------------------------------------------------
+export function isLocalPath(value) {
+    // URLs have a scheme followed by "://"; anything else is a local path
+    if (value.startsWith("http://") || value.startsWith("https://"))
+        return false;
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(value)) {
+        throw new Error(`Unsupported URL scheme: ${value.split("://")[0]}. Use http(s):// URLs or local file paths.`);
+    }
+    return true;
+}
+// ---------------------------------------------------------------------------
+// File validation
+// ---------------------------------------------------------------------------
+const MAX_FILE_SIZE = 500 * 1024 * 1024; // 500 MB
+export async function validateFile(filePath) {
+    const resolved = resolvePath(filePath);
+    try {
+        await access(resolved, constants.R_OK);
+    }
+    catch {
+        throw new Error(`File not found or not readable: ${filePath}`);
+    }
+    const info = await stat(resolved);
+    if (!info.isFile()) {
+        throw new Error(`Not a regular file: ${filePath}`);
+    }
+    if (info.size === 0) {
+        throw new Error(`File is empty: ${filePath}`);
+    }
+    if (info.size > MAX_FILE_SIZE) {
+        const sizeMB = (info.size / (1024 * 1024)).toFixed(1);
+        throw new Error(`File too large (${sizeMB} MB). Maximum is ${MAX_FILE_SIZE / (1024 * 1024)} MB.`);
+    }
+    return { size: info.size, mime: detectMimeType(filePath) };
+}
+// ---------------------------------------------------------------------------
+// Core upload: 3-step backend-mediated flow
+// ---------------------------------------------------------------------------
+/**
+ * Upload a local file to Supabase Storage via the backend's signed URL flow.
+ * Returns the public content_url for use in iteration details.
+ */
+export async function uploadStudyContent(client, studyId, filePath, opts) {
+    const resolved = resolvePath(filePath);
+    const { size, mime: detectedMime } = await validateFile(filePath);
+    const mime = opts?.mimeTypeOverride || detectedMime;
+    const name = basename(filePath);
+    const sizeMB = (size / (1024 * 1024)).toFixed(1);
+    const log = (msg) => { if (!opts?.quiet)
+        process.stderr.write(msg); };
+    // Step 1: Request a signed upload URL from the backend
+    log(`Uploading ${name} (${sizeMB} MB)...`);
+    const uploadResp = await client.post(`/studies/${studyId}/content/upload`, { content_type: mime, file_size_bytes: size });
+    // Step 2: PUT the raw file bytes to the signed URL
+    const fileBuffer = await readFile(resolved);
+    const putResp = await fetch(uploadResp.upload_info.signed_upload_url, {
+        method: "PUT",
+        headers: {
+            "Content-Type": mime,
+            "Content-Length": String(fileBuffer.byteLength),
+        },
+        body: fileBuffer,
+        signal: AbortSignal.timeout(300_000), // 5 min timeout for large files
+    });
+    if (!putResp.ok) {
+        const body = await putResp.text().catch(() => "");
+        throw new Error(`Upload failed (HTTP ${putResp.status}): ${body}`);
+    }
+    // Step 3: Mark the upload as complete
+    await client.put(`/studies/${studyId}/content/upload/complete`, {
+        file_path: uploadResp.upload_info.file_path,
+        is_uploaded: true,
+    });
+    log(" done.\n");
+    return uploadResp.content_url;
+}
+// ---------------------------------------------------------------------------
+// High-level resolvers (URL passthrough or upload)
+// ---------------------------------------------------------------------------
+/**
+ * If the value is a URL, return it as-is. If it's a local file path,
+ * upload it and return the resulting content_url.
+ */
+export async function resolveContentUrl(client, studyId, value, opts) {
+    if (!isLocalPath(value))
+        return value;
+    return uploadStudyContent(client, studyId, value, opts);
+}
+/**
+ * Resolve a comma-separated list of URLs or file paths.
+ * Each value is independently resolved (some may be URLs, some files).
+ */
+export async function resolveContentUrls(client, studyId, commaSeparated, opts) {
+    const values = commaSeparated.split(",").map((s) => s.trim()).filter(Boolean);
+    const results = [];
+    for (const v of values) {
+        results.push(await resolveContentUrl(client, studyId, v, opts));
+    }
+    return results;
+}
+/**
+ * Resolve text content. If the value starts with '@', read the file at
+ * the path that follows (curl-style convention). Otherwise return as-is.
+ */
+export function resolveTextContent(value) {
+    if (!value.startsWith("@"))
+        return value;
+    const filePath = value.slice(1);
+    if (!filePath) {
+        throw new Error("Missing file path after @. Usage: --content-text @./file.txt");
+    }
+    const resolved = resolvePath(filePath);
+    try {
+        return readFileSync(resolved, "utf-8");
+    }
+    catch {
+        throw new Error(`Cannot read text file: ${filePath}`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "speqs",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "The command-line interface for Speqs",
   "type": "module",
   "bin": {
@@ -33,7 +33,8 @@
     "email": "support@speqs.io"
   },
   "dependencies": {
-    "commander": "^13.0.0"
+    "commander": "^13.0.0",
+    "playwright-core": "^1.58.2"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",