edsger 0.31.1 → 0.32.0

package/dist/api/app-store.d.ts

@@ -0,0 +1,76 @@
+export interface AppStoreConfig {
+    id: string;
+    product_id: string;
+    store_type: 'apple_app_store' | 'google_play';
+    credentials: Record<string, unknown>;
+    app_identifier: string | null;
+    listings: Record<string, AppStoreListing>;
+    screenshots: AppStoreScreenshot[];
+    current_version: string | null;
+    submission_status: string;
+    submitted_at: string | null;
+    released_at: string | null;
+    rejection_reason: string | null;
+    is_active: boolean;
+    created_by: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface AppStoreListing {
+    app_name: string;
+    subtitle?: string;
+    short_description?: string;
+    description: string;
+    keywords?: string;
+    whats_new?: string;
+    privacy_policy_url?: string;
+    support_url?: string;
+    marketing_url?: string;
+    primary_category?: string;
+    secondary_category?: string;
+}
+export interface AppStoreScreenshot {
+    device_type: string;
+    display_order: number;
+    storage_url: string;
+    storage_path: string;
+    width: number;
+    height: number;
+    caption: string;
+    background_gradient: string;
+    device_frame: string;
+    locale: string;
+}
+/**
+ * Get app store configs for a product via MCP
+ */
+export declare function getAppStoreConfigs(productId: string, verbose?: boolean): Promise<AppStoreConfig[]>;
+/**
+ * Get a single app store config via MCP
+ */
+export declare function getAppStoreConfig(configId: string, verbose?: boolean): Promise<AppStoreConfig | null>;
+/**
+ * Create or update an app store config via MCP
+ */
+export declare function upsertAppStoreConfig(params: {
+    product_id: string;
+    store_type: string;
+    credentials?: Record<string, unknown>;
+    app_identifier?: string;
+}, verbose?: boolean): Promise<AppStoreConfig | null>;
+/**
+ * Save listings to an app store config via MCP
+ */
+export declare function saveAppStoreListings(configId: string, listings: Record<string, AppStoreListing>, verbose?: boolean): Promise<AppStoreConfig | null>;
+/**
+ * Save screenshots to an app store config via MCP
+ */
+export declare function saveAppStoreScreenshots(configId: string, screenshots: AppStoreScreenshot[], verbose?: boolean): Promise<AppStoreConfig | null>;
+/**
+ * Update submission status via MCP
+ */
+export declare function updateAppStoreStatus(configId: string, updates: {
+    submission_status?: string;
+    current_version?: string;
+    rejection_reason?: string;
+}, verbose?: boolean): Promise<AppStoreConfig | null>;

package/dist/api/app-store.js

@@ -0,0 +1,148 @@
+import { logInfo, logError } from '../utils/logger.js';
+import { callMcpEndpoint } from './mcp-client.js';
+/**
+ * Get app store configs for a product via MCP
+ */
+export async function getAppStoreConfigs(productId, verbose) {
+    if (verbose) {
+        logInfo(`Fetching app store configs for product: ${productId}`);
+    }
+    try {
+        const result = (await callMcpEndpoint('app_store/configs/list', {
+            product_id: productId,
+        }));
+        const text = result.content?.[0]?.text || '[]';
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return [];
+        }
+    }
+    catch (error) {
+        if (verbose) {
+            logError(`Failed to fetch app store configs: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return [];
+    }
+}
+/**
+ * Get a single app store config via MCP
+ */
+export async function getAppStoreConfig(configId, verbose) {
+    try {
+        const result = (await callMcpEndpoint('app_store/configs/get', {
+            config_id: configId,
+        }));
+        const text = result.content?.[0]?.text || 'null';
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return null;
+        }
+    }
+    catch (error) {
+        if (verbose) {
+            logError(`Failed to fetch app store config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return null;
+    }
+}
+/**
+ * Create or update an app store config via MCP
+ */
+export async function upsertAppStoreConfig(params, verbose) {
+    if (verbose) {
+        logInfo(`Upserting app store config for ${params.store_type}`);
+    }
+    try {
+        const result = (await callMcpEndpoint('app_store/configs/upsert', params));
+        const text = result.content?.[0]?.text || 'null';
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return null;
+        }
+    }
+    catch (error) {
+        logError(`Failed to upsert app store config: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Save listings to an app store config via MCP
+ */
+export async function saveAppStoreListings(configId, listings, verbose) {
+    if (verbose) {
+        logInfo(`Saving listings for config: ${configId}`);
+    }
+    try {
+        const result = (await callMcpEndpoint('app_store/configs/save_listings', {
+            config_id: configId,
+            listings,
+        }));
+        const text = result.content?.[0]?.text || 'null';
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return null;
+        }
+    }
+    catch (error) {
+        logError(`Failed to save listings: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Save screenshots to an app store config via MCP
+ */
+export async function saveAppStoreScreenshots(configId, screenshots, verbose) {
+    if (verbose) {
+        logInfo(`Saving ${screenshots.length} screenshots for config: ${configId}`);
+    }
+    try {
+        const result = (await callMcpEndpoint('app_store/configs/save_screenshots', {
+            config_id: configId,
+            screenshots,
+        }));
+        const text = result.content?.[0]?.text || 'null';
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return null;
+        }
+    }
+    catch (error) {
+        logError(`Failed to save screenshots: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Update submission status via MCP
+ */
+export async function updateAppStoreStatus(configId, updates, verbose) {
+    if (verbose) {
+        logInfo(`Updating status for config: ${configId}`);
+    }
+    try {
+        const result = (await callMcpEndpoint('app_store/configs/update_status', {
+            config_id: configId,
+            ...updates,
+        }));
+        const text = result.content?.[0]?.text || 'null';
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return null;
+        }
+    }
+    catch (error) {
+        logError(`Failed to update status: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}

package/dist/api/github.js

@@ -3,31 +3,30 @@
  * Uses product developer configuration from the database
  */
 import { callMcpEndpoint } from './mcp-client.js';
+import { logDebug, logSuccess, logWarning, logError } from '../utils/logger.js';
 /**
  * Get GitHub developer configuration for a feature
  * Returns installation_id, repository info from product_developers
  */
 export async function getGitHubDeveloperConfig(featureId, verbose) {
-    if (verbose) {
-        console.log(`🔍 Fetching GitHub developer config for feature: ${featureId}`);
-    }
+    logDebug(`Fetching GitHub developer config for feature: ${featureId}`, verbose);
     try {
         const result = (await callMcpEndpoint('github/developer_config', {
             feature_id: featureId,
         }));
         if (verbose) {
             if (result.configured) {
-                console.log(`✅ GitHub configured: ${result.repository_full_name}`);
+                logSuccess(`GitHub configured: ${result.repository_full_name}`);
             }
             else {
-                console.log(`⚠️ GitHub not configured: ${result.message}`);
+                logWarning(`GitHub not configured: ${result.message}`);
             }
         }
         return result;
     }
     catch (error) {
         if (verbose) {
-            console.error('❌ Failed to get GitHub developer config:', error);
+            logError(`Failed to get GitHub developer config: ${error instanceof Error ? error.message : String(error)}`);
         }
         return {
             configured: false,
@@ -39,22 +38,20 @@ export async function getGitHubDeveloperConfig(featureId, verbose) {
  * Get installation access token for GitHub API operations
  */
 export async function getGitHubInstallationToken(installationId, featureId, verbose) {
-    if (verbose) {
-        console.log(`🔑 Fetching GitHub installation token for: ${installationId}`);
-    }
+    logDebug(`Fetching GitHub installation token for: ${installationId}`, verbose);
     try {
         const result = (await callMcpEndpoint('github/installation_token', {
             installation_id: installationId,
             feature_id: featureId,
         }));
         if (verbose) {
-            console.log(`✅ GitHub token obtained, expires: ${result.expires_at}`);
+            logSuccess(`GitHub token obtained, expires: ${result.expires_at}`);
         }
         return result;
     }
     catch (error) {
         if (verbose) {
-            console.error('❌ Failed to get GitHub installation token:', error);
+            logError(`Failed to get GitHub installation token: ${error instanceof Error ? error.message : String(error)}`);
         }
         return null;
     }
@@ -64,19 +61,17 @@ export async function getGitHubInstallationToken(installationId, featureId, verb
  * Used for product-level operations like growth analysis.
  */
 export async function getGitHubConfigByProduct(productId, verbose) {
-    if (verbose) {
-        console.log(`🔍 Fetching GitHub config for product: ${productId}`);
-    }
+    logDebug(`Fetching GitHub config for product: ${productId}`, verbose);
     try {
         const result = (await callMcpEndpoint('github/config_and_token_by_product', {
             product_id: productId,
         }));
         if (verbose) {
             if (result.configured) {
-                console.log(`✅ GitHub ready: ${result.repository_full_name}`);
+                logSuccess(`GitHub ready: ${result.repository_full_name}`);
             }
             else {
-                console.log(`⚠️ GitHub not configured: ${result.message}`);
+                logWarning(`GitHub not configured: ${result.message}`);
             }
         }
         if (result.configured && result.token && result.owner && result.repo) {
@@ -95,7 +90,7 @@ export async function getGitHubConfigByProduct(productId, verbose) {
     }
     catch (error) {
         if (verbose) {
-            console.error('❌ Failed to get GitHub config for product:', error);
+            logError(`Failed to get GitHub config for product: ${error instanceof Error ? error.message : String(error)}`);
         }
         return {
             configured: false,
@@ -108,19 +103,17 @@ export async function getGitHubConfigByProduct(productId, verbose) {
  * This is the main entry point for getting GitHub config
  */
 export async function getGitHubConfig(featureId, verbose) {
-    if (verbose) {
-        console.log(`🔍 Fetching GitHub config for feature: ${featureId}`);
-    }
+    logDebug(`Fetching GitHub config for feature: ${featureId}`, verbose);
     try {
         const result = (await callMcpEndpoint('github/config_and_token', {
             feature_id: featureId,
         }));
         if (verbose) {
             if (result.configured) {
-                console.log(`✅ GitHub ready: ${result.repository_full_name}`);
+                logSuccess(`GitHub ready: ${result.repository_full_name}`);
             }
             else {
-                console.log(`⚠️ GitHub not configured: ${result.message}`);
+                logWarning(`GitHub not configured: ${result.message}`);
             }
         }
         if (result.configured && result.token && result.owner && result.repo) {
@@ -139,7 +132,7 @@ export async function getGitHubConfig(featureId, verbose) {
     }
     catch (error) {
         if (verbose) {
-            console.error('❌ Failed to get GitHub config:', error);
+            logError(`Failed to get GitHub config: ${error instanceof Error ? error.message : String(error)}`);
         }
         return {
             configured: false,

package/dist/api/mcp-client.js

@@ -7,6 +7,7 @@
  * Environment variables take precedence over stored auth.
  */
 import { getMcpServerUrl, getMcpToken } from '../auth/auth-store.js';
+import { logDebug, logError } from '../utils/logger.js';
 /**
  * Helper function to make HTTP requests to the MCP server
  * Uses stored auth from `edsger login` or environment variables
@@ -44,7 +45,7 @@ export async function callMcpEndpoint(method, params) {
         return data.result;
     }
     catch (error) {
-        console.error(`MCP call failed for ${method}:`, error instanceof Error ? error.message : String(error));
+        logError(`MCP call failed for ${method}: ${error instanceof Error ? error.message : String(error)}`);
         throw error;
     }
 }
@@ -53,21 +54,15 @@ export async function callMcpEndpoint(method, params) {
  */
 export async function makeMcpRequest(options) {
     const { method, params, verbose } = options;
-    if (verbose) {
-        console.log(`Making MCP request: ${method}`);
-    }
+    logDebug(`Making MCP request: ${method}`, verbose);
     try {
         const result = await callMcpEndpoint(method, params);
-        if (verbose) {
-            console.log(`MCP request successful: ${method}`);
-        }
+        logDebug(`MCP request successful: ${method}`, verbose);
         return result;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        if (verbose) {
-            console.error(`MCP request failed: ${method} - ${errorMessage}`);
-        }
+        logDebug(`MCP request failed: ${method} - ${errorMessage}`, verbose);
         throw error;
     }
 }

package/dist/auth/login.js

@@ -8,7 +8,7 @@ import { createInterface } from 'readline';
 import { execSync } from 'child_process';
 import { platform } from 'os';
 import { saveAuth, loadAuth, clearAuth, getEdsgerBaseUrl, getAuthFilePath } from './auth-store.js';
-import { logInfo, logSuccess, logError, logWarning } from '../utils/logger.js';
+import { logInfo, logSuccess, logError, logWarning, logRaw } from '../utils/logger.js';
 /**
  * Open a URL in the user's default browser
  */
@@ -65,7 +65,7 @@ export async function runLogin() {
     const baseUrl = getEdsgerBaseUrl();
     const authUrl = `${baseUrl}/cli/auth`;
     logInfo('Starting Edsger CLI login...');
-    console.log();
+    logRaw('');
     // Check if already logged in
     const existingAuth = loadAuth();
     if (existingAuth) {
@@ -77,19 +77,19 @@ export async function runLogin() {
         }
     }
     // Open browser
-    console.log(`  Opening browser to: ${authUrl}`);
-    console.log();
+    logInfo(`Opening browser to: ${authUrl}`);
+    logRaw('');
     const opened = openBrowser(authUrl);
     if (!opened) {
         logWarning(`Could not open browser automatically.`);
-        console.log(`  Please open this URL manually:`);
-        console.log(`  ${authUrl}`);
-        console.log();
+        logInfo('Please open this URL manually:');
+        logRaw(`  ${authUrl}`);
+        logRaw('');
     }
-    console.log('  1. Sign in to edsger.ai (if not already signed in)');
-    console.log('  2. Click "Generate CLI Token" on the page');
-    console.log('  3. Copy the CLI Token and paste it below');
-    console.log();
+    logInfo('1. Sign in to edsger.ai (if not already signed in)');
+    logInfo('2. Click "Generate CLI Token" on the page');
+    logInfo('3. Copy the CLI Token and paste it below');
+    logRaw('');
     const mcpServerUrl = process.env.EDSGER_MCP_SERVER_URL || MCP_SERVER_URL;
     // Read token
     const mcpToken = await readLine('CLI Token: ');
@@ -130,19 +130,19 @@ export async function runLogin() {
             loggedInAt: new Date().toISOString(),
             edsgerBaseUrl: baseUrl,
         });
-        console.log();
+        logRaw('');
         logSuccess('Login successful!');
         logInfo(`Credentials saved to ${getAuthFilePath()}`);
         // Show available products
         const products = data.result?.products || [];
         if (products.length > 0) {
-            console.log();
+            logRaw('');
             logInfo(`You have access to ${products.length} product(s):`);
             products.forEach((p, i) => {
-                console.log(`  ${i + 1}. ${p.name} (${p.id})`);
+                logRaw(`  ${i + 1}. ${p.name} (${p.id})`);
             });
         }
-        console.log();
+        logRaw('');
         logInfo('You can now run `edsger` to start processing features.');
     }
     catch (error) {
@@ -173,7 +173,7 @@ export async function runStatus() {
         return;
     }
     logInfo('Login status:');
-    console.log(`  Server: ${auth.mcpServerUrl}`);
-    console.log(`  Logged in at: ${auth.loggedInAt}`);
-    console.log(`  Token: ${auth.mcpToken.substring(0, 8)}...${auth.mcpToken.substring(auth.mcpToken.length - 4)}`);
+    logRaw(`  Server: ${auth.mcpServerUrl}`);
+    logRaw(`  Logged in at: ${auth.loggedInAt}`);
+    logRaw(`  Token: ${auth.mcpToken.substring(0, 8)}...${auth.mcpToken.substring(auth.mcpToken.length - 4)}`);
 }

package/dist/commands/agent-workflow/index.js

@@ -10,7 +10,7 @@
  * 6. Responds to web dashboard commands (pause/resume/stop)
  */
 import { AgentWorkflowProcessor, MAX_CONCURRENCY } from './processor.js';
-import { logInfo, logError, logSuccess, logWarning } from '../../utils/logger.js';
+import { logInfo, logError, logSuccess, logWarning, logRaw } from '../../utils/logger.js';
 import { isLoggedIn } from '../../auth/auth-store.js';
 import { startAutoUpdateChecker, stopAutoUpdateChecker } from '../../updater/auto-updater.js';
 import { startSleepPrevention, stopSleepPrevention } from '../../system/sleep-prevention.js';
@@ -27,10 +27,10 @@ export async function runAgentWorkflow(options) {
     }
     const config = validateConfiguration(options);
     const version = getVersion();
-    console.log();
+    logRaw('');
     logInfo(`Edsger Agent v${version}`);
     logInfo('Cross-product workflow mode');
-    console.log();
+    logRaw('');
     // Set up workspace directory
     const workspaceRoot = ensureWorkspaceDir();
     logInfo(`Workspace: ${workspaceRoot}`);
@@ -44,9 +44,9 @@ export async function runAgentWorkflow(options) {
     startSleepMonitor();
     // Start heartbeat
     startHeartbeat();
-    console.log();
+    logRaw('');
     logSuccess('Agent started. Watching for features...');
-    console.log();
+    logRaw('');
     // Create and start the processor
     let maxConcurrent = 3;
     if (options.concurrency && options.concurrency > 0) {
@@ -71,7 +71,7 @@ export async function runAgentWorkflow(options) {
             processor.stop();
             // Show stats
             const stats = processor.getStats();
-            console.log();
+            logRaw('');
             logInfo('Session Statistics:');
             logInfo(`  Total processed: ${stats.totalProcessed}`);
             logInfo(`  Completed: ${stats.completed}`);

package/dist/commands/agent-workflow/processor.d.ts

@@ -10,7 +10,7 @@
 import { EdsgerConfig } from '../../types/index.js';
 import { type WorkflowStats } from '../workflow/core/state-manager.js';
 /**
- * Maximum allowed concurrency.
+ * Maximum allowed concurrency (hard cap).
  * Limits are due to:
  * - MCP API rate limits (per-minute/per-hour per token)
  * - AI API rate limits (Claude/OpenAI RPM/TPM)

package/dist/commands/agent-workflow/processor.js

@@ -15,9 +15,10 @@ import { getGitHubConfig } from '../../api/github.js';
 import { logInfo, logWarning, logError, logSuccess } from '../../utils/logger.js';
 import { shouldProcess, sendHeartbeat } from '../../system/session-manager.js';
 import { cloneFeatureRepo } from '../../workspace/workspace-manager.js';
+import { WorkerTimeoutError } from '../../errors/index.js';
 import { createInitialState, updateFeatureState, createProcessingState, createCompletedState, createFailedState, calculateStats, } from '../workflow/core/state-manager.js';
 /**
- * Maximum allowed concurrency.
+ * Maximum allowed concurrency (hard cap).
  * Limits are due to:
  * - MCP API rate limits (per-minute/per-hour per token)
  * - AI API rate limits (Claude/OpenAI RPM/TPM)
@@ -41,10 +42,11 @@ export class AgentWorkflowProcessor {
     /** Chat worker subprocess — runs in parallel, handles chat messages and phase events */
     chatWorker;
     constructor(options, config) {
+        const wf = config.workflow;
         this.options = {
-            pollInterval: 30_000,
-            maxConcurrent: 3,
-            maxRetries: 3,
+            pollInterval: options.pollInterval ?? wf.pollInterval,
+            maxConcurrent: Math.min(options.maxConcurrent ?? wf.maxConcurrency, MAX_CONCURRENCY),
+            maxRetries: options.maxRetries ?? wf.maxRetries,
             verbose: false,
             ...options,
         };
@@ -152,6 +154,8 @@ export class AgentWorkflowProcessor {
         // Kill all active feature workers gracefully
         for (const [featureId, worker] of this.activeWorkers) {
             logInfo(`Stopping worker for feature: ${featureId}`);
+            if (worker.timeoutTimer)
+                clearTimeout(worker.timeoutTimer);
             try {
                 worker.process.kill('SIGTERM');
             }
@@ -186,7 +190,7 @@ export class AgentWorkflowProcessor {
                 return;
             }
             // Filter out features already being processed or recently failed
-            const COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes between retries
+            const cooldownMs = this.config.workflow.retryCooldown;
             const newFeatures = features.filter((f) => {
                 if (this.activeWorkers.has(f.id))
                     return false;
@@ -199,7 +203,7 @@ export class AgentWorkflowProcessor {
                     if (state.retryCount >= this.options.maxRetries)
                         return false;
                     // Skip if within cooldown period
-                    if (Date.now() - state.lastAttempt.getTime() < COOLDOWN_MS)
+                    if (Date.now() - state.lastAttempt.getTime() < cooldownMs)
                         return false;
                 }
                 return true;
@@ -319,6 +323,10 @@ export class AgentWorkflowProcessor {
             });
             // Handle worker exit (crash, killed, etc.)
             worker.on('exit', (code) => {
+                // Clear timeout timer
+                const w = this.activeWorkers.get(featureId);
+                if (w?.timeoutTimer)
+                    clearTimeout(w.timeoutTimer);
                 this.activeWorkers.delete(featureId);
                 // If the worker exited without sending a result message, treat as failure
                 if (!resultReceived) {
@@ -328,6 +336,26 @@ export class AgentWorkflowProcessor {
                     this.handleWorkerResult(featureId, feature.name, false, `Worker exited with code ${code}`);
                 }
             });
+            // Set up worker timeout
+            const workerTimeout = this.config.workflow.workerTimeout;
+            activeWorker.timeoutTimer = setTimeout(() => {
+                logError(`Worker for ${feature.name} timed out after ${Math.round(workerTimeout / 1000)}s, killing...`);
+                try {
+                    worker.kill('SIGTERM');
+                    // Force kill after 10s if SIGTERM didn't work
+                    setTimeout(() => {
+                        try {
+                            worker.kill('SIGKILL');
+                        }
+                        catch { /* ignore */ }
+                    }, 10_000);
+                }
+                catch {
+                    // Worker may already be dead
+                }
+                const err = new WorkerTimeoutError(featureId, workerTimeout);
+                this.handleWorkerResult(featureId, feature.name, false, err.message);
+            }, workerTimeout);
             // Send start message to worker
             worker.send({
                 type: 'start',

package/dist/commands/analyze-logs/index.d.ts

@@ -0,0 +1,7 @@
+import { CliOptions } from '../../types/index.js';
+/**
+ * Run AI-powered log analysis for a product.
+ * Analyzes pending user logs (inactive >1 hour) and creates
+ * product feedback for any issues or improvements found.
+ */
+export declare const runAnalyzeLogs: (options: CliOptions) => Promise<void>;

package/dist/commands/analyze-logs/index.js

@@ -0,0 +1,34 @@
+import { logInfo, logError, logSuccess } from '../../utils/logger.js';
+import { analyzeLogs } from '../../phases/analyze-logs/index.js';
+/**
+ * Run AI-powered log analysis for a product.
+ * Analyzes pending user logs (inactive >1 hour) and creates
+ * product feedback for any issues or improvements found.
+ */
+export const runAnalyzeLogs = async (options) => {
+    const productId = options.analyzeLogs;
+    if (!productId) {
+        throw new Error('Product ID is required for log analysis');
+    }
+    logInfo(`Starting log analysis for product: ${productId}`);
+    try {
+        const result = await analyzeLogs({
+            productId,
+            verbose: options.verbose,
+        });
+        if (result.status === 'success') {
+            logSuccess('Log analysis completed!');
+            logInfo(`  Groups processed: ${result.groupsProcessed}`);
+            logInfo(`  Feedbacks created: ${result.feedbacksCreated}`);
+            logInfo(`  Logs analyzed: ${result.logsAnalyzed}`);
+        }
+        else {
+            logError(`Log analysis failed: ${result.summary}`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        logError(`Log analysis failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+};

package/dist/commands/app-store/index.d.ts

@@ -0,0 +1,12 @@
+import { CliOptions } from '../../types/index.js';
+/**
+ * Run AI-powered app store asset generation for a product.
+ * Generates professional screenshots and optimized listing content.
+ */
+export declare const runAppStoreGeneration: (options: CliOptions & {
+    appStoreProductId: string;
+    store?: string;
+    locale?: string;
+    screenshotsOnly?: boolean;
+    listingsOnly?: boolean;
+}) => Promise<void>;