edsger 0.33.1 → 0.33.2

package/dist/api/storage.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Storage API – fetches signed upload URLs from the MCP server
+ * so the CLI can upload directly to Supabase Storage without a JWT.
+ */
+export interface SignedUploadUrl {
+    path: string;
+    signed_url: string;
+    token: string;
+}
+/**
+ * Request signed upload URLs for a batch of storage paths.
+ */
+export declare function getSignedUploadUrls(bucket: string, paths: string[], verbose?: boolean): Promise<SignedUploadUrl[]>;

package/dist/api/storage.js

@@ -0,0 +1,26 @@
+/**
+ * Storage API – fetches signed upload URLs from the MCP server
+ * so the CLI can upload directly to Supabase Storage without a JWT.
+ */
+import { callMcpEndpoint } from './mcp-client.js';
+import { logError } from '../utils/logger.js';
+/**
+ * Request signed upload URLs for a batch of storage paths.
+ */
+export async function getSignedUploadUrls(bucket, paths, verbose) {
+    try {
+        const result = (await callMcpEndpoint('storage/create_signed_upload_urls', { bucket, paths }));
+        const text = result.content?.[0]?.text || '{"urls":[],"errors":[]}';
+        const parsed = JSON.parse(text);
+        if (parsed.errors?.length) {
+            for (const err of parsed.errors) {
+                logError(`Signed URL error for ${err.path}: ${err.error}`);
+            }
+        }
+        return parsed.urls;
+    }
+    catch (error) {
+        logError(`Failed to get signed upload URLs: ${error instanceof Error ? error.message : String(error)}`);
+        return [];
+    }
+}

package/dist/commands/app-store/index.js

@@ -1,5 +1,6 @@
 import { logInfo, logError, logSuccess } from '../../utils/logger.js';
-import { validateConfiguration } from '../../utils/validation.js';
+import { validateConfiguration, validateRequirements, } from '../../utils/validation.js';
+import { isPlaywrightAvailable } from '../../services/video/screenshot-generator.js';
 import { generateAppStoreAssets, } from '../../phases/app-store-generation/index.js';
 /**
  * Run AI-powered app store asset generation for a product.
@@ -11,6 +12,14 @@ export const runAppStoreGeneration = async (options) => {
         throw new Error('Product ID is required for app store generation');
     }
     const config = validateConfiguration(options);
+    // Pre-flight check: ensure Playwright is installed when screenshots are needed
+    if (!options.listingsOnly) {
+        await validateRequirements(isPlaywrightAvailable, 'Playwright is required for screenshot generation but is not installed.\n\n' +
+            '  Install it by running:\n\n' +
+            '    npm install playwright\n' +
+            '    npx playwright install chromium\n\n' +
+            '  Then re-run this command. Use --listings-only to skip screenshots.');
+    }
     const targetStore = options.store === 'apple'
         ? 'apple'
         : options.store === 'google'

package/dist/phases/app-store-generation/uploader.js

@@ -8,9 +8,10 @@ import { readFile, copyFile, mkdir } from 'fs/promises';
 import { join, basename } from 'path';
 import { homedir } from 'os';
 import { logInfo, logError } from '../../utils/logger.js';
-import { getMcpServerUrl, getMcpToken } from '../../auth/auth-store.js';
+import { getMcpServerUrl } from '../../auth/auth-store.js';
 import { fetchWithRetry } from '../../services/video/retry.js';
 import { saveAppStoreScreenshots, } from '../../api/app-store.js';
+import { getSignedUploadUrls } from '../../api/storage.js';
 /**
  * Get local backup directory for app store assets
  */
@@ -39,8 +40,7 @@ export async function uploadAppStoreScreenshots(screenshots, options) {
     const localDir = join(getLocalAssetDir(), productId);
     await mkdir(localDir, { recursive: true });
     const storageBaseUrl = getStorageBaseUrl();
-    const mcpToken = getMcpToken();
-    if (!storageBaseUrl || !mcpToken) {
+    if (!storageBaseUrl) {
         logError('Not authenticated. Run `edsger login` to configure storage access.');
         // Still save locally even if we can't upload
         const localResults = [];
@@ -56,26 +56,48 @@ export async function uploadAppStoreScreenshots(screenshots, options) {
         }
         return localResults;
     }
-    const uploadedScreenshots = [];
+    // Save local backups and build storage paths
+    const storagePaths = [];
     for (const ss of screenshots) {
+        const localFileName = basename(ss.local_path);
+        const localPath = join(localDir, localFileName);
+        await copyFile(ss.local_path, localPath);
+        storagePaths.push(`${productId}/${localFileName}`);
+    }
+    // Fetch signed upload URLs in a single batch request
+    const signedUrls = await getSignedUploadUrls('app-store-assets', storagePaths, verbose);
+    const signedUrlMap = new Map(signedUrls.map((u) => [u.path, u]));
+    const uploadedScreenshots = [];
+    for (let i = 0; i < screenshots.length; i++) {
+        const ss = screenshots[i];
+        const storagePath = storagePaths[i];
+        const signed = signedUrlMap.get(storagePath);
+        if (!signed) {
+            logError(`No signed URL for ${storagePath}, skipping upload`);
+            uploadedScreenshots.push({
+                device_type: ss.device_type,
+                display_order: ss.display_order,
+                storage_url: '',
+                storage_path: '',
+                width: ss.width,
+                height: ss.height,
+                caption: ss.caption,
+                background_gradient: ss.background_gradient,
+                device_frame: ss.device_frame,
+                locale: ss.locale,
+            });
+            continue;
+        }
         try {
-            // Local backup
             const localFileName = basename(ss.local_path);
-            const localPath = join(localDir, localFileName);
-            await copyFile(ss.local_path, localPath);
-            // Upload to Supabase Storage
-            const storagePath = `${productId}/${localFileName}`;
-            const uploadUrl = `${storageBaseUrl}/object/app-store-assets/${storagePath}`;
             const fileBuffer = await readFile(ss.local_path);
             if (verbose) {
                 logInfo(`Uploading ${localFileName} (${(fileBuffer.length / 1024).toFixed(0)}KB)...`);
             }
-            await fetchWithRetry(uploadUrl, {
-                method: 'POST',
+            await fetchWithRetry(signed.signed_url, {
+                method: 'PUT',
                 headers: {
-                    Authorization: `Bearer ${mcpToken}`,
                     'Content-Type': 'image/png',
-                    'x-upsert': 'true',
                 },
                 body: new Uint8Array(fileBuffer),
             }, { label: `Upload ${localFileName}` });
@@ -95,7 +117,6 @@ export async function uploadAppStoreScreenshots(screenshots, options) {
         }
         catch (error) {
             logError(`Failed to upload ${basename(ss.local_path)}: ${error instanceof Error ? error.message : String(error)}`);
-            // Still include with empty storage URL
             uploadedScreenshots.push({
                 device_type: ss.device_type,
                 display_order: ss.display_order,

package/dist/services/video/video-uploader.js

@@ -6,9 +6,10 @@ import { readFile, copyFile, mkdir } from 'fs/promises';
 import { join } from 'path';
 import { homedir } from 'os';
 import { logInfo, logError } from '../../utils/logger.js';
-import { getMcpServerUrl, getMcpToken } from '../../auth/auth-store.js';
+import { getMcpServerUrl } from '../../auth/auth-store.js';
 import { callMcpEndpoint } from '../../api/mcp-client.js';
 import { fetchWithRetry } from './retry.js';
+import { getSignedUploadUrls } from '../../api/storage.js';
 /**
  * Get the local backup directory for growth videos
  */
@@ -46,22 +47,23 @@ export async function uploadGrowthVideo(videoPath, productId, analysisId, verbos
     const storagePath = `${productId}/${analysisId}/${localFileName}`;
     try {
         const storageBaseUrl = getStorageBaseUrl();
-        const mcpToken = getMcpToken();
-        if (!storageBaseUrl || !mcpToken) {
+        if (!storageBaseUrl) {
             throw new Error('Not authenticated. Run `edsger login` to configure storage access.');
         }
         const videoBuffer = await readFile(videoPath);
         if (verbose) {
             logInfo(`Uploading video to Supabase Storage (${(videoBuffer.length / 1024 / 1024).toFixed(1)}MB)...`);
         }
-        // Upload via Supabase Storage Object API (binary body) with retry
-        const uploadUrl = `${storageBaseUrl}/object/growth-videos/${storagePath}`;
-        await fetchWithRetry(uploadUrl, {
-            method: 'POST',
+        // Get a signed upload URL from the MCP server
+        const signedUrls = await getSignedUploadUrls('growth-videos', [storagePath], verbose);
+        if (!signedUrls.length) {
+            throw new Error('Failed to get signed upload URL for video');
+        }
+        // Upload using the signed URL (PUT, no auth header needed)
+        await fetchWithRetry(signedUrls[0].signed_url, {
+            method: 'PUT',
             headers: {
-                Authorization: `Bearer ${mcpToken}`,
                 'Content-Type': 'video/mp4',
-                'x-upsert': 'true',
             },
             body: new Uint8Array(videoBuffer),
         }, { label: 'Supabase Storage upload' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.33.1",
+  "version": "0.33.2",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"